samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Monitor code segregation

Browse Source 
- Features common to both Li and BE and
  their APIs are retained files at dp/wifi3.0/monitor.
- New monitor ops are introduced if there
  is a requirement for divergence of API.
- Diverged API definitions for 1.0 are captured
  in this change.

All of code in below files are moved to 1.0
- dp_rx_mon_dest.c -> 1.0/dp_rx_mon_dest_1.0.c
- dp_rx_mon_status -> 1.0/dp_rx_mon_status_1.0.c

Only Li and HMT specific are moved for below file
- dp_mon_filter.c -> 1.0/dp_mon_filter_1.0.c
- dp_mon.c -> 1.0/dp_mon_1.0.c

Change-Id: I44d163b27565b86068d80e1d97ec11d0b4a081d4
CRs-Fixed: 2991248
This commit is contained in:
Naga
2021-10-04 23:51:48 +05:30
committed by Madan Koyyalamudi
parent cca6b74fe7
commit 3289db4279
15 changed files with 8821 additions and 7847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dp/inc/cdp_txrx_ops.h
View File

@@ -866,6 +866,8 @@ struct cdp_mon_ops {
/* Configure full monitor mode */
QDF_STATUS
(*config_full_mon_mode)(struct cdp_soc_t *soc, uint8_t val);
QDF_STATUS (*soc_config_full_mon_mode)(struct cdp_pdev *cdp_pdev,
uint8_t val);
};
struct cdp_host_stats_ops {

1
dp/wifi3.0/dp_rx_buffer_pool.c
View File

@@ -19,6 +19,7 @@
#include "dp_rx_buffer_pool.h"
#include "dp_ipa.h"
#ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL
#include "dp_mon.h"
#include "dp_rx_mon.h"
#endif

3359
dp/wifi3.0/monitor/1.0/dp_mon_1.0.c
View File

File diff suppressed because it is too large Load Diff

35
dp/wifi3.0/monitor/1.0/dp_mon_1.0.h
View File

@@ -17,4 +17,39 @@
#ifndef _DP_MON_1_0_H_
#define _DP_MON_1_0_H_
#ifdef WLAN_RX_PKT_CAPTURE_ENH
#include <dp_rx_mon_feature.h>
#endif
#include <dp_rx_mon.h>
void dp_flush_monitor_rings(struct dp_soc *soc);
/* MCL specific functions */
#if defined(DP_CON_MON)
/*
* dp_service_mon_rings()- service monitor rings
* @soc: soc dp handle
* @quota: number of ring entry that can be serviced
*
* Return: None
*
*/
void dp_service_mon_rings(struct dp_soc *soc, uint32_t quota);
#endif
/**
* dp_mon_drop_packets_for_mac() - Drop the mon status ring and
* dest ring packets for a given mac. Packets in status ring and
* dest ring are dropped independently.
* @pdev: DP pdev
* @mac_id: mac id
* @quota: max number of status ring entries that can be processed
*
* Return: work done
*/
uint32_t dp_mon_drop_packets_for_mac(struct dp_pdev *pdev, uint32_t mac_id,
uint32_t quota);
#endif /* _DP_MON_1_0_H_ */

1082
dp/wifi3.0/monitor/1.0/dp_mon_filter_1.0.c
View File

File diff suppressed because it is too large Load Diff

210
dp/wifi3.0/monitor/1.0/dp_mon_filter_1.0.h
View File

@@ -16,4 +16,214 @@
#ifndef _DP_MON_FILTER_1_0_H_
#define _DP_MON_FILTER_1_0_H_
/**
* Accessor Macros to access the software
* defined HTT filter htt_rx_ring_tlv_filter.
*/
#define DP_MON_FILTER_TLV_OFFSET 0x00000000
#define DP_MON_FILTER_TLV_MASK 0xffffffff
#define DP_MON_FILTER_TLV_LSB 0
#define DP_MON_FILTER_FP_MGMT_OFFSET 0x00000004
#define DP_MON_FILTER_FP_MGMT_MASK 0x0000ffff
#define DP_MON_FILTER_FP_MGMT_LSB 0
#define DP_MON_FILTER_MO_MGMT_OFFSET 0x00000004
#define DP_MON_FILTER_MO_MGMT_MASK 0xffff0000
#define DP_MON_FILTER_MO_MGMT_LSB 16
#define DP_MON_FILTER_FP_CTRL_OFFSET 0x00000008
#define DP_MON_FILTER_FP_CTRL_MASK 0x0000ffff
#define DP_MON_FILTER_FP_CTRL_LSB 0
#define DP_MON_FILTER_MO_CTRL_OFFSET 0x00000008
#define DP_MON_FILTER_MO_CTRL_MASK 0xffff0000
#define DP_MON_FILTER_MO_CTRL_LSB 16
#define DP_MON_FILTER_FP_DATA_OFFSET 0x0000000c
#define DP_MON_FILTER_FP_DATA_MASK 0x0000ffff
#define DP_MON_FILTER_FP_DATA_LSB 0
#define DP_MON_FILTER_MO_DATA_OFFSET 0x0000000c
#define DP_MON_FILTER_MO_DATA_MASK 0xffff0000
#define DP_MON_FILTER_MO_DATA_LSB 16
#define DP_MON_FILTER_MD_DATA_OFFSET 0x00000010
#define DP_MON_FILTER_MD_DATA_MASK 0x0000ffff
#define DP_MON_FILTER_MD_DATA_LSB 0
#define DP_MON_FILTER_MD_MGMT_OFFSET 0x00000010
#define DP_MON_FILTER_MD_MGMT_MASK 0xffff0000
#define DP_MON_FILTER_MD_MGMT_LSB 16
#define DP_MON_FILTER_MD_CTRL_OFFSET 0x00000014
#define DP_MON_FILTER_MD_CTRL_MASK 0x0000ffff
#define DP_MON_FILTER_MD_CTRL_LSB 0
#ifdef QCA_ENHANCED_STATS_SUPPORT
/**
* dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev);
/***
* dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev);
#else
static inline void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev)
{
}
#endif
#ifdef QCA_MCOPY_SUPPORT
/**
* dp_mon_filter_setup_mcopy_mode() - Setup the m_copy mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_mcopy_mode() - Reset the m_copy mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev);
#else
static inline void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev)
{
}
#endif
#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
/**
* dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_smart_monitor() - Reset the smart monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev);
#else
static inline void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev)
{
}
#endif
#ifdef WLAN_RX_PKT_CAPTURE_ENH
/**
* dp_mon_filter_setup_rx_enh_capture() - Setup the Rx capture mode filters
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_rx_enh_capture() - Reset the Rx capture mode filters
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev);
#else
static inline void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev)
{
}
#endif
/**
* dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_mon_mode_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_mon_mode_1_0(struct dp_pdev *pdev);
#ifdef WDI_EVENT_ENABLE
/**
* dp_mon_filter_setup_rx_pkt_log_full() - Setup the Rx pktlog full mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_rx_pkt_log_full_1_0() - Reset the Rx pktlog full mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_setup_rx_pkt_log_lite() - Setup the Rx pktlog lite mode filter
* in the radio object.
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_rx_pkt_log_lite() - Reset the Rx pktlog lite mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_setup_rx_pkt_log_cbf() - Setup the Rx pktlog cbf mode filter
* in the radio object.
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_rx_pktlog_cbf() - Reset the Rx pktlog cbf mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev);
#else
static inline void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev)
{
}
static inline void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev)
{
}
#endif
QDF_STATUS dp_mon_filter_update_1_0(struct dp_pdev *pdev);
#endif /* _DP_MON_FILTER_1_0_H_ */

969
dp/wifi3.0/monitor/1.0/dp_rx_mon_1.0.h
View File

@@ -16,4 +16,973 @@
#ifndef _DP_RX_MON_1_0_H_
#define _DP_RX_MON_1_0_H_
#include <dp_rx.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 below macro defines the maximum number of ring entries that would
* be processed in a single instance when processing each of the non-monitoring
* RXDMA2SW ring.
*/
#define MON_DROP_REAP_LIMIT 64
/*
* The maximum headroom reserved for monitor destination buffer to
* accomodate radiotap header and protocol flow tag
*/
#ifdef DP_RX_MON_MEM_FRAG
/*
* -------------------------------------------------
* | Protocol & Flow TAG | Radiotap header|
* | | Length(128 B) |
* | ((4* QDF_NBUF_MAX_FRAGS) * 2) | |
* -------------------------------------------------
*/
#define DP_RX_MON_MAX_RADIO_TAP_HDR (128)
#define DP_RX_MON_PF_TAG_LEN_PER_FRAG (4)
#define DP_RX_MON_TOT_PF_TAG_LEN \
((DP_RX_MON_PF_TAG_LEN_PER_FRAG) * (QDF_NBUF_MAX_FRAGS))
#define DP_RX_MON_MAX_MONITOR_HEADER \
((DP_RX_MON_TOT_PF_TAG_LEN * 2) + (DP_RX_MON_MAX_RADIO_TAP_HDR))
#endif
/* 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)
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_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);
/**
* 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
*/
#ifdef QCA_MONITOR_PKT_SUPPORT
void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
uint32_t mac_id, uint32_t quota);
void dp_rx_pdev_mon_buf_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);
QDF_STATUS
dp_rx_pdev_mon_buf_desc_pool_alloc(struct dp_pdev *pdev, uint32_t mac_id);
void
dp_rx_pdev_mon_buf_desc_pool_init(struct dp_pdev *pdev, uint32_t mac_id);
#else
static inline
void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
uint32_t mac_id, uint32_t quota)
{
}
static inline
void dp_rx_pdev_mon_buf_buffers_free(struct dp_pdev *pdev, uint32_t mac_id)
{
}
static inline QDF_STATUS
dp_rx_pdev_mon_buf_buffers_alloc(struct dp_pdev *pdev, uint32_t mac_id,
bool delayed_replenish)
{
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS
dp_rx_pdev_mon_buf_desc_pool_alloc(struct dp_pdev *pdev, uint32_t mac_id)
{
return QDF_STATUS_SUCCESS;
}
static inline void
dp_rx_pdev_mon_buf_desc_pool_init(struct dp_pdev *pdev, uint32_t mac_id)
{
}
#endif
#if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
/**
* dp_mon_dest_srng_drop_for_mac() - Drop the mon dest ring packets for
* a given mac
* @pdev: DP pdev
* @mac_id: mac id
*
* Return: None
*/
uint32_t
dp_mon_dest_srng_drop_for_mac(struct dp_pdev *pdev, uint32_t mac_id);
#endif
/**
* 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);
#ifdef QCA_MONITOR_PKT_SUPPORT
/**
* 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);
#else
static inline QDF_STATUS
dp_rx_mon_link_desc_return(struct dp_pdev *dp_pdev,
hal_buff_addrinfo_t buf_addr_info,
int mac_id)
{
return QDF_STATUS_SUCCESS;
}
#endif
/**
* dp_mon_adjust_frag_len() - MPDU and MSDU may spread across
* multiple nbufs. This function
* is to return data length in
* fragmented buffer
* @soc: Datapath soc handle
* @total_len: pointer to remaining data length.
* @frag_len: pointer to data length in this fragment.
* @l2_hdr_pad: l2 header padding
*/
static inline void dp_mon_adjust_frag_len(struct dp_soc *soc,
uint32_t *total_len,
uint32_t *frag_len,
uint16_t l2_hdr_pad)
{
uint32_t rx_pkt_tlv_len = soc->rx_pkt_tlv_size;
if (*total_len >= (RX_MONITOR_BUFFER_SIZE - rx_pkt_tlv_len)) {
*frag_len = RX_MONITOR_BUFFER_SIZE - rx_pkt_tlv_len -
l2_hdr_pad;
*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_add_msdu_to_list_failure_handler() - Handler for nbuf buffer
* attach failure
*
* @rx_tlv_hdr: rx_tlv_hdr
* @pdev: struct dp_pdev *
* @last: skb pointing to last skb in chained list at any moment
* @head_msdu: parent skb in the chained list
* @tail_msdu: Last skb in the chained list
* @func_name: caller function name
*
* Return: void
*/
static inline void
dp_rx_mon_add_msdu_to_list_failure_handler(void *rx_tlv_hdr,
struct dp_pdev *pdev,
qdf_nbuf_t *last,
qdf_nbuf_t *head_msdu,
qdf_nbuf_t *tail_msdu,
const char *func_name)
{
DP_STATS_INC(pdev, replenish.nbuf_alloc_fail, 1);
qdf_frag_free(rx_tlv_hdr);
if (head_msdu)
qdf_nbuf_list_free(*head_msdu);
dp_err("[%s] failed to allocate subsequent parent buffer to hold all frag\n",
func_name);
if (head_msdu)
*head_msdu = NULL;
if (last)
*last = NULL;
if (tail_msdu)
*tail_msdu = 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
* Length reserved to accommodate Radiotap header
* is 128 bytes and length reserved for Protocol
* flow tag will vary based on QDF_NBUF_MAX_FRAGS.
*/
/* -------------------------------------------------
* | Protocol & Flow TAG | Radiotap header|
* | | Length(128 B) |
* | ((4* QDF_NBUF_MAX_FRAGS) * 2) | |
* -------------------------------------------------
*/
*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;
qdf_mem_zero(qdf_nbuf_head(*head_msdu), qdf_nbuf_headroom(*head_msdu));
/* 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 - dp_soc->rx_pkt_tlv_size;
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_tlv_decap_format_get(dp_soc->hal_soc,
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_priv_info_set_in_tlv(dp_soc->hal_soc,
rx_desc_tlv,
(uint8_t *)&frame_info,
sizeof(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_priv_info_set_in_tlv(dp_soc->hal_soc,
rx_desc_tlv,
(uint8_t *)&frame_info,
sizeof(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_priv_info_set_in_tlv(dp_soc->hal_soc,
rx_desc_tlv,
(uint8_t *)&frame_info,
sizeof(frame_info));
} else {
/* MSDU with single buffer */
*frag_len_p = msdu_info->msdu_len;
if (HAL_HW_RX_DECAP_FORMAT_RAW ==
hal_rx_tlv_decap_format_get(dp_soc->hal_soc,
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_priv_info_set_in_tlv(dp_soc->hal_soc,
rx_desc_tlv,
(uint8_t *)&frame_info,
sizeof(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.
* @soc: DP soc handle
* @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
QDF_STATUS dp_rx_mon_add_msdu_to_list(struct dp_soc *soc, 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)
{
uint32_t num_frags;
qdf_nbuf_t msdu_curr;
/* Here head_msdu and *head_msdu must not be NULL */
/* Dont add frag to skb if frag length is zero. Drop frame */
if (qdf_unlikely(!frag_len || !head_msdu || !(*head_msdu))) {
dp_err("[%s] frag_len[%d] || head_msdu[%pK] || *head_msdu is Null while adding frag to skb\n",
__func__, frag_len, head_msdu);
return QDF_STATUS_E_FAILURE;
}
/* In case of first desc of MPDU, assign curr msdu to *head_msdu */
if (!qdf_nbuf_get_nr_frags(*head_msdu))
msdu_curr = *head_msdu;
else
msdu_curr = *last;
/* Current msdu must not be NULL */
if (qdf_unlikely(!msdu_curr)) {
dp_err("[%s] Current msdu can't be Null while adding frag to skb\n",
__func__);
return QDF_STATUS_E_FAILURE;
}
num_frags = qdf_nbuf_get_nr_frags(msdu_curr);
if (num_frags < QDF_NBUF_MAX_FRAGS) {
qdf_nbuf_add_rx_frag(rx_desc_tlv, msdu_curr,
soc->rx_mon_pkt_tlv_size,
frag_len + l2_hdr_offset,
RX_MONITOR_BUFFER_SIZE,
false);
if (*last != msdu_curr)
*last = msdu_curr;
return QDF_STATUS_SUCCESS;
}
/* Execution will reach here only if num_frags == QDF_NBUF_MAX_FRAGS */
msdu_curr = NULL;
if ((dp_rx_mon_alloc_parent_buffer(&msdu_curr))
!= QDF_STATUS_SUCCESS)
return QDF_STATUS_E_FAILURE;
qdf_nbuf_add_rx_frag(rx_desc_tlv, msdu_curr, soc->rx_mon_pkt_tlv_size,
frag_len + l2_hdr_offset, RX_MONITOR_BUFFER_SIZE,
false);
/* Add allocated nbuf in the chain */
qdf_nbuf_set_next(*last, msdu_curr);
/* Assign current msdu to last to avoid traversal */
*last = msdu_curr;
return QDF_STATUS_SUCCESS;
}
/**
* dp_rx_mon_init_tail_msdu() - Initialize tail msdu
*
* @head_msdu: Parent buffer to hold MPDU data
* @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 *head_msdu, qdf_nbuf_t msdu,
qdf_nbuf_t last, qdf_nbuf_t *tail_msdu)
{
if (!head_msdu || !(*head_msdu)) {
*tail_msdu = NULL;
return;
}
if (last)
qdf_nbuf_set_next(last, NULL);
*tail_msdu = last;
}
/**
* dp_rx_mon_remove_raw_frame_fcs_len() - Remove FCS length for Raw Frame
*
* If feature is disabled, then removal happens in restitch logic.
*
* @soc: Datapath soc handle
* @head_msdu: Head msdu
* @tail_msdu: Tail msdu
*/
static inline
void dp_rx_mon_remove_raw_frame_fcs_len(struct dp_soc *soc,
qdf_nbuf_t *head_msdu,
qdf_nbuf_t *tail_msdu)
{
qdf_frag_t addr;
if (qdf_unlikely(!head_msdu || !tail_msdu || !(*head_msdu)))
return;
/* If *head_msdu is valid, then *tail_msdu must be valid */
/* If head_msdu is valid, then it must have nr_frags */
/* If tail_msdu is valid, then it must have nr_frags */
/* Strip FCS_LEN for Raw frame */
addr = qdf_nbuf_get_frag_addr(*head_msdu, 0);
addr -= soc->rx_mon_pkt_tlv_size;
if (hal_rx_tlv_decap_format_get(soc->hal_soc, addr) ==
HAL_HW_RX_DECAP_FORMAT_RAW) {
qdf_nbuf_trim_add_frag_size(*tail_msdu,
qdf_nbuf_get_nr_frags(*tail_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;
}
#else
#define DP_RX_MON_GET_NBUF_FROM_DESC(rx_desc) \
(rx_desc->nbuf)
static inline void
dp_rx_mon_add_msdu_to_list_failure_handler(void *rx_tlv_hdr,
struct dp_pdev *pdev,
qdf_nbuf_t *last,
qdf_nbuf_t *head_msdu,
qdf_nbuf_t *tail_msdu,
const char *func_name)
{
}
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)
{
/*
* 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);
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(dp_soc, total_frag_len_p, frag_len_p,
*l2_hdr_offset_p);
} else {
if (*is_frag_p) {
dp_mon_adjust_frag_len(dp_soc, total_frag_len_p,
frag_len_p,
*l2_hdr_offset_p);
} else {
*frag_len_p = msdu_info->msdu_len;
}
*is_frag_p = false;
}
}
static inline void dp_rx_mon_buffer_set_pktlen(qdf_nbuf_t msdu, uint32_t size)
{
qdf_nbuf_set_pktlen(msdu, size);
}
static inline
QDF_STATUS dp_rx_mon_add_msdu_to_list(struct dp_soc *soc, 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;
return QDF_STATUS_SUCCESS;
}
static inline
void dp_rx_mon_init_tail_msdu(qdf_nbuf_t *head_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(struct dp_soc *soc,
qdf_nbuf_t *head_msdu,
qdf_nbuf_t *tail_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;
}
#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() - 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);
}
#ifdef QCA_MONITOR_PKT_SUPPORT
/*
* dp_mon_htt_dest_srng_setup(): monitor dest srng setup
* @soc: DP SOC handle
* @pdev: DP PDEV handle
* @mac_id: MAC ID
* @mac_for_pdev: PDEV mac
*
* Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
*/
QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
struct dp_pdev *pdev,
int mac_id,
int mac_for_pdev);
/*
* dp_mon_dest_rings_deinit(): deinit monitor dest rings
* @pdev: DP PDEV handle
* @lmac_id: MAC ID
*
* Return: status: None
*/
void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id);
/*
* dp_mon_dest_rings_free(): free monitor dest rings
* @pdev: DP PDEV handle
* @lmac_id: MAC ID
*
* Return: status: None
*/
void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id);
/*
* dp_mon_dest_rings_init(): init monitor dest rings
* @pdev: DP PDEV handle
* @lmac_id: MAC ID
*
* Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
*/
QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id);
/*
* dp_mon_dest_rings_allocate(): allocate monitor dest rings
* @pdev: DP PDEV handle
* @lmac_id: MAC ID
*
* Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
*/
QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id);
#else
QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
struct dp_pdev *pdev,
int mac_id,
int mac_for_pdev)
{
return QDF_STATUS_SUCCESS;
}
static void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id)
{
}
static void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id)
{
}
static
QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id)
{
return QDF_STATUS_SUCCESS;
}
static
QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id)
{
return QDF_STATUS_SUCCESS;
}
#endif /* QCA_MONITOR_PKT_SUPPORT */
#endif /* _DP_RX_MON_1_0_H_ */

401
dp/wifi3.0/monitor/1.0/dp_rx_mon_dest_1.0.c
View File

@@ -29,6 +29,8 @@
#include "wlan_cfg.h"
#include "dp_internal.h"
#include "dp_rx_buffer_pool.h"
#include <dp_mon_1.0.h>
#include <dp_rx_mon_1.0.h>
#ifndef IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK
#define IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK 0xe0
@@ -53,7 +55,7 @@
#define MON_DEST_RING_STUCK_MAX_CNT 16
#ifdef WLAN_TX_PKT_CAPTURE_ENH
static inline void
void
dp_handle_tx_capture(struct dp_soc *soc, struct dp_pdev *pdev,
qdf_nbuf_t mon_mpdu)
{
@@ -85,19 +87,11 @@ dp_tx_capture_get_user_id(struct dp_pdev *dp_pdev, void *rx_desc_tlv)
}
#endif
#else
static inline void
dp_handle_tx_capture(struct dp_soc *soc, struct dp_pdev *pdev,
qdf_nbuf_t mon_mpdu)
{
}
#ifdef QCA_MONITOR_PKT_SUPPORT
static void
dp_tx_capture_get_user_id(struct dp_pdev *dp_pdev, void *rx_desc_tlv)
{
}
#endif
#endif
#ifdef QCA_MONITOR_PKT_SUPPORT
/**
@@ -471,34 +465,6 @@ next_msdu:
return rx_bufs_used;
}
/**
* dp_rx_extract_radiotap_info(): Extract and populate information in
* struct mon_rx_status type
* @rx_status: Receive status
* @mon_rx_status: Monitor mode status
*
* Returns: None
*/
static inline
void dp_rx_extract_radiotap_info(struct cdp_mon_status *rx_status,
struct mon_rx_status *rx_mon_status)
{
rx_mon_status->tsft = rx_status->cdp_rs_tstamp.cdp_tsf;
rx_mon_status->chan_freq = rx_status->rs_freq;
rx_mon_status->chan_num = rx_status->rs_channel;
rx_mon_status->chan_flags = rx_status->rs_flags;
rx_mon_status->rate = rx_status->rs_datarate;
/* TODO: rx_mon_status->ant_signal_db */
/* TODO: rx_mon_status->nr_ant */
rx_mon_status->mcs = rx_status->cdf_rs_rate_mcs;
rx_mon_status->is_stbc = rx_status->cdp_rs_stbc;
rx_mon_status->sgi = rx_status->cdp_rs_sgi;
/* TODO: rx_mon_status->ldpc */
/* TODO: rx_mon_status->beamformed */
/* TODO: rx_mon_status->vht_flags */
/* TODO: rx_mon_status->vht_flag_values1 */
}
void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
uint32_t mac_id, uint32_t quota)
{
@@ -2030,7 +1996,6 @@ mpdu_stitch_fail:
#endif
#ifdef DP_RX_MON_MEM_FRAG
static inline
qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu,
struct cdp_mon_status *rs)
@@ -2045,7 +2010,6 @@ qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
tail_msdu, rs);
}
#else
static inline
qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu,
struct cdp_mon_status *rs)
@@ -2058,7 +2022,6 @@ qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
#ifdef DP_RX_MON_MEM_FRAG
#if defined(WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG) ||\
defined(WLAN_SUPPORT_RX_FLOW_TAG)
static inline
void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
qdf_nbuf_t nbuf)
{
@@ -2111,114 +2074,10 @@ void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
ext_list = qdf_nbuf_queue_next(ext_list);
}
}
#else
static inline
void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
qdf_nbuf_t nbuf)
{
}
#endif
#else
static inline
void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
qdf_nbuf_t nbuf)
{
}
#endif
#ifdef DP_MON_RSSI_IN_DBM
/*
* dp_rx_mon_rssi_convert(): convert rssi_comb from unit dBm to dB
* to match with radiotap further conversion requirement
* @rx_status: monitor mode rx status pointer
*
* Return: none
*/
static inline
void dp_rx_mon_rssi_convert(struct mon_rx_status *rx_status)
{
rx_status->rssi_comb = rx_status->rssi_comb -
rx_status->chan_noise_floor;
}
#else
static inline
void dp_rx_mon_rssi_convert(struct mon_rx_status *rx_status)
{
}
#endif
/**
* dp_send_mgmt_packet_to_stack(): send indicataion to upper layers
*
* @soc: soc handle
* @nbuf: Mgmt packet
* @pdev: pdev handle
*
* Return: QDF_STATUS_SUCCESS on success
* QDF_STATUS_E_INVAL in error
*/
#ifdef QCA_MCOPY_SUPPORT
static inline QDF_STATUS dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
qdf_nbuf_t nbuf,
struct dp_pdev *pdev)
{
uint32_t *nbuf_data;
struct ieee80211_frame *wh;
qdf_frag_t addr;
struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
if (!nbuf)
return QDF_STATUS_E_INVAL;
/* Get addr pointing to80211 header */
addr = dp_rx_mon_get_nbuf_80211_hdr(nbuf);
if (qdf_unlikely(!addr)) {
qdf_nbuf_free(nbuf);
return QDF_STATUS_E_INVAL;
}
/*check if this is not a mgmt packet*/
wh = (struct ieee80211_frame *)addr;
if (((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
IEEE80211_FC0_TYPE_MGT) &&
((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
IEEE80211_FC0_TYPE_CTL)) {
qdf_nbuf_free(nbuf);
return QDF_STATUS_E_INVAL;
}
nbuf_data = (uint32_t *)qdf_nbuf_push_head(nbuf, 4);
if (!nbuf_data) {
QDF_TRACE(QDF_MODULE_ID_DP,
QDF_TRACE_LEVEL_ERROR,
FL("No headroom"));
qdf_nbuf_free(nbuf);
return QDF_STATUS_E_INVAL;
}
*nbuf_data = mon_pdev->ppdu_info.com_info.ppdu_id;
dp_wdi_event_handler(WDI_EVENT_RX_MGMT_CTRL, soc, nbuf,
HTT_INVALID_PEER,
WDI_NO_VAL, pdev->pdev_id);
return QDF_STATUS_SUCCESS;
}
#else
static inline QDF_STATUS dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
qdf_nbuf_t nbuf,
struct dp_pdev *pdev)
{
return QDF_STATUS_SUCCESS;
}
#endif /* QCA_MCOPY_SUPPORT */
/*
* dp_rx_mon_process_dest_pktlog(): function to log packet contents to
* pktlog buffer and send to pktlog module
* @soc: DP soc
* @mac_id: MAC ID
* @mpdu: MPDU buf
* Return: status: 0 - Success, non-zero: Failure
*/
static QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
uint32_t mac_id,
qdf_nbuf_t mpdu)
{
@@ -2262,174 +2121,134 @@ static QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
return QDF_STATUS_SUCCESS;
}
/*
* dp_rx_mon_deliver(): function to deliver packets to stack
* @soc: DP soc
* @mac_id: MAC ID
* @head_msdu: head of msdu list
* @tail_msdu: tail of msdu list
*
* Return: status: 0 - Success, non-zero: Failure
*/
QDF_STATUS dp_rx_mon_deliver(struct dp_soc *soc, uint32_t mac_id,
qdf_nbuf_t head_msdu,
qdf_nbuf_t tail_msdu)
#ifdef QCA_MONITOR_PKT_SUPPORT
QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
struct dp_pdev *pdev,
int mac_id,
int mac_for_pdev)
{
struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
struct cdp_mon_status *rs;
qdf_nbuf_t mon_skb, skb_next;
qdf_nbuf_t mon_mpdu = NULL;
struct dp_mon_vdev *mon_vdev;
struct dp_mon_pdev *mon_pdev;
QDF_STATUS status = QDF_STATUS_SUCCESS;
if (!pdev)
goto mon_deliver_fail;
if (soc->wlan_cfg_ctx->rxdma1_enable) {
status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
soc->rxdma_mon_buf_ring[mac_id]
.hal_srng,
RXDMA_MONITOR_BUF);
mon_pdev = pdev->monitor_pdev;
rs = &mon_pdev->rx_mon_recv_status;
if (!mon_pdev->mvdev && !mon_pdev->mcopy_mode &&
!mon_pdev->rx_pktlog_cbf)
goto mon_deliver_fail;
/* restitch mon MPDU for delivery via monitor interface */
mon_mpdu = dp_rx_mon_restitch_mpdu(soc, mac_id, head_msdu,
tail_msdu, rs);
/* If MPDU restitch fails, free buffers*/
if (!mon_mpdu) {
dp_info("MPDU restitch failed, free buffers");
goto mon_deliver_fail;
if (status != QDF_STATUS_SUCCESS) {
dp_mon_err("Failed to send htt srng setup message for Rxdma mon buf ring");
return status;
}
dp_rx_mon_process_dest_pktlog(soc, mac_id, mon_mpdu);
status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
soc->rxdma_mon_dst_ring[mac_id]
.hal_srng,
RXDMA_MONITOR_DST);
/* monitor vap cannot be present when mcopy is enabled
* hence same skb can be consumed
*/
if (mon_pdev->mcopy_mode)
return dp_send_mgmt_packet_to_stack(soc, mon_mpdu, pdev);
if (mon_mpdu && mon_pdev->mvdev &&
mon_pdev->mvdev->osif_vdev &&
mon_pdev->mvdev->monitor_vdev &&
mon_pdev->mvdev->monitor_vdev->osif_rx_mon) {
mon_vdev = mon_pdev->mvdev->monitor_vdev;
mon_pdev->ppdu_info.rx_status.ppdu_id =
mon_pdev->ppdu_info.com_info.ppdu_id;
mon_pdev->ppdu_info.rx_status.device_id = soc->device_id;
mon_pdev->ppdu_info.rx_status.chan_noise_floor =
pdev->chan_noise_floor;
/* convert rssi_comb from dBm to positive dB value */
dp_rx_mon_rssi_convert(&mon_pdev->ppdu_info.rx_status);
dp_handle_tx_capture(soc, pdev, mon_mpdu);
if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status,
mon_mpdu,
qdf_nbuf_headroom(mon_mpdu))) {
DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
goto mon_deliver_fail;
if (status != QDF_STATUS_SUCCESS) {
dp_mon_err("Failed to send htt srng setup message for Rxdma mon dst ring");
return status;
}
dp_rx_mon_update_pf_tag_to_buf_headroom(soc, mon_mpdu);
mon_vdev->osif_rx_mon(mon_pdev->mvdev->osif_vdev,
mon_mpdu,
&mon_pdev->ppdu_info.rx_status);
} else {
dp_rx_mon_dest_debug("%pK: mon_mpdu=%pK monitor_vdev %pK osif_vdev %pK"
, soc, mon_mpdu, mon_pdev->mvdev,
(mon_pdev->mvdev ? mon_pdev->mvdev->osif_vdev
: NULL));
goto mon_deliver_fail;
status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
soc->rxdma_mon_desc_ring[mac_id]
.hal_srng,
RXDMA_MONITOR_DESC);
if (status != QDF_STATUS_SUCCESS) {
dp_mon_err("Failed to send htt srng message for Rxdma mon desc ring");
return status;
}
}
return QDF_STATUS_SUCCESS;
return status;
}
#endif /* QCA_MONITOR_PKT_SUPPORT */
mon_deliver_fail:
mon_skb = head_msdu;
while (mon_skb) {
skb_next = qdf_nbuf_next(mon_skb);
#ifdef QCA_MONITOR_PKT_SUPPORT
void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id)
{
struct dp_soc *soc = pdev->soc;
dp_rx_mon_dest_debug("%pK: [%s][%d] mon_skb=%pK len %u",
soc, __func__, __LINE__,
mon_skb, mon_skb->len);
qdf_nbuf_free(mon_skb);
mon_skb = skb_next;
if (soc->wlan_cfg_ctx->rxdma1_enable) {
dp_srng_deinit(soc, &soc->rxdma_mon_buf_ring[lmac_id],
RXDMA_MONITOR_BUF, 0);
dp_srng_deinit(soc, &soc->rxdma_mon_dst_ring[lmac_id],
RXDMA_MONITOR_DST, 0);
dp_srng_deinit(soc, &soc->rxdma_mon_desc_ring[lmac_id],
RXDMA_MONITOR_DESC, 0);
}
return QDF_STATUS_E_INVAL;
}
/**
* dp_rx_mon_deliver_non_std()
* @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: QDF_STATUS
*/
QDF_STATUS dp_rx_mon_deliver_non_std(struct dp_soc *soc,
uint32_t mac_id)
void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id)
{
struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
ol_txrx_rx_mon_fp osif_rx_mon;
qdf_nbuf_t dummy_msdu;
struct dp_mon_pdev *mon_pdev;
struct dp_mon_vdev *mon_vdev;
struct dp_soc *soc = pdev->soc;
/* Sanity checking */
if (!pdev || !pdev->monitor_pdev)
goto mon_deliver_non_std_fail;
if (soc->wlan_cfg_ctx->rxdma1_enable) {
dp_srng_free(soc, &soc->rxdma_mon_buf_ring[lmac_id]);
dp_srng_free(soc, &soc->rxdma_mon_dst_ring[lmac_id]);
dp_srng_free(soc, &soc->rxdma_mon_desc_ring[lmac_id]);
}
}
mon_pdev = pdev->monitor_pdev;
QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id)
{
struct dp_soc *soc = pdev->soc;
if (!mon_pdev->mvdev || !mon_pdev->mvdev ||
!mon_pdev->mvdev->monitor_vdev ||
!mon_pdev->mvdev->monitor_vdev->osif_rx_mon)
goto mon_deliver_non_std_fail;
mon_vdev = mon_pdev->mvdev->monitor_vdev;
/* Generate a dummy skb_buff */
osif_rx_mon = mon_vdev->osif_rx_mon;
dummy_msdu = qdf_nbuf_alloc(soc->osdev, MAX_MONITOR_HEADER,
MAX_MONITOR_HEADER, 4, FALSE);
if (!dummy_msdu)
goto allocate_dummy_msdu_fail;
qdf_nbuf_set_pktlen(dummy_msdu, 0);
qdf_nbuf_set_next(dummy_msdu, NULL);
mon_pdev->ppdu_info.rx_status.ppdu_id =
mon_pdev->ppdu_info.com_info.ppdu_id;
/* Apply the radio header to this dummy skb */
if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status,
dummy_msdu,
qdf_nbuf_headroom(dummy_msdu))) {
DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
qdf_nbuf_free(dummy_msdu);
goto mon_deliver_non_std_fail;
if (soc->wlan_cfg_ctx->rxdma1_enable) {
if (dp_srng_init(soc, &soc->rxdma_mon_buf_ring[lmac_id],
RXDMA_MONITOR_BUF, 0, lmac_id)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_buf_ring ", soc);
goto fail1;
}
/* deliver to the user layer application */
osif_rx_mon(mon_pdev->mvdev->osif_vdev,
dummy_msdu, NULL);
/* Clear rx_status*/
qdf_mem_zero(&mon_pdev->ppdu_info.rx_status,
sizeof(mon_pdev->ppdu_info.rx_status));
mon_pdev->mon_ppdu_status = DP_PPDU_STATUS_START;
if (dp_srng_init(soc, &soc->rxdma_mon_dst_ring[lmac_id],
RXDMA_MONITOR_DST, 0, lmac_id)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", soc);
goto fail1;
}
if (dp_srng_init(soc, &soc->rxdma_mon_desc_ring[lmac_id],
RXDMA_MONITOR_DESC, 0, lmac_id)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_desc_ring", soc);
goto fail1;
}
}
return QDF_STATUS_SUCCESS;
allocate_dummy_msdu_fail:
dp_rx_mon_dest_debug("%pK: mon_skb=%pK ",
soc, dummy_msdu);
mon_deliver_non_std_fail:
return QDF_STATUS_E_INVAL;
fail1:
return QDF_STATUS_E_NOMEM;
}
QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id)
{
int entries;
struct dp_soc *soc = pdev->soc;
struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx = pdev->wlan_cfg_ctx;
if (soc->wlan_cfg_ctx->rxdma1_enable) {
entries = wlan_cfg_get_dma_mon_buf_ring_size(pdev_cfg_ctx);
if (dp_srng_alloc(soc, &soc->rxdma_mon_buf_ring[lmac_id],
RXDMA_MONITOR_BUF, entries, 0)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_buf_ring ", soc);
goto fail1;
}
entries = wlan_cfg_get_dma_mon_dest_ring_size(pdev_cfg_ctx);
if (dp_srng_alloc(soc, &soc->rxdma_mon_dst_ring[lmac_id],
RXDMA_MONITOR_DST, entries, 0)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", soc);
goto fail1;
}
entries = wlan_cfg_get_dma_mon_desc_ring_size(pdev_cfg_ctx);
if (dp_srng_alloc(soc, &soc->rxdma_mon_desc_ring[lmac_id],
RXDMA_MONITOR_DESC, entries, 0)) {
dp_mon_err("%pK: " RNG_ERR "rxdma_mon_desc_ring", soc);
goto fail1;
}
}
return QDF_STATUS_SUCCESS;
fail1:
return QDF_STATUS_E_NOMEM;
}
#endif

