samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Bifurcation 0
Code Tickets Demandes d'ajout Actions Paquets Projets Publications Wiki Activité
Fichiers
0be3bb02d9ae472b8fbc1a8d4530a6af6ee152b7
android_kernel_samsung_sm86…/hal/wifi3.0/li/hal_li_rx.h
Jeff Johnson 15b6ef6b0e qcacmn: Fix hal/wifi3.0/li documentation 
The kernel-doc script identified some documentation issues in the
hal/wifi3.0/li folder, so fix them.

Change-Id: I4ac9d051ac1ba23ddeecdf1b1bb88b939956795e
CRs-Fixed: 3390587
2023-02-07 18:04:49 -08:00

1174 lignes
37 KiB
C
Brut Annotations Historique

/*
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. 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_LI_RX_H_
#define _HAL_LI_RX_H_
#include <hal_rx.h>
/*
* macro to set the cookie into the rxdma ring entry
*/
#define HAL_RXDMA_COOKIE_SET(buff_addr_info, cookie) \
((*(((unsigned int *)buff_addr_info) + \
(BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET >> 2))) &= \
~BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK); \
((*(((unsigned int *)buff_addr_info) + \
(BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET >> 2))) |= \
((cookie) << BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB) & \
BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK)
/*
* macro to set the manager into the rxdma ring entry
*/
#define HAL_RXDMA_MANAGER_SET(buff_addr_info, manager) \
((*(((unsigned int *)buff_addr_info) + \
(BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET >> 2))) &= \
~BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK); \
((*(((unsigned int *)buff_addr_info) + \
(BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET >> 2))) |= \
((manager) << BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB) & \
BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK)
#define HAL_RX_ERROR_STATUS_GET(reo_desc) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(reo_desc, \
REO_DESTINATION_RING_7_REO_PUSH_REASON_OFFSET)),\
REO_DESTINATION_RING_7_REO_PUSH_REASON_MASK, \
REO_DESTINATION_RING_7_REO_PUSH_REASON_LSB))
#define HAL_RX_BUF_COOKIE_GET(buff_addr_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \
BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET)), \
BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK, \
BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB))
#define HAL_RX_BUF_RBM_GET(buff_addr_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \
BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET)),\
BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK, \
BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB))
/* TODO: Convert the following structure fields accesseses to offsets */
#define HAL_RX_REO_BUF_COOKIE_GET(reo_desc) \
(HAL_RX_BUF_COOKIE_GET(& \
(((struct reo_destination_ring *) \
reo_desc)->buf_or_link_desc_addr_info)))
#define HAL_RX_MPDU_SEQUENCE_NUMBER_GET(mpdu_info_ptr) \
((mpdu_info_ptr \
[RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_MASK) >> \
RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_LSB)
#define HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info_ptr) \
((mpdu_info_ptr \
[RX_MPDU_DESC_INFO_1_PEER_META_DATA_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_1_PEER_META_DATA_MASK) >> \
RX_MPDU_DESC_INFO_1_PEER_META_DATA_LSB)
#define HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info_ptr) \
((mpdu_info_ptr[RX_MPDU_DESC_INFO_0_MSDU_COUNT_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_MSDU_COUNT_MASK) >> \
RX_MPDU_DESC_INFO_0_MSDU_COUNT_LSB)
#define HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) \
(mpdu_info_ptr[RX_MPDU_DESC_INFO_0_FRAGMENT_FLAG_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_FRAGMENT_FLAG_MASK)
#define HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) \
(mpdu_info_ptr[RX_MPDU_DESC_INFO_0_MPDU_RETRY_BIT_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_MPDU_RETRY_BIT_MASK)
#define HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) \
(mpdu_info_ptr[RX_MPDU_DESC_INFO_0_AMPDU_FLAG_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_AMPDU_FLAG_MASK)
#define HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr) \
(mpdu_info_ptr[RX_MPDU_DESC_INFO_0_RAW_MPDU_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_RAW_MPDU_MASK)
#define HAL_RX_MPDU_FLAGS_GET(mpdu_info_ptr) \
(HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) | \
HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) | \
HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) | \
HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr))
#define HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info_ptr) \
((mpdu_info_ptr[RX_MPDU_DESC_INFO_0_BAR_FRAME_OFFSET >> 2] & \
RX_MPDU_DESC_INFO_0_BAR_FRAME_MASK) >> \
RX_MPDU_DESC_INFO_0_BAR_FRAME_LSB)
/*
* NOTE: None of the following _GET macros need a right
* shift by the corresponding _LSB. This is because, they are
* finally taken and "OR'ed" into a single word again.
*/
#define HAL_RX_MSDU_CONTINUATION_FLAG_SET(msdu_info_ptr, val) \
((*(((uint32_t *)msdu_info_ptr) + \
(RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_OFFSET >> 2))) |= \
((val) << RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_LSB) & \
RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_MASK)
#define HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_OFFSET)) & \
RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_MASK)
#define HAL_RX_MSDU_REO_DST_IND_GET(msdu_info_ptr) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_OFFSET)), \
RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_MASK, \
RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_LSB))
#define HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_SA_IS_VALID_OFFSET)) & \
RX_MSDU_DESC_INFO_0_SA_IS_VALID_MASK)
#define HAL_RX_MSDU_SA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_SA_IDX_TIMEOUT_OFFSET)) & \
RX_MSDU_DESC_INFO_0_SA_IDX_TIMEOUT_MASK)
#define HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_DA_IS_VALID_OFFSET)) & \
RX_MSDU_DESC_INFO_0_DA_IS_VALID_MASK)
#define HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_DA_IS_MCBC_OFFSET)) & \
RX_MSDU_DESC_INFO_0_DA_IS_MCBC_MASK)
#define HAL_RX_MSDU_DA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) \
((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \
RX_MSDU_DESC_INFO_0_DA_IDX_TIMEOUT_OFFSET)) & \
RX_MSDU_DESC_INFO_0_DA_IDX_TIMEOUT_MASK)
#define HAL_RX_REO_MSDU_REO_DST_IND_GET(reo_desc) \
(HAL_RX_MSDU_REO_DST_IND_GET(& \
(((struct reo_destination_ring *) \
reo_desc)->rx_msdu_desc_info_details)))
#define HAL_RX_MPDU_ENCRYPT_TYPE_GET(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_3_ENCRYPT_TYPE_OFFSET)), \
RX_MPDU_INFO_3_ENCRYPT_TYPE_MASK, \
RX_MPDU_INFO_3_ENCRYPT_TYPE_LSB))
#define HAL_RX_MSDU_DESC_INFO_SET(_msdu_info_ptr, _field, _val) \
HAL_RX_FLD_SET(_msdu_info_ptr, RX_MSDU_DESC_INFO_0, \
_field, _val)
#define HAL_RX_MPDU_DESC_INFO_SET(_mpdu_info_ptr, _field, _val) \
HAL_RX_FLD_SET(_mpdu_info_ptr, RX_MPDU_DESC_INFO_0, \
_field, _val)
/*
* Structures & Macros to obtain fields from the TLV's in the Rx packet
* pre-header.
*/
/*
* Every Rx packet starts at an offset from the top of the buffer.
* If the host hasn't subscribed to any specific TLV, there is
* still space reserved for the following TLV's from the start of
* the buffer:
* -- RX ATTENTION
* -- RX MPDU START
* -- RX MSDU START
* -- RX MSDU END
* -- RX MPDU END
* -- RX PACKET HEADER (802.11)
* If the host subscribes to any of the TLV's above, that TLV
* if populated by the HW
*/
#define NUM_DWORDS_TAG 1
/* By default the packet header TLV is 128 bytes */
#define NUM_OF_BYTES_RX_802_11_HDR_TLV 128
#define NUM_OF_DWORDS_RX_802_11_HDR_TLV \
(NUM_OF_BYTES_RX_802_11_HDR_TLV >> 2)
#define RX_PKT_OFFSET_WORDS \
( \
NUM_OF_DWORDS_RX_ATTENTION + NUM_DWORDS_TAG \
NUM_OF_DWORDS_RX_MPDU_START + NUM_DWORDS_TAG \
NUM_OF_DWORDS_RX_MSDU_START + NUM_DWORDS_TAG \
NUM_OF_DWORDS_RX_MSDU_END + NUM_DWORDS_TAG \
NUM_OF_DWORDS_RX_MPDU_END + NUM_DWORDS_TAG \
NUM_OF_DWORDS_RX_802_11_HDR_TLV + NUM_DWORDS_TAG \
)
#define RX_PKT_OFFSET_BYTES \
(RX_PKT_OFFSET_WORDS << 2)
#define RX_PKT_HDR_TLV_LEN 120
/*
* Each RX descriptor TLV is preceded by 1 DWORD "tag"
*/
struct rx_attention_tlv {
uint32_t tag;
struct rx_attention rx_attn;
};
struct rx_mpdu_start_tlv {
uint32_t tag;
struct rx_mpdu_start rx_mpdu_start;
};
struct rx_msdu_start_tlv {
uint32_t tag;
struct rx_msdu_start rx_msdu_start;
};
struct rx_msdu_end_tlv {
uint32_t tag;
struct rx_msdu_end rx_msdu_end;
};
struct rx_mpdu_end_tlv {
uint32_t tag;
struct rx_mpdu_end rx_mpdu_end;
};
struct rx_pkt_hdr_tlv {
uint32_t tag; /* 4 B */
uint32_t phy_ppdu_id; /* 4 B */
char rx_pkt_hdr[RX_PKT_HDR_TLV_LEN]; /* 120 B */
};
/* rx_pkt_tlvs structure should be used to process Data buffers, monitor status
* buffers, monitor destination buffers and monitor descriptor buffers.
*/
#ifdef RXDMA_OPTIMIZATION
/*
* The RX_PADDING_BYTES is required so that the TLV's don't
* spread across the 128 byte boundary
* RXDMA optimization requires:
* 1) MSDU_END & ATTENTION TLV's follow in that order
* 2) TLV's don't span across 128 byte lines
* 3) Rx Buffer is nicely aligned on the 128 byte boundary
*/
#define RX_PADDING0_BYTES 4
#define RX_PADDING1_BYTES 16
#if defined(IPA_OFFLOAD) && defined(IPA_WDS_EASYMESH_FEATURE)
struct rx_pkt_tlvs {
struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */
struct rx_attention_tlv attn_tlv; /* 16 bytes */
struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */
struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */
uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */
struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */
uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */
#ifndef NO_RX_PKT_HDR_TLV
struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */
#endif
};
#else
struct rx_pkt_tlvs {
struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */
struct rx_attention_tlv attn_tlv; /* 16 bytes */
struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */
uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */
struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */
struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */
uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */
#ifndef NO_RX_PKT_HDR_TLV
struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */
#endif
};
#endif
#else /* RXDMA_OPTIMIZATION */
struct rx_pkt_tlvs {
struct rx_attention_tlv attn_tlv;
struct rx_mpdu_start_tlv mpdu_start_tlv;
struct rx_msdu_start_tlv msdu_start_tlv;
struct rx_msdu_end_tlv msdu_end_tlv;
struct rx_mpdu_end_tlv mpdu_end_tlv;
struct rx_pkt_hdr_tlv pkt_hdr_tlv;
};
#endif /* RXDMA_OPTIMIZATION */
/* rx_mon_pkt_tlvs structure should be used to process monitor data buffers */
#ifdef RXDMA_OPTIMIZATION
struct rx_mon_pkt_tlvs {
struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */
struct rx_attention_tlv attn_tlv; /* 16 bytes */
struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */
uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */
struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */
struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */
uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */
struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */
};
#else /* RXDMA_OPTIMIZATION */
struct rx_mon_pkt_tlvs {
struct rx_attention_tlv attn_tlv;
struct rx_mpdu_start_tlv mpdu_start_tlv;
struct rx_msdu_start_tlv msdu_start_tlv;
struct rx_msdu_end_tlv msdu_end_tlv;
struct rx_mpdu_end_tlv mpdu_end_tlv;
struct rx_pkt_hdr_tlv pkt_hdr_tlv;
};
#endif
#define SIZE_OF_MONITOR_TLV sizeof(struct rx_mon_pkt_tlvs)
#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)
#define HAL_RX_PKT_TLV_MPDU_START_OFFSET(hal_soc) \
RX_PKT_TLV_OFFSET(mpdu_start_tlv)
#define HAL_RX_PKT_TLV_MPDU_END_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(mpdu_end_tlv)
#define HAL_RX_PKT_TLV_MSDU_START_OFFSET(hal_soc) \
RX_PKT_TLV_OFFSET(msdu_start_tlv)
#define HAL_RX_PKT_TLV_MSDU_END_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(msdu_end_tlv)
#define HAL_RX_PKT_TLV_ATTN_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(attn_tlv)
#define HAL_RX_PKT_TLV_PKT_HDR_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(pkt_hdr_tlv)
/**
* hal_rx_get_pkt_tlvs(): Function to retrieve pkt tlvs from nbuf
* @rx_buf_start: Pointer to data buffer field
*
* Return: pointer to rx_pkt_tlvs
*/
static inline
struct rx_pkt_tlvs *hal_rx_get_pkt_tlvs(uint8_t *rx_buf_start)
{
return (struct rx_pkt_tlvs *)rx_buf_start;
}
/**
* hal_rx_get_mpdu_info(): Function to retrieve mpdu info from pkt tlvs
* @pkt_tlvs: Pointer to pkt_tlvs
*
* Return: pointer to rx_mpdu_info structure
*/
static inline
struct rx_mpdu_info *hal_rx_get_mpdu_info(struct rx_pkt_tlvs *pkt_tlvs)
{
return &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start.rx_mpdu_info_details;
}
/**
* hal_rx_mon_dest_get_buffer_info_from_tlv(): Retrieve mon dest frame info
* from the reserved bytes of rx_tlv_hdr.
* @buf: start of rx_tlv_hdr
* @buf_info: hal_rx_mon_dest_buf_info structure
*
* Return: void
*/
static inline void hal_rx_mon_dest_get_buffer_info_from_tlv(
uint8_t *buf,
struct hal_rx_mon_dest_buf_info *buf_info)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
qdf_mem_copy(buf_info, pkt_tlvs->rx_padding0,
sizeof(struct hal_rx_mon_dest_buf_info));
}
/*
* Get msdu_done bit from the RX_ATTENTION TLV
*/
#define HAL_RX_ATTN_MSDU_DONE_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_2_MSDU_DONE_OFFSET)), \
RX_ATTENTION_2_MSDU_DONE_MASK, \
RX_ATTENTION_2_MSDU_DONE_LSB))
#define HAL_RX_ATTN_FIRST_MPDU_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_1_FIRST_MPDU_OFFSET)), \
RX_ATTENTION_1_FIRST_MPDU_MASK, \
RX_ATTENTION_1_FIRST_MPDU_LSB))
#define HAL_RX_ATTN_TCP_UDP_CKSUM_FAIL_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_OFFSET)), \
RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_MASK, \
RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_LSB))
/**
* hal_rx_attn_tcp_udp_cksum_fail_get() - get tcp_udp cksum fail bit
* from rx attention
* @buf: pointer to rx_pkt_tlvs
*
* Return: tcp_udp_cksum_fail
*/
static inline bool
hal_rx_attn_tcp_udp_cksum_fail_get(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn;
uint8_t tcp_udp_cksum_fail;
tcp_udp_cksum_fail = HAL_RX_ATTN_TCP_UDP_CKSUM_FAIL_GET(rx_attn);
return !!tcp_udp_cksum_fail;
}
#define HAL_RX_ATTN_IP_CKSUM_FAIL_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_1_IP_CHKSUM_FAIL_OFFSET)), \
RX_ATTENTION_1_IP_CHKSUM_FAIL_MASK, \
RX_ATTENTION_1_IP_CHKSUM_FAIL_LSB))
/**
* hal_rx_attn_ip_cksum_fail_get() - get ip cksum fail bit
* from rx attention
* @buf: pointer to rx_pkt_tlvs
*
* Return: ip_cksum_fail
*/
static inline bool
hal_rx_attn_ip_cksum_fail_get(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn;
uint8_t ip_cksum_fail;
ip_cksum_fail = HAL_RX_ATTN_IP_CKSUM_FAIL_GET(rx_attn);
return !!ip_cksum_fail;
}
#define HAL_RX_ATTN_PHY_PPDU_ID_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_0_PHY_PPDU_ID_OFFSET)), \
RX_ATTENTION_0_PHY_PPDU_ID_MASK, \
RX_ATTENTION_0_PHY_PPDU_ID_LSB))
#define HAL_RX_ATTN_CCE_MATCH_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_1_CCE_MATCH_OFFSET)), \
RX_ATTENTION_1_CCE_MATCH_MASK, \
RX_ATTENTION_1_CCE_MATCH_LSB))
/**
* hal_rx_msdu_cce_match_get_li() - 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_li(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn;
uint8_t cce_match_val;
cce_match_val = HAL_RX_ATTN_CCE_MATCH_GET(rx_attn);
return !!cce_match_val;
}
/*
* Get peer_meta_data from RX_MPDU_INFO within RX_MPDU_START
*/
#define HAL_RX_MPDU_PEER_META_DATA_GET(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_8_PEER_META_DATA_OFFSET)), \
RX_MPDU_INFO_8_PEER_META_DATA_MASK, \
RX_MPDU_INFO_8_PEER_META_DATA_LSB))
static inline uint32_t
hal_rx_mpdu_peer_meta_data_get_li(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_mpdu_start *mpdu_start =
&pkt_tlvs->mpdu_start_tlv.rx_mpdu_start;
struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details;
uint32_t peer_meta_data;
peer_meta_data = HAL_RX_MPDU_PEER_META_DATA_GET(mpdu_info);
return peer_meta_data;
}
#define HAL_RX_MPDU_INFO_AMPDU_FLAG_GET(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_12_AMPDU_FLAG_OFFSET)), \
RX_MPDU_INFO_12_AMPDU_FLAG_MASK, \
RX_MPDU_INFO_12_AMPDU_FLAG_LSB))
#define HAL_RX_MPDU_PEER_META_DATA_SET(_rx_mpdu_info, peer_mdata) \
((*(((uint32_t *)_rx_mpdu_info) + \
(RX_MPDU_INFO_8_PEER_META_DATA_OFFSET >> 2))) = \
((peer_mdata) << RX_MPDU_INFO_8_PEER_META_DATA_LSB) & \
RX_MPDU_INFO_8_PEER_META_DATA_MASK)
/**
* 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(uint8_t *buf, uint32_t peer_mdata)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_mpdu_start *mpdu_start =
&pkt_tlvs->mpdu_start_tlv.rx_mpdu_start;
struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details;
HAL_RX_MPDU_PEER_META_DATA_SET(mpdu_info, peer_mdata);
}
/*
* LRO information needed from the TLVs
*/
#define HAL_RX_TLV_GET_LRO_ELIGIBLE(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_end_tlv.rx_msdu_end), \
RX_MSDU_END_9_LRO_ELIGIBLE_OFFSET)), \
RX_MSDU_END_9_LRO_ELIGIBLE_MASK, \
RX_MSDU_END_9_LRO_ELIGIBLE_LSB))
#define HAL_RX_TLV_GET_TCP_ACK(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_end_tlv.rx_msdu_end), \
RX_MSDU_END_8_TCP_ACK_NUMBER_OFFSET)), \
RX_MSDU_END_8_TCP_ACK_NUMBER_MASK, \
RX_MSDU_END_8_TCP_ACK_NUMBER_LSB))
#define HAL_RX_TLV_GET_TCP_SEQ(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_end_tlv.rx_msdu_end), \
RX_MSDU_END_7_TCP_SEQ_NUMBER_OFFSET)), \
RX_MSDU_END_7_TCP_SEQ_NUMBER_MASK, \
RX_MSDU_END_7_TCP_SEQ_NUMBER_LSB))
#define HAL_RX_TLV_GET_TCP_WIN(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_end_tlv.rx_msdu_end), \
RX_MSDU_END_9_WINDOW_SIZE_OFFSET)), \
RX_MSDU_END_9_WINDOW_SIZE_MASK, \
RX_MSDU_END_9_WINDOW_SIZE_LSB))
#define HAL_RX_TLV_GET_TCP_PURE_ACK(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_2_TCP_ONLY_ACK_OFFSET)), \
RX_MSDU_START_2_TCP_ONLY_ACK_MASK, \
RX_MSDU_START_2_TCP_ONLY_ACK_LSB))
#define HAL_RX_TLV_GET_TCP_PROTO(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_2_TCP_PROTO_OFFSET)), \
RX_MSDU_START_2_TCP_PROTO_MASK, \
RX_MSDU_START_2_TCP_PROTO_LSB))
#define HAL_RX_TLV_GET_UDP_PROTO(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_2_UDP_PROTO_OFFSET)), \
RX_MSDU_START_2_UDP_PROTO_MASK, \
RX_MSDU_START_2_UDP_PROTO_LSB))
#define HAL_RX_TLV_GET_IPV6(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_2_IPV6_PROTO_OFFSET)), \
RX_MSDU_START_2_IPV6_PROTO_MASK, \
RX_MSDU_START_2_IPV6_PROTO_LSB))
#define HAL_RX_TLV_GET_IP_OFFSET(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_1_L3_OFFSET_OFFSET)), \
RX_MSDU_START_1_L3_OFFSET_MASK, \
RX_MSDU_START_1_L3_OFFSET_LSB))
#define HAL_RX_TLV_GET_TCP_OFFSET(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_1_L4_OFFSET_OFFSET)), \
RX_MSDU_START_1_L4_OFFSET_MASK, \
RX_MSDU_START_1_L4_OFFSET_LSB))
#define HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(buf) \
(_HAL_MS( \
(*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\
msdu_start_tlv.rx_msdu_start), \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_OFFSET)), \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_MASK, \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_LSB))
#define HAL_RX_MSDU_START_MSDU_LEN_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \
RX_MSDU_START_1_MSDU_LENGTH_OFFSET)), \
RX_MSDU_START_1_MSDU_LENGTH_MASK, \
RX_MSDU_START_1_MSDU_LENGTH_LSB))
#define HAL_RX_MSDU_START_BW_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\
RX_MSDU_START_5_RECEIVE_BANDWIDTH_OFFSET)), \
RX_MSDU_START_5_RECEIVE_BANDWIDTH_MASK, \
RX_MSDU_START_5_RECEIVE_BANDWIDTH_LSB))
#define HAL_RX_MSDU_START_FLOWID_TOEPLITZ_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_OFFSET)), \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_MASK, \
RX_MSDU_START_4_FLOW_ID_TOEPLITZ_LSB))
/**
* hal_rx_msdu_start_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_msdu_start_toeplitz_get(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_msdu_start *msdu_start =
&pkt_tlvs->msdu_start_tlv.rx_msdu_start;
return HAL_RX_MSDU_START_FLOWID_TOEPLITZ_GET(msdu_start);
}
#define HAL_RX_MSDU_START_SGI_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\
RX_MSDU_START_5_SGI_OFFSET)), \
RX_MSDU_START_5_SGI_MASK, \
RX_MSDU_START_5_SGI_LSB))
#define HAL_RX_MSDU_START_RATE_MCS_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\
RX_MSDU_START_5_RATE_MCS_OFFSET)), \
RX_MSDU_START_5_RATE_MCS_MASK, \
RX_MSDU_START_5_RATE_MCS_LSB))
#define HAL_RX_ATTN_DECRYPT_STATUS_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_2_DECRYPT_STATUS_CODE_OFFSET)), \
RX_ATTENTION_2_DECRYPT_STATUS_CODE_MASK, \
RX_ATTENTION_2_DECRYPT_STATUS_CODE_LSB))
/*
* Get key index from RX_MSDU_END
*/
#define HAL_RX_MSDU_END_KEYID_OCTET_GET(_rx_msdu_end) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_end, \
RX_MSDU_END_2_KEY_ID_OCTET_OFFSET)), \
RX_MSDU_END_2_KEY_ID_OCTET_MASK, \
RX_MSDU_END_2_KEY_ID_OCTET_LSB))
#define HAL_RX_MSDU_START_RSSI_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \
RX_MSDU_START_5_USER_RSSI_OFFSET)), \
RX_MSDU_START_5_USER_RSSI_MASK, \
RX_MSDU_START_5_USER_RSSI_LSB))
/**
* hal_rx_msdu_start_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_msdu_start_get_rssi(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_msdu_start *msdu_start =
&pkt_tlvs->msdu_start_tlv.rx_msdu_start;
uint32_t rssi;
rssi = HAL_RX_MSDU_START_RSSI_GET(msdu_start);
return rssi;
}
#define HAL_RX_MSDU_START_FREQ_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \
RX_MSDU_START_7_SW_PHY_META_DATA_OFFSET)), \
RX_MSDU_START_7_SW_PHY_META_DATA_MASK, \
RX_MSDU_START_7_SW_PHY_META_DATA_LSB))
#define HAL_RX_MSDU_START_PKT_TYPE_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \
RX_MSDU_START_5_PKT_TYPE_OFFSET)), \
RX_MSDU_START_5_PKT_TYPE_MASK, \
RX_MSDU_START_5_PKT_TYPE_LSB))
#define HAL_RX_MPDU_AD4_31_0_GET(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_OFFSET)), \
RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_MASK, \
RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_LSB))
#define HAL_RX_MPDU_AD4_47_32_GET(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_OFFSET)), \
RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_MASK, \
RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_LSB))
/*******************************************************************************
* RX ERROR APIS
******************************************************************************/
#define HAL_RX_MPDU_END_DECRYPT_ERR_GET(_rx_mpdu_end) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_mpdu_end),\
RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_OFFSET)), \
RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_MASK, \
RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_LSB))
#define HAL_RX_MPDU_END_MIC_ERR_GET(_rx_mpdu_end) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_mpdu_end),\
RX_MPDU_END_1_TKIP_MIC_ERR_OFFSET)), \
RX_MPDU_END_1_TKIP_MIC_ERR_MASK, \
RX_MPDU_END_1_TKIP_MIC_ERR_LSB))
/*******************************************************************************
* RX REO ERROR APIS
******************************************************************************/
#define HAL_RX_REO_BUF_TYPE_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \
(REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_OFFSET >> 2))) & \
REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_MASK) >> \
REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_LSB)
#define HAL_RX_REO_QUEUE_NUMBER_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \
(REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_OFFSET >> 2))) & \
REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_MASK) >> \
REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_LSB)
#define HAL_RX_REO_ERROR_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \
(REO_DESTINATION_RING_7_REO_ERROR_CODE_OFFSET >> 2))) & \
REO_DESTINATION_RING_7_REO_ERROR_CODE_MASK) >> \
REO_DESTINATION_RING_7_REO_ERROR_CODE_LSB)
/**
* hal_rx_msdu_link_desc_reinject() - Re-injects the MSDU link
* descriptor to REO entrance ring
*
* @soc: HAL version of the SOC pointer
* @pa: Physical address of the MSDU Link Descriptor
* @cookie: SW cookie to get to the virtual address
* @error_enabled_reo_q: Argument to determine whether this needs to go
* to the error enabled REO queue
*
* Return: void
*/
static inline
void hal_rx_msdu_link_desc_reinject(struct hal_soc *soc,
uint64_t pa,
uint32_t cookie,
bool error_enabled_reo_q)
{
/* TODO */
}
#define HAL_RX_WBM_FIRST_MSDU_GET(wbm_desc) \
(((*(((uint32_t *)wbm_desc) + \
(WBM_RELEASE_RING_4_FIRST_MSDU_OFFSET >> 2))) & \
WBM_RELEASE_RING_4_FIRST_MSDU_MASK) >> \
WBM_RELEASE_RING_4_FIRST_MSDU_LSB)
#define HAL_RX_WBM_LAST_MSDU_GET(wbm_desc) \
(((*(((uint32_t *)wbm_desc) + \
(WBM_RELEASE_RING_4_LAST_MSDU_OFFSET >> 2))) & \
WBM_RELEASE_RING_4_LAST_MSDU_MASK) >> \
WBM_RELEASE_RING_4_LAST_MSDU_LSB)
#define HAL_RX_WBM_BUF_COOKIE_GET(wbm_desc) \
HAL_RX_BUF_COOKIE_GET(&((struct wbm_release_ring *) \
wbm_desc)->released_buff_or_desc_addr_info)
#define HAL_RX_WBM_BUF_ADDR_39_32_GET(wbm_desc) \
(HAL_RX_BUFFER_ADDR_39_32_GET(& \
(((struct wbm_release_ring *) \
wbm_desc)->released_buff_or_desc_addr_info)))
#define HAL_RX_WBM_BUF_ADDR_31_0_GET(wbm_desc) \
(HAL_RX_BUFFER_ADDR_31_0_GET(& \
(((struct wbm_release_ring *) \
wbm_desc)->released_buff_or_desc_addr_info)))
static inline
uint32_t
HAL_RX_DESC_GET_DECAP_FORMAT(void *hw_desc_addr) {
struct rx_msdu_start *rx_msdu_start;
struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)hw_desc_addr;
rx_msdu_start = &rx_desc->msdu_start_tlv.rx_msdu_start;
return HAL_RX_GET(rx_msdu_start, RX_MSDU_START_2, DECAP_FORMAT);
}
/**
* hal_rx_dump_rx_attention_tlv() - dump RX attention TLV in structured
* human readable format.
* @rx_attn: pointer the rx_attention TLV in pkt.
* @dbg_level: log level.
*
* Return: void
*/
static inline void hal_rx_dump_rx_attention_tlv(struct rx_attention *rx_attn,
uint8_t dbg_level)
{
hal_verbose_debug("rx_attention tlv (1/2) - "
"rxpcu_mpdu_filter_in_category: %x "
"sw_frame_group_id: %x "
"reserved_0: %x "
"phy_ppdu_id: %x "
"first_mpdu : %x "
"reserved_1a: %x "
"mcast_bcast: %x "
"ast_index_not_found: %x "
"ast_index_timeout: %x "
"power_mgmt: %x "
"non_qos: %x "
"null_data: %x "
"mgmt_type: %x "
"ctrl_type: %x "
"more_data: %x "
"eosp: %x "
"a_msdu_error: %x "
"fragment_flag: %x "
"order: %x "
"cce_match: %x "
"overflow_err: %x "
"msdu_length_err: %x "
"tcp_udp_chksum_fail: %x "
"ip_chksum_fail: %x "
"sa_idx_invalid: %x "
"da_idx_invalid: %x "
"reserved_1b: %x "
"rx_in_tx_decrypt_byp: %x ",
rx_attn->rxpcu_mpdu_filter_in_category,
rx_attn->sw_frame_group_id,
rx_attn->reserved_0,
rx_attn->phy_ppdu_id,
rx_attn->first_mpdu,
rx_attn->reserved_1a,
rx_attn->mcast_bcast,
rx_attn->ast_index_not_found,
rx_attn->ast_index_timeout,
rx_attn->power_mgmt,
rx_attn->non_qos,
rx_attn->null_data,
rx_attn->mgmt_type,
rx_attn->ctrl_type,
rx_attn->more_data,
rx_attn->eosp,
rx_attn->a_msdu_error,
rx_attn->fragment_flag,
rx_attn->order,
rx_attn->cce_match,
rx_attn->overflow_err,
rx_attn->msdu_length_err,
rx_attn->tcp_udp_chksum_fail,
rx_attn->ip_chksum_fail,
rx_attn->sa_idx_invalid,
rx_attn->da_idx_invalid,
rx_attn->reserved_1b,
rx_attn->rx_in_tx_decrypt_byp);
hal_verbose_debug("rx_attention tlv (2/2) - "
"encrypt_required: %x "
"directed: %x "
"buffer_fragment: %x "
"mpdu_length_err: %x "
"tkip_mic_err: %x "
"decrypt_err: %x "
"unencrypted_frame_err: %x "
"fcs_err: %x "
"flow_idx_timeout: %x "
"flow_idx_invalid: %x "
"wifi_parser_error: %x "
"amsdu_parser_error: %x "
"sa_idx_timeout: %x "
"da_idx_timeout: %x "
"msdu_limit_error: %x "
"da_is_valid: %x "
"da_is_mcbc: %x "
"sa_is_valid: %x "
"decrypt_status_code: %x "
"rx_bitmap_not_updated: %x "
"reserved_2: %x "
"msdu_done: %x ",
rx_attn->encrypt_required,
rx_attn->directed,
rx_attn->buffer_fragment,
rx_attn->mpdu_length_err,
rx_attn->tkip_mic_err,
rx_attn->decrypt_err,
rx_attn->unencrypted_frame_err,
rx_attn->fcs_err,
rx_attn->flow_idx_timeout,
rx_attn->flow_idx_invalid,
rx_attn->wifi_parser_error,
rx_attn->amsdu_parser_error,
rx_attn->sa_idx_timeout,
rx_attn->da_idx_timeout,
rx_attn->msdu_limit_error,
rx_attn->da_is_valid,
rx_attn->da_is_mcbc,
rx_attn->sa_is_valid,
rx_attn->decrypt_status_code,
rx_attn->rx_bitmap_not_updated,
rx_attn->reserved_2,
rx_attn->msdu_done);
}
/**
* hal_rx_dump_mpdu_end_tlv() - dump RX mpdu_end TLV in structured
* human readable format.
* @mpdu_end: pointer the mpdu_end TLV in pkt.
* @dbg_level: log level.
*
* Return: void
*/
static inline void hal_rx_dump_mpdu_end_tlv(struct rx_mpdu_end *mpdu_end,
uint8_t dbg_level)
{
hal_verbose_debug("rx_mpdu_end tlv - "
"rxpcu_mpdu_filter_in_category: %x "
"sw_frame_group_id: %x "
"phy_ppdu_id: %x "
"unsup_ktype_short_frame: %x "
"rx_in_tx_decrypt_byp: %x "
"overflow_err: %x "
"mpdu_length_err: %x "
"tkip_mic_err: %x "
"decrypt_err: %x "
"unencrypted_frame_err: %x "
"pn_fields_contain_valid_info: %x "
"fcs_err: %x "
"msdu_length_err: %x "
"rxdma0_destination_ring: %x "
"rxdma1_destination_ring: %x "
"decrypt_status_code: %x "
"rx_bitmap_not_updated: %x ",
mpdu_end->rxpcu_mpdu_filter_in_category,
mpdu_end->sw_frame_group_id,
mpdu_end->phy_ppdu_id,
mpdu_end->unsup_ktype_short_frame,
mpdu_end->rx_in_tx_decrypt_byp,
mpdu_end->overflow_err,
mpdu_end->mpdu_length_err,
mpdu_end->tkip_mic_err,
mpdu_end->decrypt_err,
mpdu_end->unencrypted_frame_err,
mpdu_end->pn_fields_contain_valid_info,
mpdu_end->fcs_err,
mpdu_end->msdu_length_err,
mpdu_end->rxdma0_destination_ring,
mpdu_end->rxdma1_destination_ring,
mpdu_end->decrypt_status_code,
mpdu_end->rx_bitmap_not_updated);
}
#ifdef NO_RX_PKT_HDR_TLV
static inline void hal_rx_dump_pkt_hdr_tlv(struct rx_pkt_tlvs *pkt_tlvs,
uint8_t dbg_level)
{
}
#else
/**
* hal_rx_dump_pkt_hdr_tlv() - dump RX pkt header TLV in hex format
* @pkt_tlvs: pointer the pkt_hdr_tlv in pkt.
* @dbg_level: log level.
*
* Return: void
*/
static inline void hal_rx_dump_pkt_hdr_tlv(struct rx_pkt_tlvs *pkt_tlvs,
uint8_t dbg_level)
{
struct rx_pkt_hdr_tlv *pkt_hdr_tlv = &pkt_tlvs->pkt_hdr_tlv;
hal_verbose_debug("\n---------------\nrx_pkt_hdr_tlv"
"\n---------------\nphy_ppdu_id %d ",
pkt_hdr_tlv->phy_ppdu_id);
hal_verbose_hex_dump(pkt_hdr_tlv->rx_pkt_hdr, 128);
}
#endif
#define HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(_rx_mpdu_info) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \
RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_OFFSET)), \
RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_MASK, \
RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_LSB))
/**
* hal_rx_get_rx_more_frag_bit(): Function to retrieve more fragment bit
* @buf: Network buffer
*
* Return: rx more fragment bit
*/
static inline
uint8_t hal_rx_get_rx_more_frag_bit(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf);
struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs);
uint16_t frame_ctrl = 0;
frame_ctrl = HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(rx_mpdu_info) >>
DOT11_FC1_MORE_FRAG_OFFSET;
/* more fragment bit if at offset bit 4 */
return frame_ctrl;
}
static inline
void hal_rx_mpdu_desc_info_get_li(void *desc_addr,
void *mpdu_desc_info_hdl)
{
struct reo_destination_ring *reo_dst_ring;
struct hal_rx_mpdu_desc_info *mpdu_desc_info =
(struct hal_rx_mpdu_desc_info *)mpdu_desc_info_hdl;
uint32_t *mpdu_info;
reo_dst_ring = (struct reo_destination_ring *)desc_addr;
mpdu_info = (uint32_t *)&reo_dst_ring->rx_mpdu_desc_info_details;
mpdu_desc_info->msdu_count = HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info);
mpdu_desc_info->mpdu_seq = HAL_RX_MPDU_SEQUENCE_NUMBER_GET(mpdu_info);
mpdu_desc_info->mpdu_flags = HAL_RX_MPDU_FLAGS_GET(mpdu_info);
mpdu_desc_info->peer_meta_data =
HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info);
mpdu_desc_info->bar_frame = HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info);
}
/**
* hal_rx_attn_msdu_done_get_li() - Get msdi done flag from RX TLV
* @buf: RX tlv address
*
* Return: msdu done flag
*/
static inline uint32_t hal_rx_attn_msdu_done_get_li(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn;
uint32_t msdu_done;
msdu_done = HAL_RX_ATTN_MSDU_DONE_GET(rx_attn);
return msdu_done;
}
#define HAL_RX_MSDU_FLAGS_GET(msdu_info_ptr) \
(HAL_RX_FIRST_MSDU_IN_MPDU_FLAG_GET(msdu_info_ptr) | \
HAL_RX_LAST_MSDU_IN_MPDU_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_SA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) | \
HAL_RX_MSDU_DA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr))
/**
* hal_rx_msdu_flags_get_li() - Get msdu flags from ring desc
* @msdu_desc_info_hdl: msdu desc info handle
*
* Return: msdu flags
*/
static inline
uint32_t hal_rx_msdu_flags_get_li(rx_msdu_desc_info_t msdu_desc_info_hdl)
{
struct rx_msdu_desc_info *msdu_desc_info =
(struct rx_msdu_desc_info *)msdu_desc_info_hdl;
return HAL_RX_MSDU_FLAGS_GET(msdu_desc_info);
}
/**
* hal_rx_msdu_desc_info_get_li() - Gets the flags related to MSDU descriptor.
* @desc_addr: REO ring descriptor addr
* @msdu_desc_info: Holds MSDU descriptor info from HAL Rx descriptor
*
* Specifically flags needed are: first_msdu_in_mpdu,
* last_msdu_in_mpdu, msdu_continuation, sa_is_valid,
* sa_idx_timeout, da_is_valid, da_idx_timeout, da_is_MCBC
*
* Return: void
*/
static inline void
hal_rx_msdu_desc_info_get_li(void *desc_addr,
struct hal_rx_msdu_desc_info *msdu_desc_info)
{
struct reo_destination_ring *reo_dst_ring;
uint32_t *msdu_info;
reo_dst_ring = (struct reo_destination_ring *)desc_addr;
msdu_info = (uint32_t *)&reo_dst_ring->rx_msdu_desc_info_details;
msdu_desc_info->msdu_flags =
hal_rx_msdu_flags_get_li((struct rx_msdu_desc_info *)msdu_info);
msdu_desc_info->msdu_len = HAL_RX_MSDU_PKT_LENGTH_GET(msdu_info);
}
#define HAL_RX_MSDU_START_NSS_GET(_rx_msdu_start) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start), \
RX_MSDU_START_5_NSS_OFFSET)), \
RX_MSDU_START_5_NSS_MASK, \
RX_MSDU_START_5_NSS_LSB))
#define HAL_RX_ATTN_MSDU_LEN_ERR_GET(_rx_attn) \
(_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \
RX_ATTENTION_1_MSDU_LENGTH_ERR_OFFSET)), \
RX_ATTENTION_1_MSDU_LENGTH_ERR_MASK, \
RX_ATTENTION_1_MSDU_LENGTH_ERR_LSB))
/**
* hal_rx_attn_msdu_len_err_get_li() - Get msdu_len_err value from rx
* attention tlvs
* @buf: pointer to rx pkt tlvs hdr
*
* Return: msdu_len_err value
*/
static inline uint32_t
hal_rx_attn_msdu_len_err_get_li(uint8_t *buf)
{
struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf;
struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn;
return HAL_RX_ATTN_MSDU_LEN_ERR_GET(rx_attn);
}
#endif /* _HAL_LI_RX_H_ */
Référencer dans un nouveau ticket Voir Git Blâme Copier le lien permanent