30f857cb67
Add logic to handle mcopy and lite monitor feature in case of frag. Change-Id: I45fcbd22b1dcb1f68ee93a69f29fbac85cb0aafa
971 lines
26 KiB
C
971 lines
26 KiB
C
/*
|
|
* Copyright (c) 2016-2020 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 _DP_RX_MON_H_
|
|
#define _DP_RX_MON_H_
|
|
|
|
/*
|
|
* MON_BUF_MIN_ENTRIES macro defines minimum number of network buffers
|
|
* to be refilled in the RXDMA monitor buffer ring at init, remaining
|
|
* buffers are replenished at the time of monitor vap creation
|
|
*/
|
|
#define MON_BUF_MIN_ENTRIES 64
|
|
|
|
/*
|
|
* The maximum headroom reserved for monitor destination buffer to
|
|
* accomodate radiotap header and protocol flow tag
|
|
*/
|
|
#ifdef DP_RX_MON_MEM_FRAG
|
|
/*
|
|
*----------------------------------
|
|
*| Reserve | PF Tag | Radiotap hdr|
|
|
*| 64B | 64B | 128B |
|
|
*----------------------------------
|
|
* Reserved 64B is used to fill Protocol & Flow tag before writing into
|
|
* actual offset, data gets written to actual offset after updating
|
|
* radiotap HDR.
|
|
*/
|
|
#define DP_RX_MON_MAX_MONITOR_HEADER (256)
|
|
#else
|
|
#define DP_RX_MON_MAX_MONITOR_HEADER (512)
|
|
#endif
|
|
|
|
/* The maximum buffer length allocated for radiotap for monitor status buffer */
|
|
#define MAX_MONITOR_HEADER (512)
|
|
|
|
/* l2 header pad byte in case of Raw frame is Zero and 2 in non raw */
|
|
#define DP_RX_MON_RAW_L2_HDR_PAD_BYTE (0)
|
|
#define DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE (2)
|
|
|
|
/**
|
|
* enum dp_mon_reap_status - monitor status ring ppdu status
|
|
*
|
|
* @DP_MON_STATUS_NO_DMA - DMA not done for status ring entry
|
|
* @DP_MON_STATUS_MATCH - status and dest ppdu id mathes
|
|
* @DP_MON_STATUS_LAG - status ppdu id is lagging
|
|
* @DP_MON_STATUS_LEAD - status ppdu id is leading
|
|
* @DP_MON_STATUS_REPLENISH - status ring entry is NULL
|
|
*/
|
|
enum dp_mon_reap_status {
|
|
DP_MON_STATUS_NO_DMA,
|
|
DP_MON_STATUS_MATCH,
|
|
DP_MON_STATUS_LAG,
|
|
DP_MON_STATUS_LEAD,
|
|
DP_MON_STATUS_REPLENISH
|
|
};
|
|
|
|
/*
|
|
* dp_rx_mon_status_process() - Process monitor status ring and
|
|
* TLV in status ring.
|
|
*
|
|
* @soc: core txrx main context
|
|
* @int_ctx: interrupt context
|
|
* @mac_id: mac_id which is one of 3 mac_ids
|
|
* @quota: No. of ring entry that can be serviced in one shot.
|
|
|
|
* Return: uint32_t: No. of ring entry that is processed.
|
|
*/
|
|
uint32_t
|
|
dp_rx_mon_status_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota);
|
|
|
|
/**
|
|
* dp_rx_mon_dest_process() - Brain of the Rx processing functionality
|
|
* Called from the bottom half (tasklet/NET_RX_SOFTIRQ)
|
|
* @soc: core txrx main contex
|
|
* @int_ctx: interrupt context
|
|
* @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced
|
|
* @quota: No. of units (packets) that can be serviced in one shot.
|
|
*
|
|
* This function implements the core of Rx functionality. This is
|
|
* expected to handle only non-error frames.
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota);
|
|
|
|
QDF_STATUS dp_rx_pdev_mon_desc_pool_alloc(struct dp_pdev *pdev);
|
|
QDF_STATUS dp_rx_pdev_mon_buffers_alloc(struct dp_pdev *pdev);
|
|
void dp_rx_pdev_mon_buffers_free(struct dp_pdev *pdev);
|
|
void dp_rx_pdev_mon_desc_pool_init(struct dp_pdev *pdev);
|
|
void dp_rx_pdev_mon_desc_pool_deinit(struct dp_pdev *pdev);
|
|
void dp_rx_pdev_mon_desc_pool_free(struct dp_pdev *pdev);
|
|
void dp_rx_pdev_mon_buf_buffers_free(struct dp_pdev *pdev, uint32_t mac_id);
|
|
|
|
QDF_STATUS dp_rx_pdev_mon_status_buffers_alloc(struct dp_pdev *pdev,
|
|
uint32_t mac_id);
|
|
QDF_STATUS dp_rx_pdev_mon_status_desc_pool_alloc(struct dp_pdev *pdev,
|
|
uint32_t mac_id);
|
|
void dp_rx_pdev_mon_status_desc_pool_init(struct dp_pdev *pdev,
|
|
uint32_t mac_id);
|
|
void dp_rx_pdev_mon_status_desc_pool_deinit(struct dp_pdev *pdev,
|
|
uint32_t mac_id);
|
|
void dp_rx_pdev_mon_status_desc_pool_free(struct dp_pdev *pdev,
|
|
uint32_t mac_id);
|
|
void dp_rx_pdev_mon_status_buffers_free(struct dp_pdev *pdev, uint32_t mac_id);
|
|
QDF_STATUS
|
|
dp_rx_pdev_mon_buf_buffers_alloc(struct dp_pdev *pdev, uint32_t mac_id,
|
|
bool delayed_replenish);
|
|
|
|
/**
|
|
* dp_rx_mon_handle_status_buf_done () - Handle DMA not done case for
|
|
* monitor status ring
|
|
*
|
|
* @pdev: DP pdev handle
|
|
* @mon_status_srng: Monitor status SRNG
|
|
*
|
|
* Return: enum dp_mon_reap_status
|
|
*/
|
|
enum dp_mon_reap_status
|
|
dp_rx_mon_handle_status_buf_done(struct dp_pdev *pdev,
|
|
void *mon_status_srng);
|
|
|
|
#ifdef QCA_SUPPORT_FULL_MON
|
|
|
|
/**
|
|
* dp_full_mon_attach() - Full monitor mode attach
|
|
* This API initilises full monitor mode resources
|
|
*
|
|
* @pdev: dp pdev object
|
|
*
|
|
* Return: void
|
|
*
|
|
*/
|
|
void dp_full_mon_attach(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_full_mon_detach() - Full monitor mode attach
|
|
* This API deinitilises full monitor mode resources
|
|
*
|
|
* @pdev: dp pdev object
|
|
*
|
|
* Return: void
|
|
*
|
|
*/
|
|
void dp_full_mon_detach(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_rx_mon_process ()- API to process monitor destination ring for
|
|
* full monitor mode
|
|
*
|
|
* @soc: dp soc handle
|
|
* @int_ctx: interrupt context
|
|
* @mac_id: lmac id
|
|
* @quota: No. of ring entry that can be serviced in one shot.
|
|
*/
|
|
|
|
uint32_t dp_rx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota);
|
|
|
|
#else
|
|
/**
|
|
* dp_full_mon_attach() - attach full monitor mode resources
|
|
* @pdev: Datapath PDEV handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline void dp_full_mon_attach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* dp_full_mon_detach() - detach full monitor mode resources
|
|
* @pdev: Datapath PDEV handle
|
|
*
|
|
* Return: void
|
|
*
|
|
*/
|
|
static inline void dp_full_mon_detach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_reset_monitor_mode() - Disable monitor mode
|
|
* @pdev_handle: Datapath PDEV handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
|
|
uint8_t pdev_id,
|
|
uint8_t smart_monitor);
|
|
|
|
/**
|
|
* dp_mon_link_free() - free monitor link desc pool
|
|
* @pdev: core txrx pdev context
|
|
*
|
|
* This function will release DP link desc pool for monitor mode from
|
|
* main device context.
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: success
|
|
* QDF_STATUS_E_RESOURCES: Error return
|
|
*/
|
|
QDF_STATUS dp_mon_link_free(struct dp_pdev *pdev);
|
|
|
|
|
|
/**
|
|
* dp_mon_process() - Main monitor mode processing roution.
|
|
* @soc: core txrx main context
|
|
* @int_ctx: interrupt context
|
|
* @mac_id: mac_id which is one of 3 mac_ids
|
|
* @quota: No. of status ring entry that can be serviced in one shot.
|
|
*
|
|
* This call monitor status ring process then monitor
|
|
* destination ring process.
|
|
* Called from the bottom half (tasklet/NET_RX_SOFTIRQ)
|
|
*
|
|
* Return: uint32_t: No. of ring entry that is processed.
|
|
*/
|
|
uint32_t dp_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota);
|
|
QDF_STATUS dp_rx_mon_deliver(struct dp_soc *soc, uint32_t mac_id,
|
|
qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu);
|
|
/*
|
|
* dp_rx_mon_deliver_non_std() - deliver frames for non standard path
|
|
* @soc: core txrx main contex
|
|
* @mac_id: MAC ID
|
|
*
|
|
* This function delivers the radio tap and dummy MSDU
|
|
* into user layer application for preamble only PPDU.
|
|
*
|
|
* Return: Operation status
|
|
*/
|
|
QDF_STATUS dp_rx_mon_deliver_non_std(struct dp_soc *soc, uint32_t mac_id);
|
|
|
|
/**
|
|
* dp_rxdma_err_process() - RxDMA error processing functionality
|
|
* @soc: core txrx main contex
|
|
* @mac_id: mac id which is one of 3 mac_ids
|
|
* @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced
|
|
* @quota: No. of units (packets) that can be serviced in one shot.
|
|
*
|
|
* Return: num of buffers processed
|
|
*/
|
|
uint32_t dp_rxdma_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
|
|
uint32_t mac_id, uint32_t quota);
|
|
|
|
/**
|
|
* dp_mon_buf_delayed_replenish() - Helper routine to replenish monitor dest buf
|
|
* @pdev: DP pdev object
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_mon_buf_delayed_replenish(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_rx_mon_link_desc_return() - Return a MPDU link descriptor to HW
|
|
* (WBM), following error handling
|
|
*
|
|
* @dp_pdev: core txrx pdev context
|
|
* @buf_addr_info: void pointer to monitor link descriptor buf addr info
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS
|
|
dp_rx_mon_link_desc_return(struct dp_pdev *dp_pdev,
|
|
hal_buff_addrinfo_t buf_addr_info,
|
|
int mac_id);
|
|
|
|
/**
|
|
* dp_mon_adjust_frag_len() - MPDU and MSDU may spread across
|
|
* multiple nbufs. This function
|
|
* is to return data length in
|
|
* fragmented buffer
|
|
*
|
|
* @total_len: pointer to remaining data length.
|
|
* @frag_len: pointer to data length in this fragment.
|
|
*/
|
|
static inline void dp_mon_adjust_frag_len(uint32_t *total_len,
|
|
uint32_t *frag_len)
|
|
{
|
|
if (*total_len >= (RX_MONITOR_BUFFER_SIZE - RX_PKT_TLVS_LEN)) {
|
|
*frag_len = RX_MONITOR_BUFFER_SIZE - RX_PKT_TLVS_LEN;
|
|
*total_len -= *frag_len;
|
|
} else {
|
|
*frag_len = *total_len;
|
|
*total_len = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_frag_adjust_frag_len() - MPDU and MSDU may spread across
|
|
* multiple nbufs. This function is to return data length in
|
|
* fragmented buffer.
|
|
* It takes input as max_limit for any buffer(as it changes based
|
|
* on decap type and buffer sequence in MSDU.
|
|
*
|
|
* If MSDU is divided into multiple buffer then below format will
|
|
* be max limit.
|
|
* Decap type Non-Raw
|
|
*--------------------------------
|
|
*| 1st | 2nd | ... | Last |
|
|
*| 1662 | 1664 | 1664 | <=1664 |
|
|
*--------------------------------
|
|
* Decap type Raw
|
|
*--------------------------------
|
|
*| 1st | 2nd | ... | Last |
|
|
*| 1664 | 1664 | 1664 | <=1664 |
|
|
*--------------------------------
|
|
*
|
|
* It also calculate if current buffer has placeholder to keep padding byte.
|
|
* --------------------------------
|
|
* | MAX LIMIT(1662/1664) |
|
|
* --------------------------------
|
|
* | Actual Data | Pad byte Pholder |
|
|
* --------------------------------
|
|
*
|
|
* @total_len: Remaining data length.
|
|
* @frag_len: Data length in this fragment.
|
|
* @max_limit: Max limit of current buffer/MSDU.
|
|
*/
|
|
#ifdef DP_RX_MON_MEM_FRAG
|
|
static inline
|
|
void dp_rx_mon_frag_adjust_frag_len(uint32_t *total_len, uint32_t *frag_len,
|
|
uint32_t max_limit)
|
|
{
|
|
if (*total_len >= max_limit) {
|
|
*frag_len = max_limit;
|
|
*total_len -= *frag_len;
|
|
} else {
|
|
*frag_len = *total_len;
|
|
*total_len = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DP_RX_MON_GET_NBUF_FROM_DESC() - Get nbuf from desc
|
|
*/
|
|
#define DP_RX_MON_GET_NBUF_FROM_DESC(rx_desc) \
|
|
NULL
|
|
|
|
/**
|
|
* dp_rx_mon_get_paddr_from_desc() - Get paddr from desc
|
|
*/
|
|
static inline
|
|
qdf_dma_addr_t dp_rx_mon_get_paddr_from_desc(struct dp_rx_desc *rx_desc)
|
|
{
|
|
return rx_desc->paddr_buf_start;
|
|
}
|
|
|
|
/**
|
|
* DP_RX_MON_IS_BUFFER_ADDR_NULL() - Is Buffer received from hw is NULL
|
|
*/
|
|
#define DP_RX_MON_IS_BUFFER_ADDR_NULL(rx_desc) \
|
|
(!(rx_desc->rx_buf_start))
|
|
|
|
#define DP_RX_MON_IS_MSDU_NOT_NULL(msdu) \
|
|
true
|
|
|
|
/**
|
|
* dp_rx_mon_buffer_free() - Free nbuf or frag memory
|
|
* Free nbuf if feature is disabled, else free frag.
|
|
*
|
|
* @rx_desc: Rx desc
|
|
*/
|
|
static inline void
|
|
dp_rx_mon_buffer_free(struct dp_rx_desc *rx_desc)
|
|
{
|
|
qdf_frag_free(rx_desc->rx_buf_start);
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_buffer_unmap() - Unmap nbuf or frag memory
|
|
* Unmap nbuf if feature is disabled, else unmap frag.
|
|
*
|
|
* @soc: struct dp_soc *
|
|
* @rx_desc: struct dp_rx_desc *
|
|
* @size: Size to be unmapped
|
|
*/
|
|
static inline void
|
|
dp_rx_mon_buffer_unmap(struct dp_soc *soc, struct dp_rx_desc *rx_desc,
|
|
uint16_t size)
|
|
{
|
|
qdf_mem_unmap_page(soc->osdev, rx_desc->paddr_buf_start,
|
|
size, QDF_DMA_FROM_DEVICE);
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_alloc_parent_buffer() - Allocate parent buffer to hold
|
|
* radiotap header and accommodate all frag memory in nr_frag.
|
|
*
|
|
* @head_msdu: Ptr to hold allocated Msdu
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline
|
|
QDF_STATUS dp_rx_mon_alloc_parent_buffer(qdf_nbuf_t *head_msdu)
|
|
{
|
|
/* Headroom should accommodate radiotap header
|
|
* and protocol and flow tag for all frag
|
|
*/
|
|
/* --------------------------------------
|
|
* | Protocol & Flow TAG | Radiotap header|
|
|
* | 64 B | Length(128 B) |
|
|
* --------------------------------------
|
|
*/
|
|
*head_msdu = qdf_nbuf_alloc_no_recycler(DP_RX_MON_MAX_MONITOR_HEADER,
|
|
DP_RX_MON_MAX_MONITOR_HEADER, 4);
|
|
|
|
if (!(*head_msdu))
|
|
return QDF_STATUS_E_FAILURE;
|
|
|
|
/* Set *head_msdu->next as NULL as all msdus are
|
|
* mapped via nr frags
|
|
*/
|
|
qdf_nbuf_set_next(*head_msdu, NULL);
|
|
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_parse_desc_buffer() - Parse desc buffer based.
|
|
*
|
|
* Below code will parse desc buffer, handle continuation frame,
|
|
* adjust frag length and update l2_hdr_padding
|
|
*
|
|
* @soc : struct dp_soc*
|
|
* @msdu_info : struct hal_rx_msdu_desc_info*
|
|
* @is_frag_p : is_frag *
|
|
* @total_frag_len_p : Remaining frag len to be updated
|
|
* @frag_len_p : frag len
|
|
* @l2_hdr_offset_p : l2 hdr offset
|
|
* @rx_desc_tlv : rx_desc_tlv
|
|
* @is_frag_non_raw_p : Non raw frag
|
|
* @data : NBUF Data
|
|
*/
|
|
static inline void
|
|
dp_rx_mon_parse_desc_buffer(struct dp_soc *dp_soc,
|
|
struct hal_rx_msdu_desc_info *msdu_info,
|
|
bool *is_frag_p, uint32_t *total_frag_len_p,
|
|
uint32_t *frag_len_p, uint16_t *l2_hdr_offset_p,
|
|
qdf_frag_t rx_desc_tlv,
|
|
bool *is_frag_non_raw_p, void *data)
|
|
{
|
|
struct hal_rx_mon_dest_buf_info frame_info;
|
|
uint16_t tot_payload_len =
|
|
RX_MONITOR_BUFFER_SIZE - RX_PKT_TLVS_LEN;
|
|
|
|
if (msdu_info->msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION) {
|
|
/* First buffer of MSDU */
|
|
if (!(*is_frag_p)) {
|
|
/* Set total frag_len from msdu_len */
|
|
*total_frag_len_p = msdu_info->msdu_len;
|
|
|
|
*is_frag_p = true;
|
|
if (HAL_HW_RX_DECAP_FORMAT_RAW ==
|
|
HAL_RX_DESC_GET_DECAP_FORMAT(rx_desc_tlv)) {
|
|
*l2_hdr_offset_p =
|
|
DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
|
|
frame_info.is_decap_raw = 1;
|
|
} else {
|
|
*l2_hdr_offset_p =
|
|
DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE;
|
|
frame_info.is_decap_raw = 0;
|
|
*is_frag_non_raw_p = true;
|
|
}
|
|
dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
|
|
frag_len_p,
|
|
tot_payload_len -
|
|
*l2_hdr_offset_p);
|
|
|
|
frame_info.first_buffer = 1;
|
|
frame_info.last_buffer = 0;
|
|
hal_rx_mon_dest_set_buffer_info_to_tlv(rx_desc_tlv,
|
|
&frame_info);
|
|
} else {
|
|
/*
|
|
* Continuation Middle frame
|
|
* Here max limit will be same for Raw and Non raw case.
|
|
*/
|
|
*l2_hdr_offset_p = DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
|
|
dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
|
|
frag_len_p,
|
|
tot_payload_len);
|
|
|
|
/* Update frame info if is non raw frame */
|
|
if (*is_frag_non_raw_p)
|
|
frame_info.is_decap_raw = 0;
|
|
else
|
|
frame_info.is_decap_raw = 1;
|
|
|
|
frame_info.first_buffer = 0;
|
|
frame_info.last_buffer = 0;
|
|
hal_rx_mon_dest_set_buffer_info_to_tlv(rx_desc_tlv,
|
|
&frame_info);
|
|
}
|
|
} else {
|
|
/**
|
|
* Last buffer of MSDU spread among multiple buffer
|
|
* Here max limit will be same for Raw and Non raw case.
|
|
*/
|
|
if (*is_frag_p) {
|
|
*l2_hdr_offset_p = DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
|
|
|
|
dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
|
|
frag_len_p,
|
|
tot_payload_len);
|
|
|
|
/* Update frame info if is non raw frame */
|
|
if (*is_frag_non_raw_p)
|
|
frame_info.is_decap_raw = 0;
|
|
else
|
|
frame_info.is_decap_raw = 1;
|
|
|
|
frame_info.first_buffer = 0;
|
|
frame_info.last_buffer = 1;
|
|
hal_rx_mon_dest_set_buffer_info_to_tlv(rx_desc_tlv,
|
|
&frame_info);
|
|
} else {
|
|
/* MSDU with single buffer */
|
|
*frag_len_p = msdu_info->msdu_len;
|
|
if (HAL_HW_RX_DECAP_FORMAT_RAW ==
|
|
HAL_RX_DESC_GET_DECAP_FORMAT(rx_desc_tlv)) {
|
|
*l2_hdr_offset_p =
|
|
DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
|
|
frame_info.is_decap_raw = 1;
|
|
} else {
|
|
*l2_hdr_offset_p =
|
|
DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE;
|
|
frame_info.is_decap_raw = 0;
|
|
}
|
|
|
|
frame_info.first_buffer = 1;
|
|
frame_info.last_buffer = 1;
|
|
hal_rx_mon_dest_set_buffer_info_to_tlv(
|
|
rx_desc_tlv, &frame_info);
|
|
}
|
|
/* Reset bool after complete processing of MSDU */
|
|
*is_frag_p = false;
|
|
*is_frag_non_raw_p = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_buffer_set_pktlen() - set pktlen for buffer
|
|
*/
|
|
static inline void dp_rx_mon_buffer_set_pktlen(qdf_nbuf_t msdu, uint32_t size)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_add_msdu_to_list()- Add msdu to list and update head_msdu
|
|
* It will add reaped buffer frag to nr frag of parent msdu.
|
|
*
|
|
* @head_msdu: NULL if first time called else &msdu
|
|
* @msdu: Msdu where frag address needs to be added via nr_frag
|
|
* @last: Used to traverse in list if this feature is disabled.
|
|
* @rx_desc_tlv: Frag address
|
|
* @frag_len: Frag len
|
|
* @l2_hdr_offset: l2 hdr padding
|
|
*/
|
|
static inline
|
|
void dp_rx_mon_add_msdu_to_list(qdf_nbuf_t *head_msdu, qdf_nbuf_t msdu,
|
|
qdf_nbuf_t *last, qdf_frag_t rx_desc_tlv,
|
|
uint32_t frag_len, uint32_t l2_hdr_offset)
|
|
{
|
|
qdf_nbuf_add_rx_frag(rx_desc_tlv, *head_msdu, SIZE_OF_MONITOR_TLV,
|
|
frag_len + l2_hdr_offset, RX_MONITOR_BUFFER_SIZE,
|
|
false);
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_init_tail_msdu() - Initialize tail msdu
|
|
*
|
|
* @msdu: Msdu to be updated in tail_msdu
|
|
* @last: last msdu
|
|
* @tail_msdu: Last msdu
|
|
*/
|
|
static inline
|
|
void dp_rx_mon_init_tail_msdu(qdf_nbuf_t msdu, qdf_nbuf_t last,
|
|
qdf_nbuf_t *tail_msdu)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_remove_raw_frame_fcs_len() - Remove FCS length for Raw Frame
|
|
*
|
|
* If feature is disabled, then removal happens in restitch logic.
|
|
*
|
|
* @head_msdu: Head msdu
|
|
*/
|
|
static inline
|
|
void dp_rx_mon_remove_raw_frame_fcs_len(qdf_nbuf_t *head_msdu)
|
|
{
|
|
qdf_frag_t addr;
|
|
|
|
/* Strip FCS_LEN for Raw frame */
|
|
if (head_msdu && *head_msdu) {
|
|
addr = qdf_nbuf_get_frag_addr(*head_msdu, 0);
|
|
addr -= SIZE_OF_MONITOR_TLV;
|
|
if (HAL_RX_DESC_GET_DECAP_FORMAT(addr) ==
|
|
HAL_HW_RX_DECAP_FORMAT_RAW) {
|
|
qdf_nbuf_trim_add_frag_size(*head_msdu,
|
|
qdf_nbuf_get_nr_frags(*head_msdu) - 1,
|
|
-HAL_RX_FCS_LEN, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_get_buffer_data()- Get data from desc buffer
|
|
* @rx_desc: desc
|
|
*
|
|
* Return address containing actual tlv content
|
|
*/
|
|
static inline
|
|
uint8_t *dp_rx_mon_get_buffer_data(struct dp_rx_desc *rx_desc)
|
|
{
|
|
return rx_desc->rx_buf_start;
|
|
}
|
|
|
|
/**
|
|
* dp_rx_mon_get_nbuf_80211_hdr() - Get 80211 hdr from nbuf
|
|
* @nbuf: qdf_nbuf_t
|
|
*
|
|
* This function must be called after moving radiotap header.
|
|
*
|
|
* Return: Ptr pointing to 80211 header or NULL.
|
|
*/
|
|
static inline
|
|
qdf_frag_t dp_rx_mon_get_nbuf_80211_hdr(qdf_nbuf_t nbuf)
|
|
{
|
|
/* Return NULL if nr_frag is Zero */
|
|
if (!qdf_nbuf_get_nr_frags(nbuf))
|
|
return NULL;
|
|
|
|
return qdf_nbuf_get_frag_addr(nbuf, 0);
|
|
}
|
|
#else
|
|
|
|
#define DP_RX_MON_GET_NBUF_FROM_DESC(rx_desc) \
|
|
(rx_desc->nbuf)
|
|
|
|
static inline
|
|
qdf_dma_addr_t dp_rx_mon_get_paddr_from_desc(struct dp_rx_desc *rx_desc)
|
|
{
|
|
qdf_dma_addr_t paddr = 0;
|
|
qdf_nbuf_t msdu = NULL;
|
|
|
|
msdu = rx_desc->nbuf;
|
|
if (msdu)
|
|
paddr = qdf_nbuf_get_frag_paddr(msdu, 0);
|
|
|
|
return paddr;
|
|
}
|
|
|
|
#define DP_RX_MON_IS_BUFFER_ADDR_NULL(rx_desc) \
|
|
(!(rx_desc->nbuf))
|
|
|
|
#define DP_RX_MON_IS_MSDU_NOT_NULL(msdu) \
|
|
(msdu)
|
|
|
|
static inline void
|
|
dp_rx_mon_buffer_free(struct dp_rx_desc *rx_desc)
|
|
{
|
|
qdf_nbuf_free(rx_desc->nbuf);
|
|
}
|
|
|
|
static inline void
|
|
dp_rx_mon_buffer_unmap(struct dp_soc *soc, struct dp_rx_desc *rx_desc,
|
|
uint16_t size)
|
|
{
|
|
qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf,
|
|
QDF_DMA_FROM_DEVICE, size);
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_rx_mon_alloc_parent_buffer(qdf_nbuf_t *head_msdu)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void
|
|
dp_rx_mon_parse_desc_buffer(struct dp_soc *dp_soc,
|
|
struct hal_rx_msdu_desc_info *msdu_info,
|
|
bool *is_frag_p, uint32_t *total_frag_len_p,
|
|
uint32_t *frag_len_p, uint16_t *l2_hdr_offset_p,
|
|
qdf_frag_t rx_desc_tlv,
|
|
bool *is_frag_non_raw_p, void *data)
|
|
{
|
|
if (msdu_info->msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION) {
|
|
if (!*(is_frag_p)) {
|
|
*total_frag_len_p = msdu_info->msdu_len;
|
|
*is_frag_p = true;
|
|
}
|
|
dp_mon_adjust_frag_len(total_frag_len_p, frag_len_p);
|
|
} else {
|
|
if (*is_frag_p) {
|
|
dp_mon_adjust_frag_len(
|
|
total_frag_len_p, frag_len_p);
|
|
} else {
|
|
*frag_len_p = msdu_info->msdu_len;
|
|
}
|
|
*is_frag_p = false;
|
|
}
|
|
|
|
/*
|
|
* HW structures call this L3 header padding
|
|
* -- even though this is actually the offset
|
|
* from the buffer beginning where the L2
|
|
* header begins.
|
|
*/
|
|
*l2_hdr_offset_p =
|
|
hal_rx_msdu_end_l3_hdr_padding_get(dp_soc->hal_soc, data);
|
|
}
|
|
|
|
static inline void dp_rx_mon_buffer_set_pktlen(qdf_nbuf_t msdu, uint32_t size)
|
|
{
|
|
qdf_nbuf_set_pktlen(msdu, size);
|
|
}
|
|
|
|
static inline
|
|
void dp_rx_mon_add_msdu_to_list(qdf_nbuf_t *head_msdu, qdf_nbuf_t msdu,
|
|
qdf_nbuf_t *last, qdf_frag_t rx_desc_tlv,
|
|
uint32_t frag_len, uint32_t l2_hdr_offset)
|
|
{
|
|
if (head_msdu && !*head_msdu) {
|
|
*head_msdu = msdu;
|
|
} else {
|
|
if (*last)
|
|
qdf_nbuf_set_next(*last, msdu);
|
|
}
|
|
*last = msdu;
|
|
}
|
|
|
|
static inline
|
|
void dp_rx_mon_init_tail_msdu(qdf_nbuf_t msdu, qdf_nbuf_t last,
|
|
qdf_nbuf_t *tail_msdu)
|
|
{
|
|
if (last)
|
|
qdf_nbuf_set_next(last, NULL);
|
|
|
|
*tail_msdu = msdu;
|
|
}
|
|
|
|
static inline
|
|
void dp_rx_mon_remove_raw_frame_fcs_len(qdf_nbuf_t *head_msdu)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
uint8_t *dp_rx_mon_get_buffer_data(struct dp_rx_desc *rx_desc)
|
|
{
|
|
qdf_nbuf_t msdu = NULL;
|
|
uint8_t *data = NULL;
|
|
|
|
msdu = rx_desc->nbuf;
|
|
if (qdf_likely(msdu))
|
|
data = qdf_nbuf_data(msdu);
|
|
return data;
|
|
}
|
|
|
|
static inline
|
|
qdf_frag_t dp_rx_mon_get_nbuf_80211_hdr(qdf_nbuf_t nbuf)
|
|
{
|
|
return qdf_nbuf_data(nbuf);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_rx_cookie_2_mon_link_desc() - Retrieve Link descriptor based on target
|
|
* @pdev: core physical device context
|
|
* @hal_buf_info: structure holding the buffer info
|
|
* mac_id: mac number
|
|
*
|
|
* Return: link descriptor address
|
|
*/
|
|
static inline
|
|
void *dp_rx_cookie_2_mon_link_desc(struct dp_pdev *pdev,
|
|
struct hal_buf_info buf_info,
|
|
uint8_t mac_id)
|
|
{
|
|
if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return dp_rx_cookie_2_mon_link_desc_va(pdev, &buf_info,
|
|
mac_id);
|
|
|
|
return dp_rx_cookie_2_link_desc_va(pdev->soc, &buf_info);
|
|
}
|
|
|
|
/**
|
|
* dp_rx_monitor_link_desc_return() - Return Link descriptor based on target
|
|
* @pdev: core physical device context
|
|
* @p_last_buf_addr_info: MPDU Link descriptor
|
|
* mac_id: mac number
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline
|
|
QDF_STATUS dp_rx_monitor_link_desc_return(struct dp_pdev *pdev,
|
|
hal_buff_addrinfo_t
|
|
p_last_buf_addr_info,
|
|
uint8_t mac_id, uint8_t bm_action)
|
|
{
|
|
if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return dp_rx_mon_link_desc_return(pdev, p_last_buf_addr_info,
|
|
mac_id);
|
|
|
|
return dp_rx_link_desc_return_by_addr(pdev->soc, p_last_buf_addr_info,
|
|
bm_action);
|
|
}
|
|
|
|
/**
|
|
* dp_rxdma_get_mon_dst_ring() - Return the pointer to rxdma_err_dst_ring
|
|
* or mon_dst_ring based on the target
|
|
* @pdev: core physical device context
|
|
* @mac_for_pdev: mac_id number
|
|
*
|
|
* Return: ring address
|
|
*/
|
|
static inline
|
|
void *dp_rxdma_get_mon_dst_ring(struct dp_pdev *pdev,
|
|
uint8_t mac_for_pdev)
|
|
{
|
|
if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return pdev->soc->rxdma_mon_dst_ring[mac_for_pdev].hal_srng;
|
|
|
|
return pdev->soc->rxdma_err_dst_ring[mac_for_pdev].hal_srng;
|
|
}
|
|
|
|
/**
|
|
* dp_rxdma_get_mon_buf_ring() - Return monitor buf ring address
|
|
* based on target
|
|
* @pdev: core physical device context
|
|
* @mac_for_pdev: mac id number
|
|
*
|
|
* Return: ring address
|
|
*/
|
|
static inline
|
|
struct dp_srng *dp_rxdma_get_mon_buf_ring(struct dp_pdev *pdev,
|
|
uint8_t mac_for_pdev)
|
|
{
|
|
if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return &pdev->soc->rxdma_mon_buf_ring[mac_for_pdev];
|
|
|
|
/* For MCL there is only 1 rx refill ring */
|
|
return &pdev->soc->rx_refill_buf_ring[0];
|
|
}
|
|
|
|
/**
|
|
* dp_rx_get_mon_desc_pool() - Return monitor descriptor pool
|
|
* based on target
|
|
* @soc: soc handle
|
|
* @mac_id: mac id number
|
|
* @pdev_id: pdev id number
|
|
*
|
|
* Return: descriptor pool address
|
|
*/
|
|
static inline
|
|
struct rx_desc_pool *dp_rx_get_mon_desc_pool(struct dp_soc *soc,
|
|
uint8_t mac_id,
|
|
uint8_t pdev_id)
|
|
{
|
|
if (soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return &soc->rx_desc_mon[mac_id];
|
|
|
|
return &soc->rx_desc_buf[pdev_id];
|
|
}
|
|
|
|
/**
|
|
* dp_rx_get_mon_desc() - Return Rx descriptor based on target
|
|
* @soc: soc handle
|
|
* @cookie: cookie value
|
|
*
|
|
* Return: Rx descriptor
|
|
*/
|
|
static inline
|
|
struct dp_rx_desc *dp_rx_get_mon_desc(struct dp_soc *soc,
|
|
uint32_t cookie)
|
|
{
|
|
if (soc->wlan_cfg_ctx->rxdma1_enable)
|
|
return dp_rx_cookie_2_va_mon_buf(soc, cookie);
|
|
|
|
return dp_rx_cookie_2_va_rxdma_buf(soc, cookie);
|
|
}
|
|
|
|
#ifndef REMOVE_MON_DBG_STATS
|
|
/*
|
|
* dp_rx_mon_update_dbg_ppdu_stats() - Update status ring TLV count
|
|
* @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
|
|
* @rx_mon_stats: monitor mode status/destination ring PPDU and MPDU count
|
|
*
|
|
* Update status ring PPDU start and end count. Keep track TLV state on
|
|
* PPDU start and end to find out if start and end is matching. Keep
|
|
* track missing PPDU start and end count. Keep track matching PPDU
|
|
* start and end count.
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void
|
|
dp_rx_mon_update_dbg_ppdu_stats(struct hal_rx_ppdu_info *ppdu_info,
|
|
struct cdp_pdev_mon_stats *rx_mon_stats)
|
|
{
|
|
if (ppdu_info->rx_state ==
|
|
HAL_RX_MON_PPDU_START) {
|
|
rx_mon_stats->status_ppdu_start++;
|
|
if (rx_mon_stats->status_ppdu_state
|
|
!= CDP_MON_PPDU_END)
|
|
rx_mon_stats->status_ppdu_end_mis++;
|
|
rx_mon_stats->status_ppdu_state
|
|
= CDP_MON_PPDU_START;
|
|
ppdu_info->rx_state = HAL_RX_MON_PPDU_RESET;
|
|
} else if (ppdu_info->rx_state ==
|
|
HAL_RX_MON_PPDU_END) {
|
|
rx_mon_stats->status_ppdu_end++;
|
|
if (rx_mon_stats->status_ppdu_state
|
|
!= CDP_MON_PPDU_START)
|
|
rx_mon_stats->status_ppdu_start_mis++;
|
|
else
|
|
rx_mon_stats->status_ppdu_compl++;
|
|
rx_mon_stats->status_ppdu_state
|
|
= CDP_MON_PPDU_END;
|
|
ppdu_info->rx_state = HAL_RX_MON_PPDU_RESET;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* dp_rx_mon_init_dbg_ppdu_stats() - initialization for monitor mode stats
|
|
* @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
|
|
* @rx_mon_stats: monitor mode status/destination ring PPDU and MPDU count
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void
|
|
dp_rx_mon_init_dbg_ppdu_stats(struct hal_rx_ppdu_info *ppdu_info,
|
|
struct cdp_pdev_mon_stats *rx_mon_stats)
|
|
{
|
|
ppdu_info->rx_state = HAL_RX_MON_PPDU_END;
|
|
rx_mon_stats->status_ppdu_state
|
|
= CDP_MON_PPDU_END;
|
|
}
|
|
|
|
#else
|
|
static inline void
|
|
dp_rx_mon_update_dbg_ppdu_stats(struct hal_rx_ppdu_info *ppdu_info,
|
|
struct cdp_pdev_mon_stats *rx_mon_stats)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_rx_mon_init_dbg_ppdu_stats(struct hal_rx_ppdu_info *ppdu_info,
|
|
struct cdp_pdev_mon_stats *rx_mon_stats)
|
|
{
|
|
}
|
|
|
|
#endif
|
|
#endif
|