1526
dp/wifi3.0/monitor/1.0/dp_rx_mon_status_1.0.c
View File

File diff suppressed because it is too large Load Diff

4053
dp/wifi3.0/monitor/dp_mon.c
View File

File diff suppressed because it is too large Load Diff

527
dp/wifi3.0/monitor/dp_mon.h
View File

@@ -42,6 +42,303 @@
#define dp_mon_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_MON, params)
#define dp_mon_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_MON, params)
#ifndef WLAN_TX_PKT_CAPTURE_ENH
struct dp_pdev_tx_capture {
};
struct dp_peer_tx_capture {
};
#endif
/*
* dp_mon_soc_attach() - DP monitor soc attach
* @soc: Datapath SOC handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_NOMEM: Error
*/
QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
/*
* dp_mon_soc_detach() - DP monitor soc detach
* @soc: Datapath SOC handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
/*
* dp_mon_soc_cfg_init() - DP monitor soc config init
* @soc: Datapath SOC handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc);
/*
* dp_mon_pdev_attach() - DP monitor pdev attach
* @pdev: Datapath pdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_NOMEM: Error
*/
QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev);
/*
* dp_mon_pdev_detach() - DP monitor pdev detach
* @pdev: Datapath pdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev);
/*
* dp_mon_pdev_init() - DP monitor pdev init
* @pdev: Datapath pdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev);
/*
* dp_mon_pdev_deinit() - DP monitor pdev deinit
* @pdev: Datapath pdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev);
/*
* dp_mon_vdev_attach() - DP monitor vdev attach
* @vdev: Datapath vdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_NOMEM: Error
*/
QDF_STATUS dp_mon_vdev_attach(struct dp_vdev *vdev);
/*
* dp_mon_vdev_detach() - DP monitor vdev detach
* @vdev: Datapath vdev handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_vdev_detach(struct dp_vdev *vdev);
/*
* dp_mon_peer_attach() - DP monitor peer attach
* @peer: Datapath peer handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_NOMEM: Error
*/
QDF_STATUS dp_mon_peer_attach(struct dp_peer *peer);
/*
* dp_mon_peer_detach() - DP monitor peer detach
* @peer: Datapath peer handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_peer_detach(struct dp_peer *peer);
/*
* dp_mon_cdp_ops_register() - Register monitor cdp ops
* @soc: Datapath soc handle
*
*/
void dp_mon_cdp_ops_register(struct dp_soc *soc);
/*
* dp_mon_cdp_ops_deregister() - deregister monitor cdp ops
* @soc: Datapath soc handle
*
*/
void dp_mon_cdp_ops_deregister(struct dp_soc *soc);
/*
* dp_mon_ops_register() - Register monitor ops
* @soc: Datapath soc handle
*
*/
void dp_mon_ops_register(struct dp_soc *soc);
/*
* dp_mon_htt_srng_setup() - DP mon htt srng setup
* @soc: Datapath soc handle
* @pdev: Datapath pdev handle
* @mac_id: mac id
* @mac_for_pdev: mac id mapped pdev
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_FAILURE: Error
*/
QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc,
struct dp_pdev *pdev,
int mac_id,
int mac_for_pdev);
/*
* dp_config_debug_sniffer()- API to enable/disable debug sniffer
* @pdev: DP_PDEV handle
* @val: user provided value
*
* Return: 0 for success. nonzero for failure.
*/
#if defined(QCA_MCOPY_SUPPORT) || defined(QCA_TX_CAPTURE_SUPPORT)
QDF_STATUS
dp_config_debug_sniffer(struct dp_pdev *pdev, int val);
#else
static inline QDF_STATUS
dp_config_debug_sniffer(struct dp_pdev *pdev, int val) {
return QDF_STATUS_E_INVAL;
}
#endif /* QCA_MCOPY_SUPPORT || QCA_TX_CAPTURE_SUPPORT */
/*
* dp_htt_ppdu_stats_attach() - attach resources for HTT PPDU stats processing
* @pdev: Datapath PDEV handle
*
* Return: QDF_STATUS_SUCCESS: Success
* QDF_STATUS_E_NOMEM: Error
*/
QDF_STATUS dp_htt_ppdu_stats_attach(struct dp_pdev *pdev);
/*
* dp_htt_ppdu_stats_detach() - detach stats resources
* @pdev: Datapath PDEV handle
*
* Return: void
*/
void dp_htt_ppdu_stats_detach(struct dp_pdev *pdev);
/*
*dp_set_bpr_enable() - API to enable/disable bpr feature
*@pdev_handle: DP_PDEV handle.
*@val: Provided value.
*
*Return: 0 for success. nonzero for failure.
*/
#ifdef QCA_SUPPORT_BPR
QDF_STATUS
dp_set_bpr_enable(struct dp_pdev *pdev, int val);
#endif
#ifdef ATH_SUPPORT_NAC
int dp_set_filter_neigh_peers(struct dp_pdev *pdev,
bool val);
#endif /* ATH_SUPPORT_NAC */
#ifdef WLAN_ATF_ENABLE
void dp_set_atf_stats_enable(struct dp_pdev *pdev, bool value);
#endif
/**
* dp_set_bsscolor() - sets bsscolor for tx capture
* @pdev: Datapath PDEV handle
* @bsscolor: new bsscolor
*/
void
dp_mon_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor);
/**
* dp_pdev_get_filter_ucast_data() - get DP PDEV monitor ucast filter
* @soc : data path soc handle
* @pdev_id : pdev_id
* Return: true on ucast filter flag set
*/
bool dp_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle);
/**
* dp_pdev_get_filter_mcast_data() - get DP PDEV monitor mcast filter
* @pdev_handle: Datapath PDEV handle
* Return: true on mcast filter flag set
*/
bool dp_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle);
/**
* dp_pdev_get_filter_non_data() - get DP PDEV monitor non_data filter
* @pdev_handle: Datapath PDEV handle
* Return: true on non data filter flag set
*/
bool dp_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle);
/*
* dp_set_pktlog_wifi3() - attach txrx vdev
* @pdev: Datapath PDEV handle
* @event: which event's notifications are being subscribed to
* @enable: WDI event subscribe or not. (True or False)
*
* Return: Success, NULL on failure
*/
#ifdef WDI_EVENT_ENABLE
int dp_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
bool enable);
#endif
/* MCL specific functions */
#if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
/**
* dp_pktlogmod_exit() - API to cleanup pktlog info
* @pdev: Pdev handle
*
* Return: none
*/
void dp_pktlogmod_exit(struct dp_pdev *pdev);
#else
static inline
void dp_pktlogmod_exit(struct dp_pdev *handle)
{
}
#endif
#ifdef QCA_MONITOR_PKT_SUPPORT
/**
* dp_vdev_set_monitor_mode_buf_rings () - set monitor mode buf rings
*
* Allocate SW descriptor pool, buffers, link descriptor memory
* Initialize monitor related SRNGs
*
* @pdev: DP pdev object
*
* Return: void
*/
void dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev);
/**
* dp_vdev_set_monitor_mode_rings () - set monitor mode rings
*
* Allocate SW descriptor pool, buffers, link descriptor memory
* Initialize monitor related SRNGs
*
* @pdev: DP pdev object
*
* Return: QDF_STATUS
*/
QDF_STATUS dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
uint8_t delayed_replenish);
#else
static inline void
dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
{
}
static inline QDF_STATUS
dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
uint8_t delayed_replenish)
{
return QDF_STATUS_SUCCESS;
}
#endif
struct dp_mon_ops {
QDF_STATUS (*mon_soc_cfg_init)(struct dp_soc *soc);
QDF_STATUS (*mon_pdev_attach)(struct dp_pdev *pdev);
@@ -69,7 +366,7 @@ struct dp_mon_ops {
void (*mon_service_rings)(struct dp_soc *soc, uint32_t quota);
#endif
#ifndef DISABLE_MON_CONFIG
uint32_t (*mon_process)(struct dp_soc *soc,
uint32_t (*mon_rx_process)(struct dp_soc *soc,
struct dp_intr *int_ctx,
uint32_t mac_id,
uint32_t quota);
@@ -135,6 +432,8 @@ struct dp_mon_ops {
void (*mon_pktlogmod_exit)(struct dp_pdev *pdev);
#endif
void (*mon_vdev_set_monitor_mode_buf_rings)(struct dp_pdev *pdev);
QDF_STATUS (*mon_vdev_set_monitor_mode_rings)(struct dp_pdev *pdev,
uint8_t delayed_replenish);
void (*mon_neighbour_peers_detach)(struct dp_pdev *pdev);
#ifdef FEATURE_NAC_RSSI
QDF_STATUS (*mon_filter_neighbour_peer)(struct dp_pdev *pdev,
@@ -159,6 +458,47 @@ struct dp_mon_ops {
uint8_t *mac_addr,
qdf_nbuf_t nbuf,
uint32_t flags);
#ifdef QCA_ENHANCED_STATS_SUPPORT
void (*mon_filter_setup_enhanced_stats)(struct dp_pdev *pdev);
void (*mon_filter_reset_enhanced_stats)(struct dp_pdev *pdev);
#endif
#ifdef QCA_MCOPY_SUPPORT
void (*mon_filter_setup_mcopy_mode)(struct dp_pdev *pdev);
void (*mon_filter_reset_mcopy_mode)(struct dp_pdev *pdev);
#endif
#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
void (*mon_filter_setup_smart_monitor)(struct dp_pdev *pdev);
void (*mon_filter_reset_smart_monitor)(struct dp_pdev *pdev);
#endif
#ifdef WLAN_RX_PKT_CAPTURE_ENH
void (*mon_filter_setup_rx_enh_capture)(struct dp_pdev *pdev);
void (*mon_filter_reset_rx_enh_capture)(struct dp_pdev *pdev);
#endif
void (*mon_filter_setup_mon_mode)(struct dp_pdev *pdev);
void (*mon_filter_reset_mon_mode)(struct dp_pdev *pdev);
#ifdef WDI_EVENT_ENABLE
void (*mon_filter_setup_rx_pkt_log_full)(struct dp_pdev *pdev);
void (*mon_filter_reset_rx_pkt_log_full)(struct dp_pdev *pdev);
void (*mon_filter_setup_rx_pkt_log_lite)(struct dp_pdev *pdev);
void (*mon_filter_reset_rx_pkt_log_lite)(struct dp_pdev *pdev);
void (*mon_filter_setup_rx_pkt_log_cbf)(struct dp_pdev *pdev);
void (*mon_filter_reset_rx_pkt_log_cbf)(struct dp_pdev *pdev);
#endif
QDF_STATUS (*mon_filter_update)(struct dp_pdev *pdev);
QDF_STATUS (*mon_rings_alloc)(struct dp_soc* soc, struct dp_pdev *pdev);
void (*mon_rings_free)(struct dp_pdev *pdev);
QDF_STATUS (*mon_rings_init)(struct dp_soc* soc, struct dp_pdev *pdev);
void (*mon_rings_deinit)(struct dp_pdev *pdev);
QDF_STATUS (*rx_pdev_mon_buffers_alloc)(struct dp_pdev *pdev);
void (*rx_pdev_mon_buffers_free)(struct dp_pdev *pdev);
void (*rx_pdev_mon_desc_pool_init)(struct dp_pdev *pdev);
void (*rx_pdev_mon_desc_pool_deinit)(struct dp_pdev *pdev);
QDF_STATUS (*rx_pdev_mon_desc_pool_alloc)(struct dp_pdev *pdev);
void (*rx_pdev_mon_desc_pool_free)(struct dp_pdev *pdev);
QDF_STATUS (*mon_buffers_alloc)(struct dp_pdev *pdev);
QDF_STATUS (*mon_buffers_free)(struct dp_pdev *pdev);
};
struct dp_mon_soc {
@@ -563,16 +903,6 @@ dp_cpu_ring_map[DP_NSS_CPU_RING_MAP_MAX][WLAN_CFG_INT_NUM_CONTEXTS_MAX];
int
dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(uint32_t bitmap);
/**
* dp_ppdu_desc_user_stats_update(): Function to update TX user stats
* @pdev: DP pdev handle
* @ppdu_info: per PPDU TLV descriptor
*
* return: void
*/
void
dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
struct ppdu_info *ppdu_info);
#ifdef WDI_EVENT_ENABLE
void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn);
@@ -1409,12 +1739,12 @@ uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx,
}
monitor_ops = mon_soc->mon_ops;
if (!monitor_ops || !monitor_ops->mon_process) {
if (!monitor_ops || !monitor_ops->mon_rx_process) {
dp_mon_debug("callback not registered");
return 0;
}
return monitor_ops->mon_process(soc, int_ctx, mac_id, quota);
return monitor_ops->mon_rx_process(soc, int_ctx, mac_id, quota);
}
#else
static inline
@@ -2606,23 +2936,166 @@ void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev,
}
#endif
QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev);
QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev);
QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev);
QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev);
QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc);
void dp_mon_cdp_ops_register(struct dp_soc *soc);
void dp_mon_cdp_ops_deregister(struct dp_soc *soc);
void dp_mon_ops_register(struct dp_mon_soc *mon_soc);
QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc,
struct dp_pdev *pdev,
int mac_id,
int mac_for_pdev);
#ifdef QCA_ENHANCED_STATS_SUPPORT
QDF_STATUS dp_peer_qos_stats_notify(struct dp_pdev *dp_pdev,
struct cdp_rx_stats_ppdu_user *ppdu_user);
#endif
/*
* dp_print_pdev_rx_mon_stats() - print rx mon stats
* @pdev: device object
*
* Return: void
*/
void
dp_print_pdev_rx_mon_stats(struct dp_pdev *pdev);
/**
* dp_mcopy_check_deliver() - mcopy check deliver
* @pdev: DP pdev handle
* @peer_id: peer id
* @ppdu_id: ppdu
* @first_msdu: flag to indicate first msdu of ppdu
* Return: 0 on success, not 0 on failure
*/
QDF_STATUS dp_mcopy_check_deliver(struct dp_pdev *pdev,
uint16_t peer_id,
uint32_t ppdu_id,
uint8_t first_msdu);
/**
* dp_pdev_set_advance_monitor_filter() - Set DP PDEV monitor filter
* @soc: soc handle
* @pdev_id: id of Datapath PDEV handle
* @filter_val: Flag to select Filter for monitor mode
* Return: 0 on success, not 0 on failure
*/
#ifdef QCA_ADVANCE_MON_FILTER_SUPPORT
QDF_STATUS
dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
struct cdp_monitor_filter *filter_val);
#else
static inline QDF_STATUS
dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
struct cdp_monitor_filter *filter_val)
{
return QDF_STATUS_E_INVAL;
}
#endif /* QCA_ADVANCE_MON_FILTER_SUPPORT */
/**
* dp_deliver_tx_mgmt() - Deliver mgmt frame for tx capture
* @cdp_soc : data path soc handle
* @pdev_id : pdev_id
* @nbuf: Management frame buffer
*/
QDF_STATUS
dp_deliver_tx_mgmt(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, qdf_nbuf_t nbuf);
/**
* dp_filter_neighbour_peer() - API to filter neighbour peer
* @pdev : DP pdev handle
* @rx_pkt_hdr : packet header
*
* return: QDF_STATUS_SUCCESS on success
* QDF_STATUS_E_FAILURE on failure
*/
#ifdef FEATURE_NAC_RSSI
QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
uint8_t *rx_pkt_hdr);
#else
static inline
QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
uint8_t *rx_pkt_hdr)
{
return QDF_STATUS_SUCCESS;
}
#endif /* FEATURE_NAC_RSSI */
/*
* dp_neighbour_peers_detach() - Detach neighbour peers(nac clients)
* @pdev: device object
*
* Return: void
*/
void dp_neighbour_peers_detach(struct dp_pdev *pdev);
/**
* dp_reset_monitor_mode() - Disable monitor mode
* @soc_hdl: Datapath soc handle
* @pdev_id: id of datapath PDEV handle
* @smart_monitor: smart monitor flag
*
* Return: QDF_STATUS
*/
QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
uint8_t pdev_id,
uint8_t smart_monitor);
static inline
struct dp_mon_ops *dp_mon_ops_get(struct dp_soc *soc)
{
if (soc && soc->monitor_soc)
return soc->monitor_soc->mon_ops;
return NULL;
}
static inline
struct cdp_mon_ops *dp_mon_cdp_ops_get(struct dp_soc *soc)
{
struct cdp_ops *ops = soc->cdp_soc.ops;
return ops->mon_ops;
}
/**
* dp_ppdu_desc_user_stats_update(): Function to update TX user stats
* @pdev: DP pdev handle
* @ppdu_info: per PPDU TLV descriptor
*
* return: void
*/
#ifdef QCA_ENHANCED_STATS_SUPPORT
void
dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
struct ppdu_info *ppdu_info);
#else
static inline void
dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
struct ppdu_info *ppdu_info)
{
}
#endif /* QCA_ENHANCED_STATS_SUPPORT */
/**
* dp_mon_ops_get_1_0(): Get legacy monitor ops
*
* return: Pointer to dp_mon_ops
*/
struct dp_mon_ops *dp_mon_ops_get_1_0(void);
/**
* dp_mon_cdp_ops_get_1_0(): Get legacy monitor cdp ops
*
* return: Pointer to dp_mon_cdp_ops
*/
struct cdp_mon_ops *dp_mon_cdp_ops_get_1_0(void);
#ifdef QCA_MONITOR_2_0_SUPPORT
/**
* dp_mon_ops_get_2_0(): Get BE monitor ops
*
* return: Pointer to dp_mon_ops
*/
struct dp_mon_ops *dp_mon_ops_get_2_0(void);
/**
* dp_mon_cdp_ops_get_2_0(): Get BE monitor cdp ops
*
* return: Pointer to dp_mon_cdp_ops
*/
struct cdp_mon_ops *dp_mon_cdp_ops_get_2_0(void);
#endif
#endif /* _DP_MON_H_ */

1373
dp/wifi3.0/monitor/dp_mon_filter.c
View File

File diff suppressed because it is too large Load Diff

162
dp/wifi3.0/monitor/dp_mon_filter.h
View File

@@ -19,50 +19,6 @@
#ifndef _DP_MON_FILTER_H_
#define _DP_MON_FILTER_H_
/**
* Accessor Macros to access the software
* defined HTT filter htt_rx_ring_tlv_filter.
*/
#define DP_MON_FILTER_TLV_OFFSET 0x00000000
#define DP_MON_FILTER_TLV_MASK 0xffffffff
#define DP_MON_FILTER_TLV_LSB 0
#define DP_MON_FILTER_FP_MGMT_OFFSET 0x00000004
#define DP_MON_FILTER_FP_MGMT_MASK 0x0000ffff
#define DP_MON_FILTER_FP_MGMT_LSB 0
#define DP_MON_FILTER_MO_MGMT_OFFSET 0x00000004
#define DP_MON_FILTER_MO_MGMT_MASK 0xffff0000
#define DP_MON_FILTER_MO_MGMT_LSB 16
#define DP_MON_FILTER_FP_CTRL_OFFSET 0x00000008
#define DP_MON_FILTER_FP_CTRL_MASK 0x0000ffff
#define DP_MON_FILTER_FP_CTRL_LSB 0
#define DP_MON_FILTER_MO_CTRL_OFFSET 0x00000008
#define DP_MON_FILTER_MO_CTRL_MASK 0xffff0000
#define DP_MON_FILTER_MO_CTRL_LSB 16
#define DP_MON_FILTER_FP_DATA_OFFSET 0x0000000c
#define DP_MON_FILTER_FP_DATA_MASK 0x0000ffff
#define DP_MON_FILTER_FP_DATA_LSB 0
#define DP_MON_FILTER_MO_DATA_OFFSET 0x0000000c
#define DP_MON_FILTER_MO_DATA_MASK 0xffff0000
#define DP_MON_FILTER_MO_DATA_LSB 16
#define DP_MON_FILTER_MD_DATA_OFFSET 0x00000010
#define DP_MON_FILTER_MD_DATA_MASK 0x0000ffff
#define DP_MON_FILTER_MD_DATA_LSB 0
#define DP_MON_FILTER_MD_MGMT_OFFSET 0x00000010
#define DP_MON_FILTER_MD_MGMT_MASK 0xffff0000
#define DP_MON_FILTER_MD_MGMT_LSB 16
#define DP_MON_FILTER_MD_CTRL_OFFSET 0x00000014
#define DP_MON_FILTER_MD_CTRL_MASK 0x0000ffff
#define DP_MON_FILTER_MD_CTRL_LSB 0
#define DP_MON_FILTER_GET(src, field) \
((*((uint32_t *)((uint8_t *)(src) + DP_MON_ ## field ## _OFFSET)) & \
(DP_MON_ ## field ## _MASK)) >> DP_MON_ ## field ## _LSB) \
@@ -157,15 +113,15 @@ enum dp_mon_filter_action {
#ifdef QCA_ENHANCED_STATS_SUPPORT
/**
* dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter
* @mon_pdev: Monitor pdev handle
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_enhanced_stats(struct dp_mon_pdev *mon_pdev);
void dp_mon_filter_setup_enhanced_stats(struct dp_pdev *pdev);
/***
* dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
* @mon_pdev: Monitor pdev handle
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_enhanced_stats(struct dp_mon_pdev *mon_pdev);
void dp_mon_filter_reset_enhanced_stats(struct dp_pdev *pdev);
#endif /* QCA_ENHANCED_STATS_SUPPORT */
#ifdef QCA_MCOPY_SUPPORT
@@ -262,6 +218,16 @@ void dp_mon_filter_setup_rx_pkt_log_cbf(struct dp_pdev *pdev);
void dp_mon_filter_reset_rx_pktlog_cbf(struct dp_pdev *pdev);
#endif /* WDI_EVENT_ENABLE */
/**
* dp_mon_filter_set_status_cbf() - Set the cbf status filters
* @pdev: DP pdev handle
* @filter: Dp mon filters
*
* Return: void
*/
void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev,
struct dp_mon_filter *filter);
/**
* dp_mon_filter_update() - Setup the monitor filter setting for a srng
* type
@@ -284,4 +250,104 @@ void dp_mon_filter_dealloc(struct dp_mon_pdev *mon_pdev);
* @mon_pdev: monitor pdev handle
*/
struct dp_mon_filter **dp_mon_filter_alloc(struct dp_mon_pdev *mon_pdev);
/**
* dp_mon_filter_show_filter() - Show the set filters
* @pdev: DP pdev handle
* @mode: The filter modes
* @tlv_filter: tlv filter
*/
void dp_mon_filter_show_filter(struct dp_mon_pdev *mon_pdev,
enum dp_mon_filter_mode mode,
struct dp_mon_filter *filter);
/**
* dp_mon_ht2_rx_ring_cfg() - Send the tlv config to fw for a srng_type
* based on target
* @soc: DP soc handle
* @pdev: DP pdev handle
* @srng_type: The srng type for which filter wll be set
* @tlv_filter: tlv filter
*/
QDF_STATUS
dp_mon_ht2_rx_ring_cfg(struct dp_soc *soc,
struct dp_pdev *pdev,
enum dp_mon_filter_srng_type srng_type,
struct htt_rx_ring_tlv_filter *tlv_filter);
/**
* dp_mon_filter_reset_mon_srng()
* @soc: DP SoC handle
* @pdev: DP pdev handle
* @mon_srng_type: Monitor srng type
*/
void
dp_mon_filter_reset_mon_srng(struct dp_soc *soc, struct dp_pdev *pdev,
enum dp_mon_filter_srng_type mon_srng_type);
/**
* dp_mon_filter_set_mon_cmn() - Setp the common mon filters
* @pdev: DP pdev handle
* @filter: DP mon filter
*
* Return: QDF_STATUS
*/
void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev,
struct dp_mon_filter *filter);
/**
* dp_mon_filter_set_status_cmn() - Setp the common status filters
* @pdev: DP pdev handle
* @filter: Dp mon filters
*
* Return: QDF_STATUS
*/
void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev,
struct dp_mon_filter *filter);
/**
* dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_setup_mon_mode(struct dp_pdev *pdev);
/**
* dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter
* @pdev: DP pdev handle
*/
void dp_mon_filter_reset_mon_mode(struct dp_pdev *pdev);
/**
* dp_mon_filter_set_cbf_cmn() - Set the common cbf mode filters
* @pdev: DP pdev handle
* @filter: Dp mon filters
*
* Return: void
*/
void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev,
struct dp_mon_filter *filter);
/**
* dp_mon_filter_update() - Setup the monitor filter setting for a srng
* type
* @pdev: DP pdev handle
*
* Return: QDF_STATUS
*/
QDF_STATUS dp_mon_filter_update(struct dp_pdev *pdev);
/**
* dp_mon_filter_dealloc() - Deallocate the filter objects to be stored in
* the radio object.
* @pdev: DP pdev handle
*/
void dp_mon_filter_dealloc(struct dp_mon_pdev *mon_pdev);
/**
* dp_mon_filter_alloc() - Allocate the filter objects to be stored in
* the radio object.
* @mon_pdev: DP pdev handle
*/
struct dp_mon_filter **dp_mon_filter_alloc(struct dp_mon_pdev *mon_pdev);
#endif /* #ifndef _DP_MON_FILTER_H_ */

1504
dp/wifi3.0/monitor/dp_rx_mon.c
View File

File diff suppressed because it is too large Load Diff

1414
dp/wifi3.0/monitor/dp_rx_mon.h
View File

File diff suppressed because it is too large Load Diff