3694cff9dc
Update mlo ctx stats API with xmit type. MLO ctx ingress stats will be stored as per the legacy/mlo xmit type. Update stats incrementing mechanism on peer unmap. Change-Id: I2f16b95e64e6a7697d18d9453e9f7c60631f80bb CRs-Fixed: 3561679
5867 sor
161 KiB
C
5867 sor
161 KiB
C
/*
|
|
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
|
|
* Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for
|
|
* any purpose with or without fee is hereby granted, provided that the
|
|
* above copyright notice and this permission notice appear in all
|
|
* copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#ifndef _DP_INTERNAL_H_
|
|
#define _DP_INTERNAL_H_
|
|
|
|
#include "dp_types.h"
|
|
#include "dp_htt.h"
|
|
#include "dp_rx_tid.h"
|
|
|
|
#define RX_BUFFER_SIZE_PKTLOG_LITE 1024
|
|
|
|
#define DP_PEER_WDS_COUNT_INVALID UINT_MAX
|
|
|
|
#define DP_BLOCKMEM_SIZE 4096
|
|
#define WBM2_SW_PPE_REL_RING_ID 6
|
|
#define WBM2_SW_PPE_REL_MAP_ID 11
|
|
#define DP_TX_PPEDS_POOL_ID 0xF
|
|
|
|
/* Alignment for consistent memory for DP rings*/
|
|
#define DP_RING_BASE_ALIGN 32
|
|
|
|
#define DP_RSSI_INVAL 0x80
|
|
#define DP_RSSI_AVG_WEIGHT 2
|
|
/*
|
|
* Formula to derive avg_rssi is taken from wifi2.o firmware
|
|
*/
|
|
#define DP_GET_AVG_RSSI(avg_rssi, last_rssi) \
|
|
(((avg_rssi) - (((uint8_t)(avg_rssi)) >> DP_RSSI_AVG_WEIGHT)) \
|
|
+ ((((uint8_t)(last_rssi)) >> DP_RSSI_AVG_WEIGHT)))
|
|
|
|
/* Macro For NYSM value received in VHT TLV */
|
|
#define VHT_SGI_NYSM 3
|
|
|
|
#define INVALID_WBM_RING_NUM 0xF
|
|
|
|
#ifdef FEATURE_DIRECT_LINK
|
|
#define DIRECT_LINK_REFILL_RING_ENTRIES 64
|
|
#ifdef IPA_OFFLOAD
|
|
#ifdef IPA_WDI3_VLAN_SUPPORT
|
|
#define DIRECT_LINK_REFILL_RING_IDX 4
|
|
#else
|
|
#define DIRECT_LINK_REFILL_RING_IDX 3
|
|
#endif
|
|
#else
|
|
#define DIRECT_LINK_REFILL_RING_IDX 2
|
|
#endif
|
|
#endif
|
|
|
|
#define DP_MAX_VLAN_IDS 4096
|
|
#define DP_VLAN_UNTAGGED 0
|
|
#define DP_VLAN_TAGGED_MULTICAST 1
|
|
#define DP_VLAN_TAGGED_UNICAST 2
|
|
|
|
/**
|
|
* struct htt_dbgfs_cfg - structure to maintain required htt data
|
|
* @msg_word: htt msg sent to upper layer
|
|
* @m: qdf debugfs file pointer
|
|
*/
|
|
struct htt_dbgfs_cfg {
|
|
uint32_t *msg_word;
|
|
qdf_debugfs_file_t m;
|
|
};
|
|
|
|
/* Cookie MSB bits assigned for different use case.
|
|
* Note: User can't use last 3 bits, as it is reserved for pdev_id.
|
|
* If in future number of pdev are more than 3.
|
|
*/
|
|
/* Reserve for default case */
|
|
#define DBG_STATS_COOKIE_DEFAULT 0x0
|
|
|
|
/* Reserve for DP Stats: 3rd bit */
|
|
#define DBG_STATS_COOKIE_DP_STATS BIT(3)
|
|
|
|
/* Reserve for HTT Stats debugfs support: 4th bit */
|
|
#define DBG_STATS_COOKIE_HTT_DBGFS BIT(4)
|
|
|
|
/*Reserve for HTT Stats debugfs support: 5th bit */
|
|
#define DBG_SYSFS_STATS_COOKIE BIT(5)
|
|
|
|
/* Reserve for HTT Stats OBSS PD support: 6th bit */
|
|
#define DBG_STATS_COOKIE_HTT_OBSS BIT(6)
|
|
|
|
/*
|
|
* Bitmap of HTT PPDU TLV types for Default mode
|
|
*/
|
|
#define HTT_PPDU_DEFAULT_TLV_BITMAP \
|
|
(1 << HTT_PPDU_STATS_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_RATE_TLV) | \
|
|
(1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV)
|
|
|
|
/* PPDU STATS CFG */
|
|
#define DP_PPDU_STATS_CFG_ALL 0xFFFF
|
|
|
|
/* PPDU stats mask sent to FW to enable enhanced stats */
|
|
#define DP_PPDU_STATS_CFG_ENH_STATS \
|
|
(HTT_PPDU_DEFAULT_TLV_BITMAP) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USERS_INFO_TLV)
|
|
|
|
/* PPDU stats mask sent to FW to support debug sniffer feature */
|
|
#define DP_PPDU_STATS_CFG_SNIFFER \
|
|
(HTT_PPDU_DEFAULT_TLV_BITMAP) | \
|
|
(1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \
|
|
(1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USERS_INFO_TLV)
|
|
|
|
/* PPDU stats mask sent to FW to support BPR feature*/
|
|
#define DP_PPDU_STATS_CFG_BPR \
|
|
(1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USERS_INFO_TLV)
|
|
|
|
/* PPDU stats mask sent to FW to support BPR and enhanced stats feature */
|
|
#define DP_PPDU_STATS_CFG_BPR_ENH (DP_PPDU_STATS_CFG_BPR | \
|
|
DP_PPDU_STATS_CFG_ENH_STATS)
|
|
/* PPDU stats mask sent to FW to support BPR and pcktlog stats feature */
|
|
#define DP_PPDU_STATS_CFG_BPR_PKTLOG (DP_PPDU_STATS_CFG_BPR | \
|
|
DP_PPDU_TXLITE_STATS_BITMASK_CFG)
|
|
|
|
/*
|
|
* Bitmap of HTT PPDU delayed ba TLV types for Default mode
|
|
*/
|
|
#define HTT_PPDU_DELAYED_BA_TLV_BITMAP \
|
|
(1 << HTT_PPDU_STATS_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_RATE_TLV)
|
|
|
|
/*
|
|
* Bitmap of HTT PPDU TLV types for Delayed BA
|
|
*/
|
|
#define HTT_PPDU_STATUS_TLV_BITMAP \
|
|
(1 << HTT_PPDU_STATS_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV)
|
|
|
|
/*
|
|
* Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 64
|
|
*/
|
|
#define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64 \
|
|
((1 << HTT_PPDU_STATS_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_RATE_TLV) | \
|
|
(1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV))
|
|
|
|
/*
|
|
* Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 256
|
|
*/
|
|
#define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256 \
|
|
((1 << HTT_PPDU_STATS_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_RATE_TLV) | \
|
|
(1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \
|
|
(1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV))
|
|
|
|
static const enum cdp_packet_type hal_2_dp_pkt_type_map[HAL_DOT11_MAX] = {
|
|
[HAL_DOT11A] = DOT11_A,
|
|
[HAL_DOT11B] = DOT11_B,
|
|
[HAL_DOT11N_MM] = DOT11_N,
|
|
[HAL_DOT11AC] = DOT11_AC,
|
|
[HAL_DOT11AX] = DOT11_AX,
|
|
[HAL_DOT11BA] = DOT11_MAX,
|
|
#ifdef WLAN_FEATURE_11BE
|
|
[HAL_DOT11BE] = DOT11_BE,
|
|
#else
|
|
[HAL_DOT11BE] = DOT11_MAX,
|
|
#endif
|
|
[HAL_DOT11AZ] = DOT11_MAX,
|
|
[HAL_DOT11N_GF] = DOT11_MAX,
|
|
};
|
|
|
|
#ifdef GLOBAL_ASSERT_AVOIDANCE
|
|
#define dp_assert_always_internal_stat(_expr, _handle, _field) \
|
|
(qdf_unlikely(!(_expr)) ? ((_handle)->stats._field++, true) : false)
|
|
|
|
#define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \
|
|
((_handle)->ppeds_stats._field++)
|
|
|
|
static inline bool dp_assert_always_internal(bool expr)
|
|
{
|
|
return !expr;
|
|
}
|
|
#else
|
|
static inline bool __dp_assert_always_internal(bool expr)
|
|
{
|
|
qdf_assert_always(expr);
|
|
|
|
return false;
|
|
}
|
|
|
|
#define dp_assert_always_internal(_expr) __dp_assert_always_internal(_expr)
|
|
|
|
#define dp_assert_always_internal_stat(_expr, _handle, _field) \
|
|
dp_assert_always_internal(_expr)
|
|
|
|
#define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \
|
|
dp_assert_always_internal(_expr)
|
|
#endif
|
|
|
|
#ifdef WLAN_FEATURE_11BE
|
|
/**
|
|
* dp_get_mcs_array_index_by_pkt_type_mcs() - get the destination mcs index
|
|
* in array
|
|
* @pkt_type: host SW pkt type
|
|
* @mcs: mcs value for TX/RX rate
|
|
*
|
|
* Return: succeeded - valid index in mcs array
|
|
* fail - same value as MCS_MAX
|
|
*/
|
|
static inline uint8_t
|
|
dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs)
|
|
{
|
|
uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX;
|
|
|
|
switch (pkt_type) {
|
|
case DOT11_A:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_B:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_N:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_AC:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_AX:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_BE:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11BE ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return dst_mcs_idx;
|
|
}
|
|
#else
|
|
static inline uint8_t
|
|
dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs)
|
|
{
|
|
uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX;
|
|
|
|
switch (pkt_type) {
|
|
case DOT11_A:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_B:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_N:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_AC:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
case DOT11_AX:
|
|
dst_mcs_idx =
|
|
mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return dst_mcs_idx;
|
|
}
|
|
#endif
|
|
|
|
#ifdef WIFI_MONITOR_SUPPORT
|
|
QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
|
|
QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
|
|
#else
|
|
static inline
|
|
QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_rx_err_match_dhost() - function to check whether dest-mac is correct
|
|
* @eh: Ethernet header of incoming packet
|
|
* @vdev: dp_vdev object of the VAP on which this data packet is received
|
|
*
|
|
* Return: 1 if the destination mac is correct,
|
|
* 0 if this frame is not correctly destined to this VAP/MLD
|
|
*/
|
|
int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev);
|
|
|
|
#ifdef MONITOR_MODULARIZED_ENABLE
|
|
static inline bool dp_monitor_modularized_enable(void)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static inline QDF_STATUS
|
|
dp_mon_soc_attach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; }
|
|
|
|
static inline QDF_STATUS
|
|
dp_mon_soc_detach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; }
|
|
#else
|
|
static inline bool dp_monitor_modularized_enable(void)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_mon_soc_attach_wrapper(struct dp_soc *soc)
|
|
{
|
|
return dp_mon_soc_attach(soc);
|
|
}
|
|
|
|
static inline QDF_STATUS dp_mon_soc_detach_wrapper(struct dp_soc *soc)
|
|
{
|
|
return dp_mon_soc_detach(soc);
|
|
}
|
|
#endif
|
|
|
|
#ifndef WIFI_MONITOR_SUPPORT
|
|
#define MON_BUF_MIN_ENTRIES 64
|
|
|
|
static inline QDF_STATUS dp_monitor_pdev_attach(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_pdev_detach(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_vdev_attach(struct dp_vdev *vdev)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_vdev_detach(struct dp_vdev *vdev)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_peer_attach(struct dp_soc *soc,
|
|
struct dp_peer *peer)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_peer_detach(struct dp_soc *soc,
|
|
struct dp_peer *peer)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline struct cdp_peer_rate_stats_ctx*
|
|
dp_monitor_peer_get_peerstats_ctx(struct dp_soc *soc, struct dp_peer *peer)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_peer_reset_stats(struct dp_soc *soc, struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_peer_get_stats(struct dp_soc *soc, struct dp_peer *peer,
|
|
void *arg, enum cdp_stat_update_type type)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc *soc,
|
|
struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_peer_get_stats_param(struct dp_soc *soc,
|
|
struct dp_peer *peer,
|
|
enum cdp_peer_stats_type type,
|
|
cdp_peer_stats_param_t *buf)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_pdev_init(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_pdev_deinit(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_soc_cfg_init(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_config_debug_sniffer(struct dp_pdev *pdev,
|
|
int val)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline void dp_monitor_flush_rings(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc,
|
|
struct dp_pdev *pdev,
|
|
int mac_id,
|
|
int mac_for_pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void dp_monitor_service_mon_rings(struct dp_soc *soc,
|
|
uint32_t quota)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline
|
|
uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev,
|
|
uint32_t mac_id, uint32_t quota)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void dp_monitor_peer_tx_init(struct dp_pdev *pdev,
|
|
struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_peer_tx_cleanup(struct dp_vdev *vdev,
|
|
struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc,
|
|
struct dp_peer *peer,
|
|
uint16_t peer_id)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev,
|
|
struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc,
|
|
struct dp_tx_desc_s *desc,
|
|
struct hal_tx_completion_status *ts,
|
|
uint16_t peer_id)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc,
|
|
struct dp_pdev *pdev,
|
|
struct dp_peer *peer,
|
|
struct hal_tx_completion_status *ts,
|
|
qdf_nbuf_t netbuf)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc,
|
|
uint32_t *msg_word,
|
|
qdf_nbuf_t htt_t2h_msg)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_htt_ppdu_stats_attach(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void dp_monitor_htt_ppdu_stats_detach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_config_enh_tx_capture(struct dp_pdev *pdev,
|
|
uint32_t val)
|
|
{
|
|
return QDF_STATUS_E_INVAL;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_tx_peer_filter(struct dp_pdev *pdev,
|
|
struct dp_peer *peer,
|
|
uint8_t is_tx_pkt_cap_enable,
|
|
uint8_t *peer_mac)
|
|
{
|
|
return QDF_STATUS_E_INVAL;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev,
|
|
uint32_t val)
|
|
{
|
|
return QDF_STATUS_E_INVAL;
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev, uint32_t val)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline
|
|
int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
|
|
bool enable)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_neighbour_peers_detach(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev,
|
|
uint8_t *rx_pkt_hdr)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline void dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_reap_timer_init(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_reap_timer_deinit(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_reap_timer_start(struct dp_soc *soc,
|
|
enum cdp_mon_reap_source source)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_reap_timer_stop(struct dp_soc *soc,
|
|
enum cdp_mon_reap_source source)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void
|
|
dp_monitor_reap_timer_suspend(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_vdev_timer_init(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_vdev_timer_deinit(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_vdev_timer_start(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
bool dp_monitor_vdev_timer_stop(struct dp_soc *soc)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline struct qdf_mem_multi_page_t*
|
|
dp_monitor_get_link_desc_pages(struct dp_soc *soc, uint32_t mac_id)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct dp_srng*
|
|
dp_monitor_get_link_desc_ring(struct dp_soc *soc, uint32_t mac_id)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline uint32_t
|
|
dp_monitor_get_num_link_desc_ring_entries(struct dp_soc *soc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline uint32_t *
|
|
dp_monitor_get_total_link_descs(struct dp_soc *soc, uint32_t mac_id)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline bool dp_is_enable_reap_timer_non_pkt(struct dp_pdev *pdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void dp_monitor_vdev_register_osif(struct dp_vdev *vdev,
|
|
struct ol_txrx_ops *txrx_ops)
|
|
{
|
|
}
|
|
|
|
static inline bool dp_monitor_is_vdev_timer_running(struct dp_soc *soc)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_pdev_set_mon_vdev(struct dp_vdev *vdev)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_vdev_delete(struct dp_soc *soc,
|
|
struct dp_vdev *vdev)
|
|
{
|
|
}
|
|
|
|
static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_neighbour_peer_add_ast(struct dp_pdev *pdev,
|
|
struct dp_peer *ta_peer,
|
|
uint8_t *mac_addr,
|
|
qdf_nbuf_t nbuf,
|
|
uint32_t flags)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_monitor_set_chan_band(struct dp_pdev *pdev, enum reg_wifi_band chan_band)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_monitor_set_chan_freq(struct dp_pdev *pdev, qdf_freq_t chan_freq)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_set_chan_num(struct dp_pdev *pdev, int chan_num)
|
|
{
|
|
}
|
|
|
|
static inline bool dp_monitor_is_enable_mcopy_mode(struct dp_pdev *pdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_neighbour_peer_list_remove(struct dp_pdev *pdev,
|
|
struct dp_vdev *vdev,
|
|
struct dp_neighbour_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline bool dp_monitor_is_chan_band_known(struct dp_pdev *pdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline enum reg_wifi_band
|
|
dp_monitor_get_chan_band(struct dp_pdev *pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
dp_monitor_get_chan_num(struct dp_pdev *pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline qdf_freq_t
|
|
dp_monitor_get_chan_freq(struct dp_pdev *pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void dp_monitor_get_mpdu_status(struct dp_pdev *pdev,
|
|
struct dp_soc *soc,
|
|
uint8_t *rx_tlv_hdr)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_print_tx_stats(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev,
|
|
uint16_t peer_id, uint32_t ppdu_id,
|
|
uint8_t first_msdu)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline bool dp_monitor_is_enable_tx_sniffer(struct dp_pdev *pdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline struct dp_vdev*
|
|
dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev *pdev)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_check_com_info_ppdu_id(struct dp_pdev *pdev,
|
|
void *rx_desc)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline struct mon_rx_status*
|
|
dp_monitor_get_rx_status(struct dp_pdev *pdev)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev *pdev, bool val)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev,
|
|
bool val)
|
|
{
|
|
}
|
|
|
|
static inline QDF_STATUS
|
|
dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer,
|
|
struct cdp_peer_tx_capture_stats *stats)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline QDF_STATUS
|
|
dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
struct cdp_pdev_tx_capture_stats *stats)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
#ifdef DP_POWER_SAVE
|
|
static inline
|
|
void dp_monitor_pktlog_reap_pending_frames(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_pktlog_start_reap_timer(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static inline bool dp_monitor_is_configured(struct dp_pdev *pdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_soc_init(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline void dp_monitor_soc_deinit(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev,
|
|
int val)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS
|
|
dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
|
|
int mask1, int mask2)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS
|
|
dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev,
|
|
int *mask, int *mask_cont)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_monitor_soc_htt_srng_setup(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline
|
|
uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline uint32_t
|
|
dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
|
|
uint32_t mac_id, uint32_t quota)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline uint32_t
|
|
dp_print_txmon_ring_stat_from_hal(struct dp_pdev *pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline
|
|
uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline bool dp_monitor_is_tx_cap_enabled(struct dp_peer *peer)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline bool dp_monitor_is_rx_cap_enabled(struct dp_peer *peer)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void
|
|
dp_rx_mon_enable(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_wmask_subscribe(struct dp_soc *soc,
|
|
uint32_t *msg_word, int pdev_id,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_mac_filter_set(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_enable_pkt_tlv_offset(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_mon_rx_enable_fpmo(struct dp_soc *soc, uint32_t *msg_word,
|
|
struct htt_rx_ring_tlv_filter *tlv_filter)
|
|
{
|
|
}
|
|
|
|
#ifdef WLAN_CONFIG_TELEMETRY_AGENT
|
|
static inline
|
|
void dp_monitor_peer_telemetry_stats(struct dp_peer *peer,
|
|
struct cdp_peer_telemetry_stats *stats)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_monitor_peer_deter_stats(struct dp_peer *peer,
|
|
struct cdp_peer_telemetry_stats *stats)
|
|
{
|
|
}
|
|
#endif /* WLAN_CONFIG_TELEMETRY_AGENT */
|
|
#endif /* !WIFI_MONITOR_SUPPORT */
|
|
|
|
/**
|
|
* cdp_soc_t_to_dp_soc() - typecast cdp_soc_t to
|
|
* dp soc handle
|
|
* @psoc: CDP psoc handle
|
|
*
|
|
* Return: struct dp_soc pointer
|
|
*/
|
|
static inline
|
|
struct dp_soc *cdp_soc_t_to_dp_soc(struct cdp_soc_t *psoc)
|
|
{
|
|
return (struct dp_soc *)psoc;
|
|
}
|
|
|
|
#define DP_MAX_TIMER_EXEC_TIME_TICKS \
|
|
(QDF_LOG_TIMESTAMP_CYCLES_PER_10_US * 100 * 20)
|
|
|
|
/**
|
|
* enum timer_yield_status - yield status code used in monitor mode timer.
|
|
* @DP_TIMER_NO_YIELD: do not yield
|
|
* @DP_TIMER_WORK_DONE: yield because work is done
|
|
* @DP_TIMER_WORK_EXHAUST: yield because work quota is exhausted
|
|
* @DP_TIMER_TIME_EXHAUST: yield due to time slot exhausted
|
|
*/
|
|
enum timer_yield_status {
|
|
DP_TIMER_NO_YIELD,
|
|
DP_TIMER_WORK_DONE,
|
|
DP_TIMER_WORK_EXHAUST,
|
|
DP_TIMER_TIME_EXHAUST,
|
|
};
|
|
|
|
#if DP_PRINT_ENABLE
|
|
#include <qdf_types.h> /* qdf_vprint */
|
|
#include <cdp_txrx_handle.h>
|
|
|
|
enum {
|
|
/* FATAL_ERR - print only irrecoverable error messages */
|
|
DP_PRINT_LEVEL_FATAL_ERR,
|
|
|
|
/* ERR - include non-fatal err messages */
|
|
DP_PRINT_LEVEL_ERR,
|
|
|
|
/* WARN - include warnings */
|
|
DP_PRINT_LEVEL_WARN,
|
|
|
|
/* INFO1 - include fundamental, infrequent events */
|
|
DP_PRINT_LEVEL_INFO1,
|
|
|
|
/* INFO2 - include non-fundamental but infrequent events */
|
|
DP_PRINT_LEVEL_INFO2,
|
|
};
|
|
|
|
#define dp_print(level, fmt, ...) do { \
|
|
if (level <= g_txrx_print_level) \
|
|
qdf_print(fmt, ## __VA_ARGS__); \
|
|
while (0)
|
|
#define DP_PRINT(level, fmt, ...) do { \
|
|
dp_print(level, "DP: " fmt, ## __VA_ARGS__); \
|
|
while (0)
|
|
#else
|
|
#define DP_PRINT(level, fmt, ...)
|
|
#endif /* DP_PRINT_ENABLE */
|
|
|
|
#define DP_TRACE(LVL, fmt, args ...) \
|
|
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_##LVL, \
|
|
fmt, ## args)
|
|
|
|
#ifdef WLAN_SYSFS_DP_STATS
|
|
void DP_PRINT_STATS(const char *fmt, ...);
|
|
#else /* WLAN_SYSFS_DP_STATS */
|
|
#ifdef DP_PRINT_NO_CONSOLE
|
|
/* Stat prints should not go to console or kernel logs.*/
|
|
#define DP_PRINT_STATS(fmt, args ...)\
|
|
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_HIGH, \
|
|
fmt, ## args)
|
|
#else
|
|
#define DP_PRINT_STATS(fmt, args ...)\
|
|
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,\
|
|
fmt, ## args)
|
|
#endif
|
|
#endif /* WLAN_SYSFS_DP_STATS */
|
|
|
|
#define DP_STATS_INIT(_handle) \
|
|
qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats))
|
|
|
|
#define DP_TXRX_PEER_STATS_INIT(_handle, size) \
|
|
qdf_mem_zero(&((_handle)->stats[0]), size)
|
|
|
|
#define DP_STATS_CLR(_handle) \
|
|
qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats))
|
|
|
|
#define DP_TXRX_PEER_STATS_CLR(_handle, size) \
|
|
qdf_mem_zero(&((_handle)->stats[0]), size)
|
|
|
|
#ifndef DISABLE_DP_STATS
|
|
#define DP_STATS_INC(_handle, _field, _delta) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->stats._field += _delta; \
|
|
}
|
|
|
|
#define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->stats[_link]._field += _delta; \
|
|
}
|
|
|
|
#define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->_field += _delta; \
|
|
}
|
|
|
|
#define DP_STATS_INCC(_handle, _field, _delta, _cond) \
|
|
{ \
|
|
if (_cond && likely(_handle)) \
|
|
_handle->stats._field += _delta; \
|
|
}
|
|
|
|
#define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link) \
|
|
{ \
|
|
if (_cond && likely(_handle)) \
|
|
_handle->stats[_link]._field += _delta; \
|
|
}
|
|
|
|
#define DP_STATS_DEC(_handle, _field, _delta) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->stats._field -= _delta; \
|
|
}
|
|
|
|
#define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->_field -= _delta; \
|
|
}
|
|
|
|
#define DP_STATS_UPD(_handle, _field, _delta) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->stats._field = _delta; \
|
|
}
|
|
|
|
#define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link) \
|
|
{ \
|
|
if (likely(_handle)) \
|
|
_handle->stats[_link]._field = _delta; \
|
|
}
|
|
|
|
#define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) \
|
|
{ \
|
|
DP_STATS_INC(_handle, _field.num, _count); \
|
|
DP_STATS_INC(_handle, _field.bytes, _bytes) \
|
|
}
|
|
|
|
#define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) \
|
|
{ \
|
|
DP_PEER_STATS_FLAT_INC(_handle, _field.num, _count); \
|
|
DP_PEER_STATS_FLAT_INC(_handle, _field.bytes, _bytes) \
|
|
}
|
|
|
|
#define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) \
|
|
{ \
|
|
DP_STATS_INCC(_handle, _field.num, _count, _cond); \
|
|
DP_STATS_INCC(_handle, _field.bytes, _bytes, _cond) \
|
|
}
|
|
|
|
#define DP_STATS_AGGR(_handle_a, _handle_b, _field) \
|
|
{ \
|
|
_handle_a->stats._field += _handle_b->stats._field; \
|
|
}
|
|
|
|
#define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) \
|
|
{ \
|
|
DP_STATS_AGGR(_handle_a, _handle_b, _field.num); \
|
|
DP_STATS_AGGR(_handle_a, _handle_b, _field.bytes);\
|
|
}
|
|
|
|
#define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx) \
|
|
{ \
|
|
_handle_a->stats._arr._field += _handle_b->stats._arr[_idx]._field; \
|
|
}
|
|
|
|
#define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx)\
|
|
{ \
|
|
DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.num, _idx); \
|
|
DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.bytes, _idx);\
|
|
}
|
|
|
|
#define DP_STATS_UPD_STRUCT(_handle_a, _handle_b, _field) \
|
|
{ \
|
|
_handle_a->stats._field = _handle_b->stats._field; \
|
|
}
|
|
|
|
#else
|
|
#define DP_STATS_INC(_handle, _field, _delta)
|
|
#define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link)
|
|
#define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta)
|
|
#define DP_STATS_INCC(_handle, _field, _delta, _cond)
|
|
#define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link)
|
|
#define DP_STATS_DEC(_handle, _field, _delta)
|
|
#define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta)
|
|
#define DP_STATS_UPD(_handle, _field, _delta)
|
|
#define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link)
|
|
#define DP_STATS_INC_PKT(_handle, _field, _count, _bytes)
|
|
#define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes)
|
|
#define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond)
|
|
#define DP_STATS_AGGR(_handle_a, _handle_b, _field)
|
|
#define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field)
|
|
#define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx)
|
|
#define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx)
|
|
#endif
|
|
|
|
#define DP_PEER_PER_PKT_STATS_INC(_handle, _field, _delta, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_INC(_handle, per_pkt_stats._field, _delta, _link); \
|
|
}
|
|
|
|
#define DP_PEER_PER_PKT_STATS_INCC(_handle, _field, _delta, _cond, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_INCC(_handle, per_pkt_stats._field, _delta, _cond, _link); \
|
|
}
|
|
|
|
#define DP_PEER_PER_PKT_STATS_INC_PKT(_handle, _field, _count, _bytes, _link) \
|
|
{ \
|
|
DP_PEER_PER_PKT_STATS_INC(_handle, _field.num, _count, _link); \
|
|
DP_PEER_PER_PKT_STATS_INC(_handle, _field.bytes, _bytes, _link) \
|
|
}
|
|
|
|
#define DP_PEER_PER_PKT_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
DP_PEER_PER_PKT_STATS_INCC(_handle, _field.num, _count, _cond, _link); \
|
|
DP_PEER_PER_PKT_STATS_INCC(_handle, _field.bytes, _bytes, _cond, _link) \
|
|
}
|
|
|
|
#define DP_PEER_PER_PKT_STATS_UPD(_handle, _field, _delta, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_UPD(_handle, per_pkt_stats._field, _delta, _link); \
|
|
}
|
|
|
|
#ifndef QCA_ENHANCED_STATS_SUPPORT
|
|
#define DP_PEER_EXTD_STATS_INC(_handle, _field, _delta, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_INC(_handle, extd_stats._field, _delta, _link); \
|
|
}
|
|
|
|
#define DP_PEER_EXTD_STATS_INCC(_handle, _field, _delta, _cond, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_INCC(_handle, extd_stats._field, _delta, _cond, _link); \
|
|
}
|
|
|
|
#define DP_PEER_EXTD_STATS_UPD(_handle, _field, _delta, _link) \
|
|
{ \
|
|
DP_PEER_LINK_STATS_UPD(_handle, extd_stats._field, _delta, _link); \
|
|
}
|
|
#endif
|
|
|
|
#if defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) && \
|
|
defined(QCA_ENHANCED_STATS_SUPPORT)
|
|
#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
|
|
{ \
|
|
if (_cond || !(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \
|
|
}
|
|
|
|
#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
|
|
{ \
|
|
if (_cond || !(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \
|
|
}
|
|
|
|
#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (_cond || !(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \
|
|
}
|
|
|
|
#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (_cond || !(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \
|
|
}
|
|
|
|
#define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (_cond || !(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \
|
|
}
|
|
#elif defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT)
|
|
#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
|
|
{ \
|
|
if (!(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \
|
|
}
|
|
|
|
#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
|
|
{ \
|
|
if (!(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \
|
|
}
|
|
|
|
#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (!(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \
|
|
}
|
|
|
|
#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (!(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \
|
|
}
|
|
|
|
#define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
{ \
|
|
if (!(_handle->hw_txrx_stats_en)) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \
|
|
}
|
|
#else
|
|
#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
|
|
DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes);
|
|
|
|
#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
|
|
DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count);
|
|
|
|
#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link);
|
|
|
|
#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link);
|
|
|
|
#define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \
|
|
DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link);
|
|
#endif
|
|
|
|
#ifdef ENABLE_DP_HIST_STATS
|
|
#define DP_HIST_INIT() \
|
|
uint32_t num_of_packets[MAX_PDEV_CNT] = {0};
|
|
|
|
#define DP_HIST_PACKET_COUNT_INC(_pdev_id) \
|
|
{ \
|
|
++num_of_packets[_pdev_id]; \
|
|
}
|
|
|
|
#define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \
|
|
do { \
|
|
if (_p_cntrs == 1) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_1, 1); \
|
|
} else if (_p_cntrs > 1 && _p_cntrs <= 20) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_2_20, 1); \
|
|
} else if (_p_cntrs > 20 && _p_cntrs <= 40) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_21_40, 1); \
|
|
} else if (_p_cntrs > 40 && _p_cntrs <= 60) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_41_60, 1); \
|
|
} else if (_p_cntrs > 60 && _p_cntrs <= 80) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_61_80, 1); \
|
|
} else if (_p_cntrs > 80 && _p_cntrs <= 100) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_81_100, 1); \
|
|
} else if (_p_cntrs > 100 && _p_cntrs <= 200) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_101_200, 1); \
|
|
} else if (_p_cntrs > 200) { \
|
|
DP_STATS_INC(_pdev, \
|
|
tx_comp_histogram.pkts_201_plus, 1); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \
|
|
do { \
|
|
if (_p_cntrs == 1) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_1, 1); \
|
|
} else if (_p_cntrs > 1 && _p_cntrs <= 20) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_2_20, 1); \
|
|
} else if (_p_cntrs > 20 && _p_cntrs <= 40) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_21_40, 1); \
|
|
} else if (_p_cntrs > 40 && _p_cntrs <= 60) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_41_60, 1); \
|
|
} else if (_p_cntrs > 60 && _p_cntrs <= 80) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_61_80, 1); \
|
|
} else if (_p_cntrs > 80 && _p_cntrs <= 100) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_81_100, 1); \
|
|
} else if (_p_cntrs > 100 && _p_cntrs <= 200) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_101_200, 1); \
|
|
} else if (_p_cntrs > 200) { \
|
|
DP_STATS_INC(_pdev, \
|
|
rx_ind_histogram.pkts_201_plus, 1); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define DP_TX_HIST_STATS_PER_PDEV() \
|
|
do { \
|
|
uint8_t hist_stats = 0; \
|
|
for (hist_stats = 0; hist_stats < soc->pdev_count; \
|
|
hist_stats++) { \
|
|
DP_TX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \
|
|
num_of_packets[hist_stats]); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
#define DP_RX_HIST_STATS_PER_PDEV() \
|
|
do { \
|
|
uint8_t hist_stats = 0; \
|
|
for (hist_stats = 0; hist_stats < soc->pdev_count; \
|
|
hist_stats++) { \
|
|
DP_RX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \
|
|
num_of_packets[hist_stats]); \
|
|
} \
|
|
} while (0)
|
|
|
|
#else
|
|
#define DP_HIST_INIT()
|
|
#define DP_HIST_PACKET_COUNT_INC(_pdev_id)
|
|
#define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs)
|
|
#define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs)
|
|
#define DP_RX_HIST_STATS_PER_PDEV()
|
|
#define DP_TX_HIST_STATS_PER_PDEV()
|
|
#endif /* DISABLE_DP_STATS */
|
|
|
|
#define FRAME_MASK_IPV4_ARP 1
|
|
#define FRAME_MASK_IPV4_DHCP 2
|
|
#define FRAME_MASK_IPV4_EAPOL 4
|
|
#define FRAME_MASK_IPV6_DHCP 8
|
|
|
|
static inline int dp_log2_ceil(unsigned int value)
|
|
{
|
|
unsigned int tmp = value;
|
|
int log2 = -1;
|
|
|
|
if (qdf_unlikely(value == 0))
|
|
return 0;
|
|
while (tmp) {
|
|
log2++;
|
|
tmp >>= 1;
|
|
}
|
|
if (1 << log2 != value)
|
|
log2++;
|
|
return log2;
|
|
}
|
|
|
|
#ifdef QCA_SUPPORT_PEER_ISOLATION
|
|
#define dp_get_peer_isolation(_peer) ((_peer)->isolation)
|
|
|
|
static inline void dp_set_peer_isolation(struct dp_txrx_peer *txrx_peer,
|
|
bool val)
|
|
{
|
|
txrx_peer->isolation = val;
|
|
}
|
|
|
|
#else
|
|
#define dp_get_peer_isolation(_peer) (0)
|
|
|
|
static inline void dp_set_peer_isolation(struct dp_txrx_peer *peer, bool val)
|
|
{
|
|
}
|
|
#endif /* QCA_SUPPORT_PEER_ISOLATION */
|
|
|
|
bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev);
|
|
|
|
#ifdef QCA_SUPPORT_WDS_EXTENDED
|
|
static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer)
|
|
{
|
|
txrx_peer->wds_ext.osif_peer = NULL;
|
|
txrx_peer->wds_ext.init = 0;
|
|
}
|
|
#else
|
|
static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer)
|
|
{
|
|
}
|
|
#endif /* QCA_SUPPORT_WDS_EXTENDED */
|
|
|
|
#ifdef QCA_HOST2FW_RXBUF_RING
|
|
static inline
|
|
struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id)
|
|
{
|
|
return &pdev->rx_mac_buf_ring[lmac_id];
|
|
}
|
|
#else
|
|
static inline
|
|
struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id)
|
|
{
|
|
return &pdev->soc->rx_refill_buf_ring[lmac_id];
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* The lmac ID for a particular channel band is fixed.
|
|
* 2.4GHz band uses lmac_id = 1
|
|
* 5GHz/6GHz band uses lmac_id=0
|
|
*/
|
|
#define DP_INVALID_LMAC_ID (-1)
|
|
#define DP_MON_INVALID_LMAC_ID (-1)
|
|
#define DP_MAC0_LMAC_ID 0
|
|
#define DP_MAC1_LMAC_ID 1
|
|
|
|
#ifdef FEATURE_TSO_STATS
|
|
/**
|
|
* dp_init_tso_stats() - Clear tso stats
|
|
* @pdev: pdev handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline
|
|
void dp_init_tso_stats(struct dp_pdev *pdev)
|
|
{
|
|
if (pdev) {
|
|
qdf_mem_zero(&((pdev)->stats.tso_stats),
|
|
sizeof((pdev)->stats.tso_stats));
|
|
qdf_atomic_init(&pdev->tso_idx);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_stats_tso_segment_histogram_update() - TSO Segment Histogram
|
|
* @pdev: pdev handle
|
|
* @_p_cntrs: number of tso segments for a tso packet
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev,
|
|
uint8_t _p_cntrs);
|
|
|
|
/**
|
|
* dp_tso_segment_update() - Collect tso segment information
|
|
* @pdev: pdev handle
|
|
* @stats_idx: tso packet number
|
|
* @idx: tso segment number
|
|
* @seg: tso segment
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_tso_segment_update(struct dp_pdev *pdev,
|
|
uint32_t stats_idx,
|
|
uint8_t idx,
|
|
struct qdf_tso_seg_t seg);
|
|
|
|
/**
|
|
* dp_tso_packet_update() - TSO Packet information
|
|
* @pdev: pdev handle
|
|
* @stats_idx: tso packet number
|
|
* @msdu: nbuf handle
|
|
* @num_segs: tso segments
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx,
|
|
qdf_nbuf_t msdu, uint16_t num_segs);
|
|
|
|
/**
|
|
* dp_tso_segment_stats_update() - TSO Segment stats
|
|
* @pdev: pdev handle
|
|
* @stats_seg: tso segment list
|
|
* @stats_idx: tso packet number
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_tso_segment_stats_update(struct dp_pdev *pdev,
|
|
struct qdf_tso_seg_elem_t *stats_seg,
|
|
uint32_t stats_idx);
|
|
|
|
/**
|
|
* dp_print_tso_stats() - dump tso statistics
|
|
* @soc:soc handle
|
|
* @level: verbosity level
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_print_tso_stats(struct dp_soc *soc,
|
|
enum qdf_stats_verbosity_level level);
|
|
|
|
/**
|
|
* dp_txrx_clear_tso_stats() - clear tso stats
|
|
* @soc: soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_txrx_clear_tso_stats(struct dp_soc *soc);
|
|
#else
|
|
static inline
|
|
void dp_init_tso_stats(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev,
|
|
uint8_t _p_cntrs)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_tso_segment_update(struct dp_pdev *pdev,
|
|
uint32_t stats_idx,
|
|
uint32_t idx,
|
|
struct qdf_tso_seg_t seg)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx,
|
|
qdf_nbuf_t msdu, uint16_t num_segs)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_tso_segment_stats_update(struct dp_pdev *pdev,
|
|
struct qdf_tso_seg_elem_t *stats_seg,
|
|
uint32_t stats_idx)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_print_tso_stats(struct dp_soc *soc,
|
|
enum qdf_stats_verbosity_level level)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_txrx_clear_tso_stats(struct dp_soc *soc)
|
|
{
|
|
}
|
|
#endif /* FEATURE_TSO_STATS */
|
|
|
|
/**
|
|
* dp_txrx_get_peer_per_pkt_stats_param() - Get peer per pkt stats param
|
|
* @peer: DP peer handle
|
|
* @type: Requested stats type
|
|
* @buf: Buffer to hold the value
|
|
*
|
|
* Return: status success/failure
|
|
*/
|
|
QDF_STATUS dp_txrx_get_peer_per_pkt_stats_param(struct dp_peer *peer,
|
|
enum cdp_peer_stats_type type,
|
|
cdp_peer_stats_param_t *buf);
|
|
|
|
/**
|
|
* dp_txrx_get_peer_extd_stats_param() - Get peer extd stats param
|
|
* @peer: DP peer handle
|
|
* @type: Requested stats type
|
|
* @buf: Buffer to hold the value
|
|
*
|
|
* Return: status success/failure
|
|
*/
|
|
QDF_STATUS dp_txrx_get_peer_extd_stats_param(struct dp_peer *peer,
|
|
enum cdp_peer_stats_type type,
|
|
cdp_peer_stats_param_t *buf);
|
|
|
|
#define DP_HTT_T2H_HP_PIPE 5
|
|
/**
|
|
* dp_update_pdev_stats(): Update the pdev stats
|
|
* @tgtobj: pdev handle
|
|
* @srcobj: vdev stats structure
|
|
*
|
|
* Update the pdev stats from the specified vdev stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_pdev_stats(struct dp_pdev *tgtobj,
|
|
struct cdp_vdev_stats *srcobj);
|
|
|
|
/**
|
|
* dp_update_vdev_ingress_stats(): Update the vdev ingress stats
|
|
* @tgtobj: vdev handle
|
|
*
|
|
* Update the vdev ingress stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_ingress_stats(struct dp_vdev *tgtobj);
|
|
|
|
/**
|
|
* dp_update_vdev_rate_stats() - Update the vdev rate stats
|
|
* @tgtobj: tgt buffer for cdp vdev stats
|
|
* @srcobj: srcobj dp vdev stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_rate_stats(struct cdp_vdev_stats *tgtobj,
|
|
struct dp_vdev_stats *srcobj);
|
|
|
|
/**
|
|
* dp_update_pdev_ingress_stats(): Update the pdev ingress stats
|
|
* @tgtobj: pdev handle
|
|
* @srcobj: vdev stats structure
|
|
*
|
|
* Update the pdev ingress stats from the specified vdev stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj,
|
|
struct dp_vdev *srcobj);
|
|
|
|
/**
|
|
* dp_copy_vdev_stats_to_tgt_buf(): Update the cdp vdev ingress stats from
|
|
* dp vdev ingress stats
|
|
* @vdev_stats: cdp vdev stats structure
|
|
* @stats: dp vdev stats structure
|
|
* @xmit_type: xmit type of packet - MLD/Link
|
|
*
|
|
* Update the cdp vdev ingress stats from dp vdev ingress stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
|
|
void dp_copy_vdev_stats_to_tgt_buf(struct cdp_vdev_stats *vdev_stats,
|
|
struct dp_vdev_stats *stats,
|
|
enum dp_pkt_xmit_type xmit_type);
|
|
|
|
/**
|
|
* dp_update_vdev_stats(): Update the vdev stats
|
|
* @soc: soc handle
|
|
* @srcobj: DP_PEER object
|
|
* @arg: point to vdev stats structure
|
|
*
|
|
* Update the vdev stats from the specified peer stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_stats(struct dp_soc *soc,
|
|
struct dp_peer *srcobj,
|
|
void *arg);
|
|
|
|
/**
|
|
* dp_update_vdev_stats_on_peer_unmap() - Update the vdev stats on peer unmap
|
|
* @vdev: DP_VDEV handle
|
|
* @peer: DP_PEER handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_stats_on_peer_unmap(struct dp_vdev *vdev,
|
|
struct dp_peer *peer);
|
|
|
|
#ifdef IPA_OFFLOAD
|
|
#define DP_IPA_UPDATE_RX_STATS(__tgtobj, __srcobj) \
|
|
{ \
|
|
DP_STATS_AGGR_PKT(__tgtobj, __srcobj, rx.rx_total); \
|
|
}
|
|
|
|
#define DP_IPA_UPDATE_PER_PKT_RX_STATS(__tgtobj, __srcobj) \
|
|
{ \
|
|
(__tgtobj)->rx.rx_total.num += (__srcobj)->rx.rx_total.num; \
|
|
(__tgtobj)->rx.rx_total.bytes += (__srcobj)->rx.rx_total.bytes; \
|
|
}
|
|
#else
|
|
#define DP_IPA_UPDATE_PER_PKT_RX_STATS(tgtobj, srcobj) \
|
|
|
|
#define DP_IPA_UPDATE_RX_STATS(tgtobj, srcobj)
|
|
#endif
|
|
|
|
#define DP_UPDATE_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
uint8_t i; \
|
|
uint8_t pream_type; \
|
|
for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \
|
|
for (i = 0; i < MAX_MCS; i++) { \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, \
|
|
tx.pkt_type[pream_type].mcs_count[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, \
|
|
rx.pkt_type[pream_type].mcs_count[i]); \
|
|
} \
|
|
} \
|
|
\
|
|
for (i = 0; i < MAX_BW; i++) { \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.bw[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.bw[i]); \
|
|
} \
|
|
\
|
|
for (i = 0; i < SS_COUNT; i++) { \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.nss[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.nss[i]); \
|
|
} \
|
|
for (i = 0; i < WME_AC_MAX; i++) { \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.wme_ac_type[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.wme_ac_type[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, \
|
|
tx.wme_ac_type_bytes[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, \
|
|
rx.wme_ac_type_bytes[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.excess_retries_per_ac[i]); \
|
|
\
|
|
} \
|
|
\
|
|
for (i = 0; i < MAX_GI; i++) { \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.sgi_count[i]); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.sgi_count[i]); \
|
|
} \
|
|
\
|
|
for (i = 0; i < MAX_RECEPTION_TYPES; i++) \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.reception_type[i]); \
|
|
\
|
|
if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.comp_pkt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.tx_failed); \
|
|
} \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.ucast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.mcast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.bcast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_success); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.nawds_mcast); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.nawds_mcast_drop); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.ofdma); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.stbc); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.ldpc); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.retries); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_amsdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.amsdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_ampdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.ampdu_cnt); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.dropped.fw_rem); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_tx); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_notx); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason1); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason2); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason3); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_queue_disable); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_no_match); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_threshold); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_link_desc_na); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_drop); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.mcast_vdev_drop); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_rr); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.age_out); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_total); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_success); \
|
|
\
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.mic_err); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.fcserr); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.pn_err); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.oor_err); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.jump_2k_err); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.rxdma_wifi_parse_err); \
|
|
if (_srcobj->stats.rx.snr != 0) \
|
|
DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.snr); \
|
|
DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.rx_rate); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_ampdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.ampdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_amsdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.amsdu_cnt); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.nawds_mcast_drop); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.to_stack); \
|
|
\
|
|
for (i = 0; i < CDP_MAX_RX_RINGS; i++) \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rcvd_reo[i]); \
|
|
\
|
|
for (i = 0; i < CDP_MAX_LMACS; i++) \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rx_lmac[i]); \
|
|
\
|
|
_srcobj->stats.rx.unicast.num = \
|
|
_srcobj->stats.rx.to_stack.num - \
|
|
_srcobj->stats.rx.multicast.num; \
|
|
_srcobj->stats.rx.unicast.bytes = \
|
|
_srcobj->stats.rx.to_stack.bytes - \
|
|
_srcobj->stats.rx.multicast.bytes; \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.unicast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.multicast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.bcast); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.raw); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.pkts); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.fail); \
|
|
DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.mec_drop); \
|
|
\
|
|
_tgtobj->stats.tx.last_ack_rssi = \
|
|
_srcobj->stats.tx.last_ack_rssi; \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.multipass_rx_pkt_drop); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.peer_unauth_rx_pkt_drop); \
|
|
DP_STATS_AGGR(_tgtobj, _srcobj, rx.policy_check_drop); \
|
|
DP_IPA_UPDATE_RX_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#ifdef VDEV_PEER_PROTOCOL_COUNT
|
|
#define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) \
|
|
{ \
|
|
uint8_t j; \
|
|
for (j = 0; j < CDP_TRACE_MAX; j++) { \
|
|
_tgtobj->tx.protocol_trace_cnt[j].egress_cnt += \
|
|
_srcobj->tx.protocol_trace_cnt[j].egress_cnt; \
|
|
_tgtobj->tx.protocol_trace_cnt[j].ingress_cnt += \
|
|
_srcobj->tx.protocol_trace_cnt[j].ingress_cnt; \
|
|
_tgtobj->rx.protocol_trace_cnt[j].egress_cnt += \
|
|
_srcobj->rx.protocol_trace_cnt[j].egress_cnt; \
|
|
_tgtobj->rx.protocol_trace_cnt[j].ingress_cnt += \
|
|
_srcobj->rx.protocol_trace_cnt[j].ingress_cnt; \
|
|
} \
|
|
}
|
|
#else
|
|
#define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj)
|
|
#endif
|
|
|
|
#ifdef WLAN_FEATURE_11BE
|
|
#define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
uint8_t i, mu_type; \
|
|
for (i = 0; i < MAX_MCS; i++) { \
|
|
_tgtobj->tx.su_be_ppdu_cnt.mcs_count[i] += \
|
|
_srcobj->tx.su_be_ppdu_cnt.mcs_count[i]; \
|
|
_tgtobj->rx.su_be_ppdu_cnt.mcs_count[i] += \
|
|
_srcobj->rx.su_be_ppdu_cnt.mcs_count[i]; \
|
|
} \
|
|
for (mu_type = 0; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \
|
|
for (i = 0; i < MAX_MCS; i++) { \
|
|
_tgtobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \
|
|
_srcobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \
|
|
_tgtobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \
|
|
_srcobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \
|
|
} \
|
|
} \
|
|
for (i = 0; i < MAX_PUNCTURED_MODE; i++) { \
|
|
_tgtobj->tx.punc_bw[i] += _srcobj->tx.punc_bw[i]; \
|
|
_tgtobj->rx.punc_bw[i] += _srcobj->rx.punc_bw[i]; \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj)
|
|
#endif
|
|
|
|
#define DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
_tgtobj->tx.comp_pkt.num += _srcobj->tx.comp_pkt.num; \
|
|
_tgtobj->tx.comp_pkt.bytes += _srcobj->tx.comp_pkt.bytes; \
|
|
_tgtobj->tx.tx_failed += _srcobj->tx.tx_failed; \
|
|
_tgtobj->rx.to_stack.num += _srcobj->rx.to_stack.num; \
|
|
_tgtobj->rx.to_stack.bytes += _srcobj->rx.to_stack.bytes; \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
uint8_t i; \
|
|
_tgtobj->tx.ucast.num += _srcobj->tx.ucast.num; \
|
|
_tgtobj->tx.ucast.bytes += _srcobj->tx.ucast.bytes; \
|
|
_tgtobj->tx.mcast.num += _srcobj->tx.mcast.num; \
|
|
_tgtobj->tx.mcast.bytes += _srcobj->tx.mcast.bytes; \
|
|
_tgtobj->tx.bcast.num += _srcobj->tx.bcast.num; \
|
|
_tgtobj->tx.bcast.bytes += _srcobj->tx.bcast.bytes; \
|
|
_tgtobj->tx.nawds_mcast.num += _srcobj->tx.nawds_mcast.num; \
|
|
_tgtobj->tx.nawds_mcast.bytes += \
|
|
_srcobj->tx.nawds_mcast.bytes; \
|
|
_tgtobj->tx.tx_success.num += _srcobj->tx.tx_success.num; \
|
|
_tgtobj->tx.tx_success.bytes += _srcobj->tx.tx_success.bytes; \
|
|
_tgtobj->tx.nawds_mcast_drop += _srcobj->tx.nawds_mcast_drop; \
|
|
_tgtobj->tx.ofdma += _srcobj->tx.ofdma; \
|
|
_tgtobj->tx.non_amsdu_cnt += _srcobj->tx.non_amsdu_cnt; \
|
|
_tgtobj->tx.amsdu_cnt += _srcobj->tx.amsdu_cnt; \
|
|
_tgtobj->tx.dropped.fw_rem.num += \
|
|
_srcobj->tx.dropped.fw_rem.num; \
|
|
_tgtobj->tx.dropped.fw_rem.bytes += \
|
|
_srcobj->tx.dropped.fw_rem.bytes; \
|
|
_tgtobj->tx.dropped.fw_rem_notx += \
|
|
_srcobj->tx.dropped.fw_rem_notx; \
|
|
_tgtobj->tx.dropped.fw_rem_tx += \
|
|
_srcobj->tx.dropped.fw_rem_tx; \
|
|
_tgtobj->tx.dropped.age_out += _srcobj->tx.dropped.age_out; \
|
|
_tgtobj->tx.dropped.fw_reason1 += \
|
|
_srcobj->tx.dropped.fw_reason1; \
|
|
_tgtobj->tx.dropped.fw_reason2 += \
|
|
_srcobj->tx.dropped.fw_reason2; \
|
|
_tgtobj->tx.dropped.fw_reason3 += \
|
|
_srcobj->tx.dropped.fw_reason3; \
|
|
_tgtobj->tx.dropped.fw_rem_queue_disable += \
|
|
_srcobj->tx.dropped.fw_rem_queue_disable; \
|
|
_tgtobj->tx.dropped.fw_rem_no_match += \
|
|
_srcobj->tx.dropped.fw_rem_no_match; \
|
|
_tgtobj->tx.dropped.drop_threshold += \
|
|
_srcobj->tx.dropped.drop_threshold; \
|
|
_tgtobj->tx.dropped.drop_link_desc_na += \
|
|
_srcobj->tx.dropped.drop_link_desc_na; \
|
|
_tgtobj->tx.dropped.invalid_drop += \
|
|
_srcobj->tx.dropped.invalid_drop; \
|
|
_tgtobj->tx.dropped.mcast_vdev_drop += \
|
|
_srcobj->tx.dropped.mcast_vdev_drop; \
|
|
_tgtobj->tx.dropped.invalid_rr += \
|
|
_srcobj->tx.dropped.invalid_rr; \
|
|
_tgtobj->tx.failed_retry_count += \
|
|
_srcobj->tx.failed_retry_count; \
|
|
_tgtobj->tx.retry_count += _srcobj->tx.retry_count; \
|
|
_tgtobj->tx.multiple_retry_count += \
|
|
_srcobj->tx.multiple_retry_count; \
|
|
_tgtobj->tx.tx_success_twt.num += \
|
|
_srcobj->tx.tx_success_twt.num; \
|
|
_tgtobj->tx.tx_success_twt.bytes += \
|
|
_srcobj->tx.tx_success_twt.bytes; \
|
|
_tgtobj->tx.last_tx_ts = _srcobj->tx.last_tx_ts; \
|
|
_tgtobj->tx.release_src_not_tqm += \
|
|
_srcobj->tx.release_src_not_tqm; \
|
|
for (i = 0; i < QDF_PROTO_SUBTYPE_MAX; i++) { \
|
|
_tgtobj->tx.no_ack_count[i] += \
|
|
_srcobj->tx.no_ack_count[i];\
|
|
} \
|
|
\
|
|
_tgtobj->rx.multicast.num += _srcobj->rx.multicast.num; \
|
|
_tgtobj->rx.multicast.bytes += _srcobj->rx.multicast.bytes; \
|
|
_tgtobj->rx.rx_success.num += _srcobj->rx.rx_success.num;\
|
|
_tgtobj->rx.rx_success.bytes += _srcobj->rx.rx_success.bytes;\
|
|
_tgtobj->rx.bcast.num += _srcobj->rx.bcast.num; \
|
|
_tgtobj->rx.bcast.bytes += _srcobj->rx.bcast.bytes; \
|
|
_tgtobj->rx.unicast.num += _srcobj->rx.unicast.num; \
|
|
_tgtobj->rx.unicast.bytes += _srcobj->rx.unicast.bytes; \
|
|
_tgtobj->rx.raw.num += _srcobj->rx.raw.num; \
|
|
_tgtobj->rx.raw.bytes += _srcobj->rx.raw.bytes; \
|
|
_tgtobj->rx.nawds_mcast_drop += _srcobj->rx.nawds_mcast_drop; \
|
|
_tgtobj->rx.mcast_3addr_drop += _srcobj->rx.mcast_3addr_drop; \
|
|
_tgtobj->rx.mec_drop.num += _srcobj->rx.mec_drop.num; \
|
|
_tgtobj->rx.mec_drop.bytes += _srcobj->rx.mec_drop.bytes; \
|
|
_tgtobj->rx.ppeds_drop.num += _srcobj->rx.ppeds_drop.num; \
|
|
_tgtobj->rx.ppeds_drop.bytes += _srcobj->rx.ppeds_drop.bytes; \
|
|
_tgtobj->rx.intra_bss.pkts.num += \
|
|
_srcobj->rx.intra_bss.pkts.num; \
|
|
_tgtobj->rx.intra_bss.pkts.bytes += \
|
|
_srcobj->rx.intra_bss.pkts.bytes; \
|
|
_tgtobj->rx.intra_bss.fail.num += \
|
|
_srcobj->rx.intra_bss.fail.num; \
|
|
_tgtobj->rx.intra_bss.fail.bytes += \
|
|
_srcobj->rx.intra_bss.fail.bytes; \
|
|
_tgtobj->rx.intra_bss.mdns_no_fwd += \
|
|
_srcobj->rx.intra_bss.mdns_no_fwd; \
|
|
_tgtobj->rx.err.mic_err += _srcobj->rx.err.mic_err; \
|
|
_tgtobj->rx.err.decrypt_err += _srcobj->rx.err.decrypt_err; \
|
|
_tgtobj->rx.err.fcserr += _srcobj->rx.err.fcserr; \
|
|
_tgtobj->rx.err.pn_err += _srcobj->rx.err.pn_err; \
|
|
_tgtobj->rx.err.oor_err += _srcobj->rx.err.oor_err; \
|
|
_tgtobj->rx.err.jump_2k_err += _srcobj->rx.err.jump_2k_err; \
|
|
_tgtobj->rx.err.rxdma_wifi_parse_err += \
|
|
_srcobj->rx.err.rxdma_wifi_parse_err; \
|
|
_tgtobj->rx.non_amsdu_cnt += _srcobj->rx.non_amsdu_cnt; \
|
|
_tgtobj->rx.amsdu_cnt += _srcobj->rx.amsdu_cnt; \
|
|
_tgtobj->rx.rx_retries += _srcobj->rx.rx_retries; \
|
|
_tgtobj->rx.multipass_rx_pkt_drop += \
|
|
_srcobj->rx.multipass_rx_pkt_drop; \
|
|
_tgtobj->rx.peer_unauth_rx_pkt_drop += \
|
|
_srcobj->rx.peer_unauth_rx_pkt_drop; \
|
|
_tgtobj->rx.policy_check_drop += \
|
|
_srcobj->rx.policy_check_drop; \
|
|
_tgtobj->rx.to_stack_twt.num += _srcobj->rx.to_stack_twt.num; \
|
|
_tgtobj->rx.to_stack_twt.bytes += \
|
|
_srcobj->rx.to_stack_twt.bytes; \
|
|
_tgtobj->rx.last_rx_ts = _srcobj->rx.last_rx_ts; \
|
|
for (i = 0; i < CDP_MAX_RX_RINGS; i++) { \
|
|
_tgtobj->rx.rcvd_reo[i].num += \
|
|
_srcobj->rx.rcvd_reo[i].num; \
|
|
_tgtobj->rx.rcvd_reo[i].bytes += \
|
|
_srcobj->rx.rcvd_reo[i].bytes; \
|
|
_tgtobj->rx.rcvd.num += \
|
|
_srcobj->rx.rcvd_reo[i].num; \
|
|
_tgtobj->rx.rcvd.bytes += \
|
|
_srcobj->rx.rcvd_reo[i].bytes; \
|
|
} \
|
|
for (i = 0; i < CDP_MAX_LMACS; i++) { \
|
|
_tgtobj->rx.rx_lmac[i].num += \
|
|
_srcobj->rx.rx_lmac[i].num; \
|
|
_tgtobj->rx.rx_lmac[i].bytes += \
|
|
_srcobj->rx.rx_lmac[i].bytes; \
|
|
} \
|
|
DP_IPA_UPDATE_PER_PKT_RX_STATS(_tgtobj, _srcobj); \
|
|
DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
uint8_t i, pream_type, mu_type; \
|
|
_tgtobj->tx.stbc += _srcobj->tx.stbc; \
|
|
_tgtobj->tx.ldpc += _srcobj->tx.ldpc; \
|
|
_tgtobj->tx.retries += _srcobj->tx.retries; \
|
|
_tgtobj->tx.ampdu_cnt += _srcobj->tx.ampdu_cnt; \
|
|
_tgtobj->tx.non_ampdu_cnt += _srcobj->tx.non_ampdu_cnt; \
|
|
_tgtobj->tx.num_ppdu_cookie_valid += \
|
|
_srcobj->tx.num_ppdu_cookie_valid; \
|
|
_tgtobj->tx.tx_ppdus += _srcobj->tx.tx_ppdus; \
|
|
_tgtobj->tx.tx_mpdus_success += _srcobj->tx.tx_mpdus_success; \
|
|
_tgtobj->tx.tx_mpdus_tried += _srcobj->tx.tx_mpdus_tried; \
|
|
_tgtobj->tx.tx_rate = _srcobj->tx.tx_rate; \
|
|
_tgtobj->tx.last_tx_rate = _srcobj->tx.last_tx_rate; \
|
|
_tgtobj->tx.last_tx_rate_mcs = _srcobj->tx.last_tx_rate_mcs; \
|
|
_tgtobj->tx.mcast_last_tx_rate = \
|
|
_srcobj->tx.mcast_last_tx_rate; \
|
|
_tgtobj->tx.mcast_last_tx_rate_mcs = \
|
|
_srcobj->tx.mcast_last_tx_rate_mcs; \
|
|
_tgtobj->tx.rnd_avg_tx_rate = _srcobj->tx.rnd_avg_tx_rate; \
|
|
_tgtobj->tx.avg_tx_rate = _srcobj->tx.avg_tx_rate; \
|
|
_tgtobj->tx.tx_ratecode = _srcobj->tx.tx_ratecode; \
|
|
_tgtobj->tx.pream_punct_cnt += _srcobj->tx.pream_punct_cnt; \
|
|
_tgtobj->tx.ru_start = _srcobj->tx.ru_start; \
|
|
_tgtobj->tx.ru_tones = _srcobj->tx.ru_tones; \
|
|
_tgtobj->tx.last_ack_rssi = _srcobj->tx.last_ack_rssi; \
|
|
_tgtobj->tx.nss_info = _srcobj->tx.nss_info; \
|
|
_tgtobj->tx.mcs_info = _srcobj->tx.mcs_info; \
|
|
_tgtobj->tx.bw_info = _srcobj->tx.bw_info; \
|
|
_tgtobj->tx.gi_info = _srcobj->tx.gi_info; \
|
|
_tgtobj->tx.preamble_info = _srcobj->tx.preamble_info; \
|
|
_tgtobj->tx.retries_mpdu += _srcobj->tx.retries_mpdu; \
|
|
_tgtobj->tx.mpdu_success_with_retries += \
|
|
_srcobj->tx.mpdu_success_with_retries; \
|
|
_tgtobj->tx.rts_success = _srcobj->tx.rts_success; \
|
|
_tgtobj->tx.rts_failure = _srcobj->tx.rts_failure; \
|
|
_tgtobj->tx.bar_cnt = _srcobj->tx.bar_cnt; \
|
|
_tgtobj->tx.ndpa_cnt = _srcobj->tx.ndpa_cnt; \
|
|
for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \
|
|
for (i = 0; i < MAX_MCS; i++) \
|
|
_tgtobj->tx.pkt_type[pream_type].mcs_count[i] += \
|
|
_srcobj->tx.pkt_type[pream_type].mcs_count[i]; \
|
|
} \
|
|
for (i = 0; i < WME_AC_MAX; i++) { \
|
|
_tgtobj->tx.wme_ac_type[i] += _srcobj->tx.wme_ac_type[i]; \
|
|
_tgtobj->tx.wme_ac_type_bytes[i] += \
|
|
_srcobj->tx.wme_ac_type_bytes[i]; \
|
|
_tgtobj->tx.excess_retries_per_ac[i] += \
|
|
_srcobj->tx.excess_retries_per_ac[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_GI; i++) { \
|
|
_tgtobj->tx.sgi_count[i] += _srcobj->tx.sgi_count[i]; \
|
|
} \
|
|
for (i = 0; i < SS_COUNT; i++) { \
|
|
_tgtobj->tx.nss[i] += _srcobj->tx.nss[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_BW; i++) { \
|
|
_tgtobj->tx.bw[i] += _srcobj->tx.bw[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_RU_LOCATIONS; i++) { \
|
|
_tgtobj->tx.ru_loc[i].num_msdu += \
|
|
_srcobj->tx.ru_loc[i].num_msdu; \
|
|
_tgtobj->tx.ru_loc[i].num_mpdu += \
|
|
_srcobj->tx.ru_loc[i].num_mpdu; \
|
|
_tgtobj->tx.ru_loc[i].mpdu_tried += \
|
|
_srcobj->tx.ru_loc[i].mpdu_tried; \
|
|
} \
|
|
for (i = 0; i < MAX_TRANSMIT_TYPES; i++) { \
|
|
_tgtobj->tx.transmit_type[i].num_msdu += \
|
|
_srcobj->tx.transmit_type[i].num_msdu; \
|
|
_tgtobj->tx.transmit_type[i].num_mpdu += \
|
|
_srcobj->tx.transmit_type[i].num_mpdu; \
|
|
_tgtobj->tx.transmit_type[i].mpdu_tried += \
|
|
_srcobj->tx.transmit_type[i].mpdu_tried; \
|
|
} \
|
|
for (i = 0; i < MAX_MU_GROUP_ID; i++) { \
|
|
_tgtobj->tx.mu_group_id[i] = _srcobj->tx.mu_group_id[i]; \
|
|
} \
|
|
_tgtobj->tx.tx_ucast_total.num += \
|
|
_srcobj->tx.tx_ucast_total.num;\
|
|
_tgtobj->tx.tx_ucast_total.bytes += \
|
|
_srcobj->tx.tx_ucast_total.bytes;\
|
|
_tgtobj->tx.tx_ucast_success.num += \
|
|
_srcobj->tx.tx_ucast_success.num; \
|
|
_tgtobj->tx.tx_ucast_success.bytes += \
|
|
_srcobj->tx.tx_ucast_success.bytes; \
|
|
\
|
|
for (i = 0; i < CDP_RSSI_CHAIN_LEN; i++) \
|
|
_tgtobj->tx.rssi_chain[i] = _srcobj->tx.rssi_chain[i]; \
|
|
_tgtobj->rx.mpdu_cnt_fcs_ok += _srcobj->rx.mpdu_cnt_fcs_ok; \
|
|
_tgtobj->rx.mpdu_cnt_fcs_err += _srcobj->rx.mpdu_cnt_fcs_err; \
|
|
_tgtobj->rx.non_ampdu_cnt += _srcobj->rx.non_ampdu_cnt; \
|
|
_tgtobj->rx.ampdu_cnt += _srcobj->rx.ampdu_cnt; \
|
|
_tgtobj->rx.rx_mpdus += _srcobj->rx.rx_mpdus; \
|
|
_tgtobj->rx.rx_ppdus += _srcobj->rx.rx_ppdus; \
|
|
_tgtobj->rx.rx_rate = _srcobj->rx.rx_rate; \
|
|
_tgtobj->rx.last_rx_rate = _srcobj->rx.last_rx_rate; \
|
|
_tgtobj->rx.rnd_avg_rx_rate = _srcobj->rx.rnd_avg_rx_rate; \
|
|
_tgtobj->rx.avg_rx_rate = _srcobj->rx.avg_rx_rate; \
|
|
_tgtobj->rx.rx_ratecode = _srcobj->rx.rx_ratecode; \
|
|
_tgtobj->rx.avg_snr = _srcobj->rx.avg_snr; \
|
|
_tgtobj->rx.rx_snr_measured_time = \
|
|
_srcobj->rx.rx_snr_measured_time; \
|
|
_tgtobj->rx.snr = _srcobj->rx.snr; \
|
|
_tgtobj->rx.last_snr = _srcobj->rx.last_snr; \
|
|
_tgtobj->rx.nss_info = _srcobj->rx.nss_info; \
|
|
_tgtobj->rx.mcs_info = _srcobj->rx.mcs_info; \
|
|
_tgtobj->rx.bw_info = _srcobj->rx.bw_info; \
|
|
_tgtobj->rx.gi_info = _srcobj->rx.gi_info; \
|
|
_tgtobj->rx.preamble_info = _srcobj->rx.preamble_info; \
|
|
_tgtobj->rx.mpdu_retry_cnt += _srcobj->rx.mpdu_retry_cnt; \
|
|
_tgtobj->rx.bar_cnt = _srcobj->rx.bar_cnt; \
|
|
_tgtobj->rx.ndpa_cnt = _srcobj->rx.ndpa_cnt; \
|
|
for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \
|
|
for (i = 0; i < MAX_MCS; i++) { \
|
|
_tgtobj->rx.pkt_type[pream_type].mcs_count[i] += \
|
|
_srcobj->rx.pkt_type[pream_type].mcs_count[i]; \
|
|
} \
|
|
} \
|
|
for (i = 0; i < WME_AC_MAX; i++) { \
|
|
_tgtobj->rx.wme_ac_type[i] += _srcobj->rx.wme_ac_type[i]; \
|
|
_tgtobj->rx.wme_ac_type_bytes[i] += \
|
|
_srcobj->rx.wme_ac_type_bytes[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_MCS; i++) { \
|
|
_tgtobj->rx.su_ax_ppdu_cnt.mcs_count[i] += \
|
|
_srcobj->rx.su_ax_ppdu_cnt.mcs_count[i]; \
|
|
_tgtobj->rx.rx_mpdu_cnt[i] += _srcobj->rx.rx_mpdu_cnt[i]; \
|
|
} \
|
|
for (mu_type = 0 ; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \
|
|
_tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok += \
|
|
_srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok; \
|
|
_tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err += \
|
|
_srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err; \
|
|
for (i = 0; i < SS_COUNT; i++) \
|
|
_tgtobj->rx.rx_mu[mu_type].ppdu_nss[i] += \
|
|
_srcobj->rx.rx_mu[mu_type].ppdu_nss[i]; \
|
|
for (i = 0; i < MAX_MCS; i++) \
|
|
_tgtobj->rx.rx_mu[mu_type].ppdu.mcs_count[i] += \
|
|
_srcobj->rx.rx_mu[mu_type].ppdu.mcs_count[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_RECEPTION_TYPES; i++) { \
|
|
_tgtobj->rx.reception_type[i] += \
|
|
_srcobj->rx.reception_type[i]; \
|
|
_tgtobj->rx.ppdu_cnt[i] += _srcobj->rx.ppdu_cnt[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_GI; i++) { \
|
|
_tgtobj->rx.sgi_count[i] += _srcobj->rx.sgi_count[i]; \
|
|
} \
|
|
for (i = 0; i < SS_COUNT; i++) { \
|
|
_tgtobj->rx.nss[i] += _srcobj->rx.nss[i]; \
|
|
_tgtobj->rx.ppdu_nss[i] += _srcobj->rx.ppdu_nss[i]; \
|
|
} \
|
|
for (i = 0; i < MAX_BW; i++) { \
|
|
_tgtobj->rx.bw[i] += _srcobj->rx.bw[i]; \
|
|
} \
|
|
DP_UPDATE_11BE_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj) \
|
|
do { \
|
|
DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj); \
|
|
DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj); \
|
|
DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj) \
|
|
do { \
|
|
_tgtobj->rx_i.reo_rcvd_pkt.num += \
|
|
_srcobj->rx_i.reo_rcvd_pkt.num; \
|
|
_tgtobj->rx_i.reo_rcvd_pkt.bytes += \
|
|
_srcobj->rx_i.reo_rcvd_pkt.bytes; \
|
|
_tgtobj->rx_i.null_q_desc_pkt.num += \
|
|
_srcobj->rx_i.null_q_desc_pkt.num; \
|
|
_tgtobj->rx_i.null_q_desc_pkt.bytes += \
|
|
_srcobj->rx_i.null_q_desc_pkt.bytes; \
|
|
_tgtobj->rx_i.routed_eapol_pkt.num += \
|
|
_srcobj->rx_i.routed_eapol_pkt.num; \
|
|
_tgtobj->rx_i.routed_eapol_pkt.bytes += \
|
|
_srcobj->rx_i.routed_eapol_pkt.bytes; \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \
|
|
do { \
|
|
uint8_t i = 0; \
|
|
uint8_t idx = 0; \
|
|
enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \
|
|
if (temp_xmit_type == DP_XMIT_MLD) { \
|
|
idx = DP_VDEV_XMIT_TYPE; \
|
|
temp_xmit_type = DP_VDEV_XMIT_TYPE; \
|
|
} else if (temp_xmit_type == DP_XMIT_TOTAL) { \
|
|
temp_xmit_type = DP_VDEV_XMIT_TYPE; \
|
|
} \
|
|
for (; idx <= temp_xmit_type; idx++) { \
|
|
_tgtobj->tx_i.rcvd.num += _srcobj->tx_i[idx].rcvd.num; \
|
|
_tgtobj->tx_i.rcvd.bytes += \
|
|
_srcobj->tx_i[idx].rcvd.bytes; \
|
|
_tgtobj->tx_i.rcvd_in_fast_xmit_flow += \
|
|
_srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \
|
|
for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \
|
|
_tgtobj->tx_i.rcvd_per_core[i] += \
|
|
_srcobj->tx_i[idx].rcvd_per_core[i]; \
|
|
} \
|
|
_tgtobj->tx_i.processed.num += \
|
|
_srcobj->tx_i[idx].processed.num; \
|
|
_tgtobj->tx_i.processed.bytes += \
|
|
_srcobj->tx_i[idx].processed.bytes; \
|
|
_tgtobj->tx_i.reinject_pkts.num += \
|
|
_srcobj->tx_i[idx].reinject_pkts.num; \
|
|
_tgtobj->tx_i.reinject_pkts.bytes += \
|
|
_srcobj->tx_i[idx].reinject_pkts.bytes; \
|
|
_tgtobj->tx_i.inspect_pkts.num += \
|
|
_srcobj->tx_i[idx].inspect_pkts.num; \
|
|
_tgtobj->tx_i.inspect_pkts.bytes += \
|
|
_srcobj->tx_i[idx].inspect_pkts.bytes; \
|
|
_tgtobj->tx_i.nawds_mcast.num += \
|
|
_srcobj->tx_i[idx].nawds_mcast.num; \
|
|
_tgtobj->tx_i.nawds_mcast.bytes += \
|
|
_srcobj->tx_i[idx].nawds_mcast.bytes; \
|
|
_tgtobj->tx_i.bcast.num += \
|
|
_srcobj->tx_i[idx].bcast.num; \
|
|
_tgtobj->tx_i.bcast.bytes += \
|
|
_srcobj->tx_i[idx].bcast.bytes; \
|
|
_tgtobj->tx_i.raw.raw_pkt.num += \
|
|
_srcobj->tx_i[idx].raw.raw_pkt.num; \
|
|
_tgtobj->tx_i.raw.raw_pkt.bytes += \
|
|
_srcobj->tx_i[idx].raw.raw_pkt.bytes; \
|
|
_tgtobj->tx_i.raw.dma_map_error += \
|
|
_srcobj->tx_i[idx].raw.dma_map_error; \
|
|
_tgtobj->tx_i.raw.invalid_raw_pkt_datatype += \
|
|
_srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \
|
|
_tgtobj->tx_i.raw.num_frags_overflow_err += \
|
|
_srcobj->tx_i[idx].raw.num_frags_overflow_err; \
|
|
_tgtobj->tx_i.sg.sg_pkt.num += \
|
|
_srcobj->tx_i[idx].sg.sg_pkt.num; \
|
|
_tgtobj->tx_i.sg.sg_pkt.bytes += \
|
|
_srcobj->tx_i[idx].sg.sg_pkt.bytes; \
|
|
_tgtobj->tx_i.sg.non_sg_pkts.num += \
|
|
_srcobj->tx_i[idx].sg.non_sg_pkts.num; \
|
|
_tgtobj->tx_i.sg.non_sg_pkts.bytes += \
|
|
_srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \
|
|
_tgtobj->tx_i.sg.dropped_host.num += \
|
|
_srcobj->tx_i[idx].sg.dropped_host.num; \
|
|
_tgtobj->tx_i.sg.dropped_host.bytes += \
|
|
_srcobj->tx_i[idx].sg.dropped_host.bytes; \
|
|
_tgtobj->tx_i.sg.dropped_target += \
|
|
_srcobj->tx_i[idx].sg.dropped_target; \
|
|
_tgtobj->tx_i.sg.dma_map_error += \
|
|
_srcobj->tx_i[idx].sg.dma_map_error; \
|
|
_tgtobj->tx_i.mcast_en.mcast_pkt.num += \
|
|
_srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \
|
|
_tgtobj->tx_i.mcast_en.mcast_pkt.bytes += \
|
|
_srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \
|
|
_tgtobj->tx_i.mcast_en.dropped_map_error += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_map_error; \
|
|
_tgtobj->tx_i.mcast_en.dropped_self_mac += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_self_mac; \
|
|
_tgtobj->tx_i.mcast_en.dropped_send_fail += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_send_fail; \
|
|
_tgtobj->tx_i.mcast_en.ucast += \
|
|
_srcobj->tx_i[idx].mcast_en.ucast; \
|
|
_tgtobj->tx_i.mcast_en.fail_seg_alloc += \
|
|
_srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \
|
|
_tgtobj->tx_i.mcast_en.clone_fail += \
|
|
_srcobj->tx_i[idx].mcast_en.clone_fail; \
|
|
_tgtobj->tx_i.igmp_mcast_en.igmp_rcvd += \
|
|
_srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \
|
|
_tgtobj->tx_i.igmp_mcast_en.igmp_ucast_converted += \
|
|
_srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \
|
|
_tgtobj->tx_i.dropped.desc_na.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na.num; \
|
|
_tgtobj->tx_i.dropped.desc_na.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na.bytes; \
|
|
_tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \
|
|
_tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \
|
|
_tgtobj->tx_i.dropped.desc_na_exc_outstand.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \
|
|
_tgtobj->tx_i.dropped.desc_na_exc_outstand.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \
|
|
_tgtobj->tx_i.dropped.exc_desc_na.num += \
|
|
_srcobj->tx_i[idx].dropped.exc_desc_na.num; \
|
|
_tgtobj->tx_i.dropped.exc_desc_na.bytes += \
|
|
_srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \
|
|
_tgtobj->tx_i.dropped.ring_full += \
|
|
_srcobj->tx_i[idx].dropped.ring_full; \
|
|
_tgtobj->tx_i.dropped.enqueue_fail += \
|
|
_srcobj->tx_i[idx].dropped.enqueue_fail; \
|
|
_tgtobj->tx_i.dropped.dma_error += \
|
|
_srcobj->tx_i[idx].dropped.dma_error; \
|
|
_tgtobj->tx_i.dropped.res_full += \
|
|
_srcobj->tx_i[idx].dropped.res_full; \
|
|
_tgtobj->tx_i.dropped.headroom_insufficient += \
|
|
_srcobj->tx_i[idx].dropped.headroom_insufficient; \
|
|
_tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check += \
|
|
_srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \
|
|
_tgtobj->tx_i.dropped.drop_ingress += \
|
|
_srcobj->tx_i[idx].dropped.drop_ingress; \
|
|
_tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path += \
|
|
_srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \
|
|
_tgtobj->tx_i.dropped.tx_mcast_drop += \
|
|
_srcobj->tx_i[idx].dropped.tx_mcast_drop; \
|
|
_tgtobj->tx_i.dropped.fw2wbm_tx_drop += \
|
|
_srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \
|
|
_tgtobj->tx_i.dropped.dropped_pkt.bytes += \
|
|
_srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \
|
|
_tgtobj->tx_i.mesh.exception_fw += \
|
|
_srcobj->tx_i[idx].mesh.exception_fw; \
|
|
_tgtobj->tx_i.mesh.completion_fw += \
|
|
_srcobj->tx_i[idx].mesh.completion_fw; \
|
|
_tgtobj->tx_i.cce_classified += \
|
|
_srcobj->tx_i[idx].cce_classified; \
|
|
_tgtobj->tx_i.cce_classified_raw += \
|
|
_srcobj->tx_i[idx].cce_classified_raw; \
|
|
_tgtobj->tx_i.sniffer_rcvd.num += \
|
|
_srcobj->tx_i[idx].sniffer_rcvd.num; \
|
|
_tgtobj->tx_i.sniffer_rcvd.bytes += \
|
|
_srcobj->tx_i[idx].sniffer_rcvd.bytes; \
|
|
} \
|
|
_tgtobj->tx_i.dropped.dropped_pkt.num = \
|
|
_tgtobj->tx_i.dropped.dma_error + \
|
|
_tgtobj->tx_i.dropped.ring_full + \
|
|
_tgtobj->tx_i.dropped.enqueue_fail + \
|
|
_tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check + \
|
|
_tgtobj->tx_i.dropped.desc_na.num + \
|
|
_tgtobj->tx_i.dropped.res_full + \
|
|
_tgtobj->tx_i.dropped.drop_ingress + \
|
|
_tgtobj->tx_i.dropped.headroom_insufficient + \
|
|
_tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path + \
|
|
_tgtobj->tx_i.dropped.tx_mcast_drop + \
|
|
_tgtobj->tx_i.dropped.fw2wbm_tx_drop; \
|
|
DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \
|
|
do { \
|
|
uint8_t i = 0; \
|
|
uint8_t idx = 0; \
|
|
enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \
|
|
if (temp_xmit_type == DP_XMIT_MLD) { \
|
|
idx = DP_VDEV_XMIT_TYPE; \
|
|
temp_xmit_type = DP_VDEV_XMIT_TYPE; \
|
|
} else if (temp_xmit_type == DP_XMIT_TOTAL) { \
|
|
temp_xmit_type = DP_VDEV_XMIT_TYPE; \
|
|
} \
|
|
for (; idx <= temp_xmit_type; idx++) { \
|
|
_tgtobj->tx_i[idx].rcvd.num += _srcobj->tx_i[idx].rcvd.num; \
|
|
_tgtobj->tx_i[idx].rcvd.bytes += \
|
|
_srcobj->tx_i[idx].rcvd.bytes; \
|
|
_tgtobj->tx_i[idx].rcvd_in_fast_xmit_flow += \
|
|
_srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \
|
|
for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \
|
|
_tgtobj->tx_i[idx].rcvd_per_core[i] += \
|
|
_srcobj->tx_i[idx].rcvd_per_core[i]; \
|
|
} \
|
|
_tgtobj->tx_i[idx].processed.num += \
|
|
_srcobj->tx_i[idx].processed.num; \
|
|
_tgtobj->tx_i[idx].processed.bytes += \
|
|
_srcobj->tx_i[idx].processed.bytes; \
|
|
_tgtobj->tx_i[idx].reinject_pkts.num += \
|
|
_srcobj->tx_i[idx].reinject_pkts.num; \
|
|
_tgtobj->tx_i[idx].reinject_pkts.bytes += \
|
|
_srcobj->tx_i[idx].reinject_pkts.bytes; \
|
|
_tgtobj->tx_i[idx].inspect_pkts.num += \
|
|
_srcobj->tx_i[idx].inspect_pkts.num; \
|
|
_tgtobj->tx_i[idx].inspect_pkts.bytes += \
|
|
_srcobj->tx_i[idx].inspect_pkts.bytes; \
|
|
_tgtobj->tx_i[idx].nawds_mcast.num += \
|
|
_srcobj->tx_i[idx].nawds_mcast.num; \
|
|
_tgtobj->tx_i[idx].nawds_mcast.bytes += \
|
|
_srcobj->tx_i[idx].nawds_mcast.bytes; \
|
|
_tgtobj->tx_i[idx].bcast.num += \
|
|
_srcobj->tx_i[idx].bcast.num; \
|
|
_tgtobj->tx_i[idx].bcast.bytes += \
|
|
_srcobj->tx_i[idx].bcast.bytes; \
|
|
_tgtobj->tx_i[idx].raw.raw_pkt.num += \
|
|
_srcobj->tx_i[idx].raw.raw_pkt.num; \
|
|
_tgtobj->tx_i[idx].raw.raw_pkt.bytes += \
|
|
_srcobj->tx_i[idx].raw.raw_pkt.bytes; \
|
|
_tgtobj->tx_i[idx].raw.dma_map_error += \
|
|
_srcobj->tx_i[idx].raw.dma_map_error; \
|
|
_tgtobj->tx_i[idx].raw.invalid_raw_pkt_datatype += \
|
|
_srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \
|
|
_tgtobj->tx_i[idx].raw.num_frags_overflow_err += \
|
|
_srcobj->tx_i[idx].raw.num_frags_overflow_err; \
|
|
_tgtobj->tx_i[idx].sg.sg_pkt.num += \
|
|
_srcobj->tx_i[idx].sg.sg_pkt.num; \
|
|
_tgtobj->tx_i[idx].sg.sg_pkt.bytes += \
|
|
_srcobj->tx_i[idx].sg.sg_pkt.bytes; \
|
|
_tgtobj->tx_i[idx].sg.non_sg_pkts.num += \
|
|
_srcobj->tx_i[idx].sg.non_sg_pkts.num; \
|
|
_tgtobj->tx_i[idx].sg.non_sg_pkts.bytes += \
|
|
_srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \
|
|
_tgtobj->tx_i[idx].sg.dropped_host.num += \
|
|
_srcobj->tx_i[idx].sg.dropped_host.num; \
|
|
_tgtobj->tx_i[idx].sg.dropped_host.bytes += \
|
|
_srcobj->tx_i[idx].sg.dropped_host.bytes; \
|
|
_tgtobj->tx_i[idx].sg.dropped_target += \
|
|
_srcobj->tx_i[idx].sg.dropped_target; \
|
|
_tgtobj->tx_i[idx].sg.dma_map_error += \
|
|
_srcobj->tx_i[idx].sg.dma_map_error; \
|
|
_tgtobj->tx_i[idx].mcast_en.mcast_pkt.num += \
|
|
_srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \
|
|
_tgtobj->tx_i[idx].mcast_en.mcast_pkt.bytes += \
|
|
_srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \
|
|
_tgtobj->tx_i[idx].mcast_en.dropped_map_error += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_map_error; \
|
|
_tgtobj->tx_i[idx].mcast_en.dropped_self_mac += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_self_mac; \
|
|
_tgtobj->tx_i[idx].mcast_en.dropped_send_fail += \
|
|
_srcobj->tx_i[idx].mcast_en.dropped_send_fail; \
|
|
_tgtobj->tx_i[idx].mcast_en.ucast += \
|
|
_srcobj->tx_i[idx].mcast_en.ucast; \
|
|
_tgtobj->tx_i[idx].mcast_en.fail_seg_alloc += \
|
|
_srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \
|
|
_tgtobj->tx_i[idx].mcast_en.clone_fail += \
|
|
_srcobj->tx_i[idx].mcast_en.clone_fail; \
|
|
_tgtobj->tx_i[idx].igmp_mcast_en.igmp_rcvd += \
|
|
_srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \
|
|
_tgtobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted += \
|
|
_srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na.num; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na.bytes; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.num += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \
|
|
_tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes += \
|
|
_srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \
|
|
_tgtobj->tx_i[idx].dropped.exc_desc_na.num += \
|
|
_srcobj->tx_i[idx].dropped.exc_desc_na.num; \
|
|
_tgtobj->tx_i[idx].dropped.exc_desc_na.bytes += \
|
|
_srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \
|
|
_tgtobj->tx_i[idx].dropped.ring_full += \
|
|
_srcobj->tx_i[idx].dropped.ring_full; \
|
|
_tgtobj->tx_i[idx].dropped.enqueue_fail += \
|
|
_srcobj->tx_i[idx].dropped.enqueue_fail; \
|
|
_tgtobj->tx_i[idx].dropped.dma_error += \
|
|
_srcobj->tx_i[idx].dropped.dma_error; \
|
|
_tgtobj->tx_i[idx].dropped.res_full += \
|
|
_srcobj->tx_i[idx].dropped.res_full; \
|
|
_tgtobj->tx_i[idx].dropped.headroom_insufficient += \
|
|
_srcobj->tx_i[idx].dropped.headroom_insufficient; \
|
|
_tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check += \
|
|
_srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \
|
|
_tgtobj->tx_i[idx].dropped.drop_ingress += \
|
|
_srcobj->tx_i[idx].dropped.drop_ingress; \
|
|
_tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path += \
|
|
_srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \
|
|
_tgtobj->tx_i[idx].dropped.tx_mcast_drop += \
|
|
_srcobj->tx_i[idx].dropped.tx_mcast_drop; \
|
|
_tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop += \
|
|
_srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \
|
|
_tgtobj->tx_i[idx].dropped.dropped_pkt.bytes += \
|
|
_srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \
|
|
_tgtobj->tx_i[idx].mesh.exception_fw += \
|
|
_srcobj->tx_i[idx].mesh.exception_fw; \
|
|
_tgtobj->tx_i[idx].mesh.completion_fw += \
|
|
_srcobj->tx_i[idx].mesh.completion_fw; \
|
|
_tgtobj->tx_i[idx].cce_classified += \
|
|
_srcobj->tx_i[idx].cce_classified; \
|
|
_tgtobj->tx_i[idx].cce_classified_raw += \
|
|
_srcobj->tx_i[idx].cce_classified_raw; \
|
|
_tgtobj->tx_i[idx].sniffer_rcvd.num += \
|
|
_srcobj->tx_i[idx].sniffer_rcvd.num; \
|
|
_tgtobj->tx_i[idx].sniffer_rcvd.bytes += \
|
|
_srcobj->tx_i[idx].sniffer_rcvd.bytes; \
|
|
_tgtobj->tx_i[idx].dropped.dropped_pkt.num = \
|
|
_tgtobj->tx_i[idx].dropped.dma_error + \
|
|
_tgtobj->tx_i[idx].dropped.ring_full + \
|
|
_tgtobj->tx_i[idx].dropped.enqueue_fail + \
|
|
_tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check + \
|
|
_tgtobj->tx_i[idx].dropped.desc_na.num + \
|
|
_tgtobj->tx_i[idx].dropped.res_full + \
|
|
_tgtobj->tx_i[idx].dropped.drop_ingress + \
|
|
_tgtobj->tx_i[idx].dropped.headroom_insufficient + \
|
|
_tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path + \
|
|
_tgtobj->tx_i[idx].dropped.tx_mcast_drop + \
|
|
_tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop; \
|
|
} \
|
|
DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_TO_MLD_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \
|
|
do { \
|
|
DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \
|
|
DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
|
|
#define DP_UPDATE_TO_LINK_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \
|
|
do { \
|
|
DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \
|
|
DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \
|
|
} while (0)
|
|
/**
|
|
* dp_peer_find_attach() - Allocates memory for peer objects
|
|
* @soc: SoC handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS dp_peer_find_attach(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_peer_find_detach() - Frees memory for peer objects
|
|
* @soc: SoC handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_peer_find_detach(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_peer_find_hash_add() - add peer to peer_hash_table
|
|
* @soc: soc handle
|
|
* @peer: peer handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_peer_find_hash_remove() - remove peer from peer_hash_table
|
|
* @soc: soc handle
|
|
* @peer: peer handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer);
|
|
|
|
/* unused?? */
|
|
void dp_peer_find_hash_erase(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_peer_vdev_list_add() - add peer into vdev's peer list
|
|
* @soc: soc handle
|
|
* @vdev: vdev handle
|
|
* @peer: peer handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev,
|
|
struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_peer_vdev_list_remove() - remove peer from vdev's peer list
|
|
* @soc: SoC handle
|
|
* @vdev: VDEV handle
|
|
* @peer: peer handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev,
|
|
struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_peer_find_id_to_obj_add() - Add peer into peer_id table
|
|
* @soc: SoC handle
|
|
* @peer: peer handle
|
|
* @peer_id: peer_id
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_peer_find_id_to_obj_add(struct dp_soc *soc,
|
|
struct dp_peer *peer,
|
|
uint16_t peer_id);
|
|
|
|
/**
|
|
* dp_txrx_peer_attach_add() - Attach txrx_peer and add it to peer_id table
|
|
* @soc: SoC handle
|
|
* @peer: peer handle
|
|
* @txrx_peer: txrx peer handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_txrx_peer_attach_add(struct dp_soc *soc,
|
|
struct dp_peer *peer,
|
|
struct dp_txrx_peer *txrx_peer);
|
|
|
|
/**
|
|
* dp_peer_find_id_to_obj_remove() - remove peer from peer_id table
|
|
* @soc: SoC handle
|
|
* @peer_id: peer_id
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_peer_find_id_to_obj_remove(struct dp_soc *soc,
|
|
uint16_t peer_id);
|
|
|
|
/**
|
|
* dp_vdev_unref_delete() - check and process vdev delete
|
|
* @soc: DP specific soc pointer
|
|
* @vdev: DP specific vdev pointer
|
|
* @mod_id: module id
|
|
*
|
|
*/
|
|
void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev,
|
|
enum dp_mod_id mod_id);
|
|
|
|
/**
|
|
* dp_peer_ppdu_delayed_ba_cleanup() - free ppdu allocated in peer
|
|
* @peer: Datapath peer
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_peer_ppdu_delayed_ba_cleanup(struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_peer_rx_init() - Initialize receive TID state
|
|
* @pdev: Datapath pdev
|
|
* @peer: Datapath peer
|
|
*
|
|
*/
|
|
void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_peer_cleanup() - Cleanup peer information
|
|
* @vdev: Datapath vdev
|
|
* @peer: Datapath peer
|
|
*
|
|
*/
|
|
void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer);
|
|
|
|
#ifdef DP_PEER_EXTENDED_API
|
|
/**
|
|
* dp_register_peer() - Register peer into physical device
|
|
* @soc_hdl: data path soc handle
|
|
* @pdev_id: device instance id
|
|
* @sta_desc: peer description
|
|
*
|
|
* Register peer into physical device
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS registration success
|
|
* QDF_STATUS_E_FAULT peer not found
|
|
*/
|
|
QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct ol_txrx_desc_type *sta_desc);
|
|
|
|
/**
|
|
* dp_clear_peer() - remove peer from physical device
|
|
* @soc_hdl: data path soc handle
|
|
* @pdev_id: device instance id
|
|
* @peer_addr: peer mac address
|
|
*
|
|
* remove peer from physical device
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS registration success
|
|
* QDF_STATUS_E_FAULT peer not found
|
|
*/
|
|
QDF_STATUS dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct qdf_mac_addr peer_addr);
|
|
|
|
/**
|
|
* dp_find_peer_exist_on_vdev - find if peer exists on the given vdev
|
|
* @soc_hdl: datapath soc handle
|
|
* @vdev_id: vdev instance id
|
|
* @peer_addr: peer mac address
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
uint8_t *peer_addr);
|
|
|
|
/**
|
|
* dp_find_peer_exist_on_other_vdev - find if peer exists
|
|
* on other than the given vdev
|
|
* @soc_hdl: datapath soc handle
|
|
* @vdev_id: vdev instance id
|
|
* @peer_addr: peer mac address
|
|
* @max_bssid: max number of bssids
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl,
|
|
uint8_t vdev_id, uint8_t *peer_addr,
|
|
uint16_t max_bssid);
|
|
|
|
/**
|
|
* dp_peer_state_update() - update peer local state
|
|
* @soc: datapath soc handle
|
|
* @peer_mac: peer mac address
|
|
* @state: new peer local state
|
|
*
|
|
* update peer local state
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS registration success
|
|
*/
|
|
QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc, uint8_t *peer_mac,
|
|
enum ol_txrx_peer_state state);
|
|
|
|
/**
|
|
* dp_get_vdevid() - Get virtual interface id which peer registered
|
|
* @soc_hdl: datapath soc handle
|
|
* @peer_mac: peer mac address
|
|
* @vdev_id: virtual interface id which peer registered
|
|
*
|
|
* Get virtual interface id which peer registered
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS registration success
|
|
*/
|
|
QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
|
|
uint8_t *vdev_id);
|
|
|
|
struct cdp_vdev *dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle,
|
|
struct qdf_mac_addr peer_addr);
|
|
|
|
/**
|
|
* dp_get_vdev_for_peer() - Get virtual interface instance which peer belongs
|
|
* @peer: peer instance
|
|
*
|
|
* Get virtual interface instance which peer belongs
|
|
*
|
|
* Return: virtual interface instance pointer
|
|
* NULL in case cannot find
|
|
*/
|
|
struct cdp_vdev *dp_get_vdev_for_peer(void *peer);
|
|
|
|
/**
|
|
* dp_peer_get_peer_mac_addr() - Get peer mac address
|
|
* @peer: peer instance
|
|
*
|
|
* Get peer mac address
|
|
*
|
|
* Return: peer mac address pointer
|
|
* NULL in case cannot find
|
|
*/
|
|
uint8_t *dp_peer_get_peer_mac_addr(void *peer);
|
|
|
|
/**
|
|
* dp_get_peer_state() - Get local peer state
|
|
* @soc: datapath soc handle
|
|
* @vdev_id: vdev id
|
|
* @peer_mac: peer mac addr
|
|
*
|
|
* Get local peer state
|
|
*
|
|
* Return: peer status
|
|
*/
|
|
int dp_get_peer_state(struct cdp_soc_t *soc, uint8_t vdev_id,
|
|
uint8_t *peer_mac);
|
|
|
|
/**
|
|
* dp_local_peer_id_pool_init() - local peer id pool alloc for physical device
|
|
* @pdev: data path device instance
|
|
*
|
|
* local peer id pool alloc for physical device
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_local_peer_id_pool_init(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_local_peer_id_alloc() - allocate local peer id
|
|
* @pdev: data path device instance
|
|
* @peer: new peer instance
|
|
*
|
|
* allocate local peer id
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_local_peer_id_free() - remove local peer id
|
|
* @pdev: data path device instance
|
|
* @peer: peer instance should be removed
|
|
*
|
|
* remove local peer id
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer);
|
|
|
|
/**
|
|
* dp_set_peer_as_tdls_peer() - set tdls peer flag to peer
|
|
* @soc_hdl: datapath soc handle
|
|
* @vdev_id: vdev_id
|
|
* @peer_mac: peer mac addr
|
|
* @val: tdls peer flag
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
uint8_t *peer_mac, bool val);
|
|
#else
|
|
static inline
|
|
QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
|
|
uint8_t *vdev_id)
|
|
{
|
|
return QDF_STATUS_E_NOSUPPORT;
|
|
}
|
|
|
|
static inline void dp_local_peer_id_pool_init(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
uint8_t *peer_mac, bool val)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_find_peer_exist - find peer if already exists
|
|
* @soc_hdl: datapath soc handle
|
|
* @pdev_id: physical device instance id
|
|
* @peer_addr: peer mac address
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
uint8_t *peer_addr);
|
|
|
|
#ifdef DP_UMAC_HW_RESET_SUPPORT
|
|
/**
|
|
* dp_pause_reo_send_cmd() - Pause Reo send commands.
|
|
* @soc: dp soc
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_pause_reo_send_cmd(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_resume_reo_send_cmd() - Resume Reo send commands.
|
|
* @soc: dp soc
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_resume_reo_send_cmd(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_cleanup_reo_cmd_module - Clean up the reo cmd module
|
|
* @soc: DP SoC handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_cleanup_reo_cmd_module(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_reo_desc_freelist_destroy() - Flush REO descriptors from deferred freelist
|
|
* @soc: DP SOC handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_reo_desc_freelist_destroy(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_reset_rx_reo_tid_queue() - Reset the reo tid queues
|
|
* @soc: dp soc
|
|
* @hw_qdesc_vaddr: starting address of the tid queues
|
|
* @size: size of the memory pointed to by hw_qdesc_vaddr
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_reset_rx_reo_tid_queue(struct dp_soc *soc, void *hw_qdesc_vaddr,
|
|
uint32_t size);
|
|
|
|
|
|
static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc)
|
|
{
|
|
notify_pre_reset_fw_callback callback = soc->notify_fw_callback;
|
|
|
|
if (callback)
|
|
callback(soc);
|
|
}
|
|
|
|
#if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP)
|
|
/**
|
|
* dp_umac_reset_complete_umac_recovery() - Complete Umac reset session
|
|
* @soc: dp soc handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_umac_reset_complete_umac_recovery(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_umac_reset_initiate_umac_recovery() - Initiate Umac reset session
|
|
* @soc: dp soc handle
|
|
* @umac_reset_ctx: Umac reset context
|
|
* @rx_event: Rx event received
|
|
* @is_target_recovery: Flag to indicate if it is triggered for target recovery
|
|
*
|
|
* Return: status
|
|
*/
|
|
QDF_STATUS dp_umac_reset_initiate_umac_recovery(struct dp_soc *soc,
|
|
struct dp_soc_umac_reset_ctx *umac_reset_ctx,
|
|
enum umac_reset_rx_event rx_event,
|
|
bool is_target_recovery);
|
|
|
|
/**
|
|
* dp_umac_reset_handle_action_cb() - Function to call action callback
|
|
* @soc: dp soc handle
|
|
* @umac_reset_ctx: Umac reset context
|
|
* @action: Action to call the callback for
|
|
*
|
|
* Return: QDF_STATUS status
|
|
*/
|
|
QDF_STATUS dp_umac_reset_handle_action_cb(struct dp_soc *soc,
|
|
struct dp_soc_umac_reset_ctx *umac_reset_ctx,
|
|
enum umac_reset_action action);
|
|
|
|
/**
|
|
* dp_umac_reset_post_tx_cmd() - Iterate partner socs and post Tx command
|
|
* @umac_reset_ctx: UMAC reset context
|
|
* @tx_cmd: Tx command to be posted
|
|
*
|
|
* Return: QDF status of operation
|
|
*/
|
|
QDF_STATUS
|
|
dp_umac_reset_post_tx_cmd(struct dp_soc_umac_reset_ctx *umac_reset_ctx,
|
|
enum umac_reset_tx_cmd tx_cmd);
|
|
|
|
/**
|
|
* dp_umac_reset_initiator_check() - Check if soc is the Umac reset initiator
|
|
* @soc: dp soc handle
|
|
*
|
|
* Return: true if the soc is initiator or false otherwise
|
|
*/
|
|
bool dp_umac_reset_initiator_check(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_umac_reset_target_recovery_check() - Check if this is for target recovery
|
|
* @soc: dp soc handle
|
|
*
|
|
* Return: true if the session is for target recovery or false otherwise
|
|
*/
|
|
bool dp_umac_reset_target_recovery_check(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_umac_reset_is_soc_ignored() - Check if this soc is to be ignored
|
|
* @soc: dp soc handle
|
|
*
|
|
* Return: true if the soc is ignored or false otherwise
|
|
*/
|
|
bool dp_umac_reset_is_soc_ignored(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_mlo_umac_reset_stats_print() - API to print MLO umac reset stats
|
|
* @soc: dp soc handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc);
|
|
#else
|
|
static inline
|
|
QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
#endif
|
|
#else
|
|
static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#if defined(DP_UMAC_HW_RESET_SUPPORT) && defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP)
|
|
/**
|
|
* dp_umac_reset_notify_asserted_soc() - API to notify the asserted SOC
|
|
* @soc: dp soc
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_get_umac_reset_in_progress_state() - API to check umac reset in progress
|
|
* state
|
|
* @psoc: dp soc handle
|
|
*
|
|
* Return: umac reset state
|
|
*/
|
|
enum cdp_umac_reset_state
|
|
dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc);
|
|
#else
|
|
static inline
|
|
QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline enum cdp_umac_reset_state
|
|
dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc)
|
|
{
|
|
return CDP_UMAC_RESET_NOT_IN_PROGRESS;
|
|
}
|
|
#endif
|
|
|
|
#ifndef WLAN_SOFTUMAC_SUPPORT
|
|
QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, enum hal_reo_cmd_type type,
|
|
struct hal_reo_cmd_params *params,
|
|
void (*callback_fn), void *data);
|
|
|
|
/**
|
|
* dp_reo_cmdlist_destroy() - Free REO commands in the queue
|
|
* @soc: DP SoC handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_reo_cmdlist_destroy(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_reo_status_ring_handler() - Handler for REO Status ring
|
|
* @int_ctx: pointer to DP interrupt context
|
|
* @soc: DP Soc handle
|
|
*
|
|
* Return: Number of descriptors reaped
|
|
*/
|
|
uint32_t dp_reo_status_ring_handler(struct dp_intr *int_ctx,
|
|
struct dp_soc *soc);
|
|
#endif
|
|
|
|
/**
|
|
* dp_aggregate_vdev_stats() - Consolidate stats at VDEV level
|
|
* @vdev: DP VDEV handle
|
|
* @vdev_stats: aggregate statistics
|
|
* @xmit_type: xmit type of packet - MLD/Link
|
|
* return: void
|
|
*/
|
|
void dp_aggregate_vdev_stats(struct dp_vdev *vdev,
|
|
struct cdp_vdev_stats *vdev_stats,
|
|
enum dp_pkt_xmit_type xmit_type);
|
|
|
|
/**
|
|
* dp_txrx_get_vdev_stats() - Update buffer with cdp_vdev_stats
|
|
* @soc_hdl: CDP SoC handle
|
|
* @vdev_id: vdev Id
|
|
* @buf: buffer for vdev stats
|
|
* @is_aggregate: are aggregate stats being collected
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS
|
|
dp_txrx_get_vdev_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
void *buf, bool is_aggregate);
|
|
|
|
/**
|
|
* dp_rx_bar_stats_cb() - BAR received stats callback
|
|
* @soc: SOC handle
|
|
* @cb_ctxt: Call back context
|
|
* @reo_status: Reo status
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_rx_bar_stats_cb(struct dp_soc *soc, void *cb_ctxt,
|
|
union hal_reo_status *reo_status);
|
|
|
|
uint16_t dp_tx_me_send_convert_ucast(struct cdp_soc_t *soc, uint8_t vdev_id,
|
|
qdf_nbuf_t nbuf,
|
|
uint8_t newmac[][QDF_MAC_ADDR_SIZE],
|
|
uint8_t new_mac_cnt, uint8_t tid,
|
|
bool is_igmp, bool is_dms_pkt);
|
|
void dp_tx_me_alloc_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id);
|
|
|
|
void dp_tx_me_free_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id);
|
|
|
|
/**
|
|
* dp_h2t_ext_stats_msg_send(): function to construct HTT message to pass to FW
|
|
* @pdev: DP PDEV handle
|
|
* @stats_type_upload_mask: stats type requested by user
|
|
* @config_param_0: extra configuration parameters
|
|
* @config_param_1: extra configuration parameters
|
|
* @config_param_2: extra configuration parameters
|
|
* @config_param_3: extra configuration parameters
|
|
* @cookie:
|
|
* @cookie_msb:
|
|
* @mac_id: mac number
|
|
*
|
|
* Return: QDF STATUS
|
|
*/
|
|
QDF_STATUS dp_h2t_ext_stats_msg_send(struct dp_pdev *pdev,
|
|
uint32_t stats_type_upload_mask, uint32_t config_param_0,
|
|
uint32_t config_param_1, uint32_t config_param_2,
|
|
uint32_t config_param_3, int cookie, int cookie_msb,
|
|
uint8_t mac_id);
|
|
|
|
/**
|
|
* dp_htt_stats_print_tag() - function to select the tag type and
|
|
* print the corresponding tag structure
|
|
* @pdev: pdev pointer
|
|
* @tag_type: tag type that is to be printed
|
|
* @tag_buf: pointer to the tag structure
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_htt_stats_print_tag(struct dp_pdev *pdev,
|
|
uint8_t tag_type, uint32_t *tag_buf);
|
|
|
|
/**
|
|
* dp_htt_stats_copy_tag() - function to select the tag type and
|
|
* copy the corresponding tag structure
|
|
* @pdev: DP_PDEV handle
|
|
* @tag_type: tag type that is to be printed
|
|
* @tag_buf: pointer to the tag structure
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_htt_stats_copy_tag(struct dp_pdev *pdev, uint8_t tag_type, uint32_t *tag_buf);
|
|
|
|
/**
|
|
* dp_h2t_3tuple_config_send(): function to construct 3 tuple configuration
|
|
* HTT message to pass to FW
|
|
* @pdev: DP PDEV handle
|
|
* @tuple_mask: tuple configuration to report 3 tuple hash value in either
|
|
* toeplitz_2_or_4 or flow_id_toeplitz in MSDU START TLV.
|
|
*
|
|
* tuple_mask[1:0]:
|
|
* 00 - Do not report 3 tuple hash value
|
|
* 10 - Report 3 tuple hash value in toeplitz_2_or_4
|
|
* 01 - Report 3 tuple hash value in flow_id_toeplitz
|
|
* 11 - Report 3 tuple hash value in both toeplitz_2_or_4 & flow_id_toeplitz
|
|
* @mac_id: MAC ID
|
|
*
|
|
* Return: QDF STATUS
|
|
*/
|
|
QDF_STATUS dp_h2t_3tuple_config_send(struct dp_pdev *pdev, uint32_t tuple_mask,
|
|
uint8_t mac_id);
|
|
|
|
#ifdef IPA_OFFLOAD
|
|
/**
|
|
* dp_peer_update_tid_stats_from_reo() - update rx pkt and byte count from reo
|
|
* @soc: soc handle
|
|
* @cb_ctxt: combination of peer_id and tid
|
|
* @reo_status: reo status
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_peer_update_tid_stats_from_reo(struct dp_soc *soc, void *cb_ctxt,
|
|
union hal_reo_status *reo_status);
|
|
|
|
int dp_peer_get_rxtid_stats_ipa(struct dp_peer *peer,
|
|
dp_rxtid_stats_cmd_cb dp_stats_cmd_cb);
|
|
#ifdef IPA_OPT_WIFI_DP
|
|
void dp_ipa_wdi_opt_dpath_notify_flt_rlsd(int flt0_rslt,
|
|
int flt1_rslt);
|
|
void dp_ipa_wdi_opt_dpath_notify_flt_add_rem_cb(int flt0_rslt, int flt1_rslt);
|
|
void dp_ipa_wdi_opt_dpath_notify_flt_rsvd(bool is_success);
|
|
#endif
|
|
#ifdef QCA_ENHANCED_STATS_SUPPORT
|
|
/**
|
|
* dp_peer_aggregate_tid_stats - aggregate rx tid stats
|
|
* @peer: Data Path peer
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_peer_aggregate_tid_stats(struct dp_peer *peer);
|
|
#endif
|
|
#else
|
|
static inline void dp_peer_aggregate_tid_stats(struct dp_peer *peer)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_set_key_sec_type_wifi3() - set security mode of key
|
|
* @soc: Datapath soc handle
|
|
* @vdev_id: id of atapath vdev
|
|
* @peer_mac: Datapath peer mac address
|
|
* @sec_type: security type
|
|
* @is_unicast: key type
|
|
*
|
|
*/
|
|
QDF_STATUS
|
|
dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id,
|
|
uint8_t *peer_mac, enum cdp_sec_type sec_type,
|
|
bool is_unicast);
|
|
|
|
/**
|
|
* dp_get_pdev_for_mac_id() - Return pdev for mac_id
|
|
* @soc: handle to DP soc
|
|
* @mac_id: MAC id
|
|
*
|
|
* Return: Return pdev corresponding to MAC
|
|
*/
|
|
void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id);
|
|
|
|
QDF_STATUS
|
|
dp_set_michael_key(struct cdp_soc_t *soc, uint8_t vdev_id,
|
|
uint8_t *peer_mac,
|
|
bool is_unicast, uint32_t *key);
|
|
|
|
/**
|
|
* dp_check_pdev_exists() - Validate pdev before use
|
|
* @soc: dp soc handle
|
|
* @data: pdev handle
|
|
*
|
|
* Return: 0 - success/invalid - failure
|
|
*/
|
|
bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data);
|
|
|
|
/**
|
|
* dp_update_delay_stats() - Update delay statistics in structure
|
|
* and fill min, max and avg delay
|
|
* @tstats: tid tx stats
|
|
* @rstats: tid rx stats
|
|
* @delay: delay in ms
|
|
* @tid: tid value
|
|
* @mode: type of tx delay mode
|
|
* @ring_id: ring number
|
|
* @delay_in_us: flag to indicate whether the delay is in ms or us
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_update_delay_stats(struct cdp_tid_tx_stats *tstats,
|
|
struct cdp_tid_rx_stats *rstats, uint32_t delay,
|
|
uint8_t tid, uint8_t mode, uint8_t ring_id,
|
|
bool delay_in_us);
|
|
|
|
/**
|
|
* dp_print_ring_stats(): Print tail and head pointer
|
|
* @pdev: DP_PDEV handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_ring_stats(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_print_ring_stat_from_hal(): Print tail and head pointer through hal
|
|
* @soc: soc handle
|
|
* @srng: srng handle
|
|
* @ring_type: ring type
|
|
*
|
|
* Return: void
|
|
*/
|
|
void
|
|
dp_print_ring_stat_from_hal(struct dp_soc *soc, struct dp_srng *srng,
|
|
enum hal_ring_type ring_type);
|
|
|
|
/**
|
|
* dp_print_pdev_cfg_params() - Print the pdev cfg parameters
|
|
* @pdev: DP pdev handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_pdev_cfg_params(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_print_soc_cfg_params()- Dump soc wlan config parameters
|
|
* @soc: Soc handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_soc_cfg_params(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_srng_get_str_from_hal_ring_type() - Return string name for a ring
|
|
* @ring_type: Ring
|
|
*
|
|
* Return: char const pointer
|
|
*/
|
|
const
|
|
char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type);
|
|
|
|
/**
|
|
* dp_txrx_path_stats() - Function to display dump stats
|
|
* @soc: soc handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_txrx_path_stats(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_print_per_ring_stats(): Packet count per ring
|
|
* @soc: soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_print_per_ring_stats(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_aggregate_pdev_stats(): Consolidate stats at PDEV level
|
|
* @pdev: DP PDEV handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_aggregate_pdev_stats(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_print_rx_rates(): Print Rx rate stats
|
|
* @vdev: DP_VDEV handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void dp_print_rx_rates(struct dp_vdev *vdev);
|
|
|
|
/**
|
|
* dp_print_tx_rates(): Print tx rates
|
|
* @vdev: DP_VDEV handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void dp_print_tx_rates(struct dp_vdev *vdev);
|
|
|
|
/**
|
|
* dp_print_peer_stats():print peer stats
|
|
* @peer: DP_PEER handle
|
|
* @peer_stats: buffer holding peer stats
|
|
*
|
|
* return void
|
|
*/
|
|
void dp_print_peer_stats(struct dp_peer *peer,
|
|
struct cdp_peer_stats *peer_stats);
|
|
|
|
/**
|
|
* dp_print_pdev_tx_stats(): Print Pdev level TX stats
|
|
* @pdev: DP_PDEV Handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void
|
|
dp_print_pdev_tx_stats(struct dp_pdev *pdev);
|
|
|
|
#if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MCAST_MLO)
|
|
/**
|
|
* dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats
|
|
* @vdev: DP_VDEV Handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void
|
|
dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev);
|
|
#else
|
|
/**
|
|
* dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats
|
|
* @vdev: DP_VDEV Handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
static inline
|
|
void dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_print_pdev_rx_stats(): Print Pdev level RX stats
|
|
* @pdev: DP_PDEV Handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void
|
|
dp_print_pdev_rx_stats(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_print_soc_tx_stats(): Print SOC level stats
|
|
* @soc: DP_SOC Handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_soc_tx_stats(struct dp_soc *soc);
|
|
|
|
#ifdef QCA_SUPPORT_DP_GLOBAL_CTX
|
|
/**
|
|
* dp_print_global_desc_count(): Print global desc in use
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_global_desc_count(void);
|
|
#else
|
|
/**
|
|
* dp_print_global_desc_count(): Print global desc in use
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline
|
|
void dp_print_global_desc_count(void)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_print_soc_interrupt_stats() - Print interrupt stats for the soc
|
|
* @soc: dp_soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_print_soc_interrupt_stats(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_print_tx_ppeds_stats() - Print Tx in use stats for the soc in DS
|
|
* @soc: dp_soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
|
|
void dp_print_tx_ppeds_stats(struct dp_soc *soc);
|
|
#ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING
|
|
/**
|
|
* dp_dump_srng_high_wm_stats() - Print the ring usage high watermark stats
|
|
* for all SRNGs
|
|
* @soc: DP soc handle
|
|
* @srng_mask: SRNGs mask for dumping usage watermark stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask);
|
|
#else
|
|
static inline
|
|
void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_print_soc_rx_stats() - Print SOC level Rx stats
|
|
* @soc: DP_SOC Handle
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_print_soc_rx_stats(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_get_mac_id_for_pdev() - Return mac corresponding to pdev for mac
|
|
*
|
|
* @mac_id: MAC id
|
|
* @pdev_id: pdev_id corresponding to pdev, 0 for MCL
|
|
*
|
|
* Single pdev using both MACs will operate on both MAC rings,
|
|
* which is the case for MCL.
|
|
* For WIN each PDEV will operate one ring, so index is zero.
|
|
*
|
|
*/
|
|
static inline int dp_get_mac_id_for_pdev(uint32_t mac_id, uint32_t pdev_id)
|
|
{
|
|
if (mac_id && pdev_id) {
|
|
qdf_print("Both mac_id and pdev_id cannot be non zero");
|
|
QDF_BUG(0);
|
|
return 0;
|
|
}
|
|
return (mac_id + pdev_id);
|
|
}
|
|
|
|
/**
|
|
* dp_get_lmac_id_for_pdev_id() - Return lmac id corresponding to host pdev id
|
|
* @soc: soc pointer
|
|
* @mac_id: MAC id
|
|
* @pdev_id: pdev_id corresponding to pdev, 0 for MCL
|
|
*
|
|
* For MCL, Single pdev using both MACs will operate on both MAC rings.
|
|
*
|
|
* For WIN, each PDEV will operate one ring.
|
|
*
|
|
*/
|
|
static inline int
|
|
dp_get_lmac_id_for_pdev_id
|
|
(struct dp_soc *soc, uint32_t mac_id, uint32_t pdev_id)
|
|
{
|
|
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) {
|
|
if (mac_id && pdev_id) {
|
|
qdf_print("Both mac_id and pdev_id cannot be non zero");
|
|
QDF_BUG(0);
|
|
return 0;
|
|
}
|
|
return (mac_id + pdev_id);
|
|
}
|
|
|
|
return soc->pdev_list[pdev_id]->lmac_id;
|
|
}
|
|
|
|
/**
|
|
* dp_get_pdev_for_lmac_id() - Return pdev pointer corresponding to lmac id
|
|
* @soc: soc pointer
|
|
* @lmac_id: LMAC id
|
|
*
|
|
* For MCL, Single pdev exists
|
|
*
|
|
* For WIN, each PDEV will operate one ring.
|
|
*
|
|
*/
|
|
static inline struct dp_pdev *
|
|
dp_get_pdev_for_lmac_id(struct dp_soc *soc, uint32_t lmac_id)
|
|
{
|
|
uint8_t i = 0;
|
|
|
|
if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) {
|
|
i = wlan_cfg_get_pdev_idx(soc->wlan_cfg_ctx, lmac_id);
|
|
return ((i < MAX_PDEV_CNT) ? soc->pdev_list[i] : NULL);
|
|
}
|
|
|
|
/* Typically for MCL as there only 1 PDEV*/
|
|
return soc->pdev_list[0];
|
|
}
|
|
|
|
/**
|
|
* dp_calculate_target_pdev_id_from_host_pdev_id() - Return target pdev
|
|
* corresponding to host pdev id
|
|
* @soc: soc pointer
|
|
* @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL
|
|
*
|
|
* Return: target pdev_id for host pdev id. For WIN, this is derived through
|
|
* a two step process:
|
|
* 1. Get lmac_id corresponding to host pdev_id (lmac_id can change
|
|
* during mode switch)
|
|
* 2. Get target pdev_id (set up during WMI ready) from lmac_id
|
|
*
|
|
* For MCL, return the offset-1 translated mac_id
|
|
*/
|
|
static inline int
|
|
dp_calculate_target_pdev_id_from_host_pdev_id
|
|
(struct dp_soc *soc, uint32_t mac_for_pdev)
|
|
{
|
|
struct dp_pdev *pdev;
|
|
|
|
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
|
|
return DP_SW2HW_MACID(mac_for_pdev);
|
|
|
|
pdev = soc->pdev_list[mac_for_pdev];
|
|
|
|
/*non-MCL case, get original target_pdev mapping*/
|
|
return wlan_cfg_get_target_pdev_id(soc->wlan_cfg_ctx, pdev->lmac_id);
|
|
}
|
|
|
|
/**
|
|
* dp_get_target_pdev_id_for_host_pdev_id() - Return target pdev corresponding
|
|
* to host pdev id
|
|
* @soc: soc pointer
|
|
* @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL
|
|
*
|
|
* Return: target pdev_id for host pdev id.
|
|
* For WIN, return the value stored in pdev object.
|
|
* For MCL, return the offset-1 translated mac_id.
|
|
*/
|
|
static inline int
|
|
dp_get_target_pdev_id_for_host_pdev_id
|
|
(struct dp_soc *soc, uint32_t mac_for_pdev)
|
|
{
|
|
struct dp_pdev *pdev;
|
|
|
|
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
|
|
return DP_SW2HW_MACID(mac_for_pdev);
|
|
|
|
pdev = soc->pdev_list[mac_for_pdev];
|
|
|
|
return pdev->target_pdev_id;
|
|
}
|
|
|
|
/**
|
|
* dp_get_host_pdev_id_for_target_pdev_id() - Return host pdev corresponding
|
|
* to target pdev id
|
|
* @soc: soc pointer
|
|
* @pdev_id: pdev_id corresponding to target pdev
|
|
*
|
|
* Return: host pdev_id for target pdev id. For WIN, this is derived through
|
|
* a two step process:
|
|
* 1. Get lmac_id corresponding to target pdev_id
|
|
* 2. Get host pdev_id (set up during WMI ready) from lmac_id
|
|
*
|
|
* For MCL, return the 0-offset pdev_id
|
|
*/
|
|
static inline int
|
|
dp_get_host_pdev_id_for_target_pdev_id
|
|
(struct dp_soc *soc, uint32_t pdev_id)
|
|
{
|
|
struct dp_pdev *pdev;
|
|
int lmac_id;
|
|
|
|
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
|
|
return DP_HW2SW_MACID(pdev_id);
|
|
|
|
/*non-MCL case, get original target_lmac mapping from target pdev*/
|
|
lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx,
|
|
DP_HW2SW_MACID(pdev_id));
|
|
|
|
/*Get host pdev from lmac*/
|
|
pdev = dp_get_pdev_for_lmac_id(soc, lmac_id);
|
|
|
|
return pdev ? pdev->pdev_id : INVALID_PDEV_ID;
|
|
}
|
|
|
|
/**
|
|
* dp_get_mac_id_for_mac() - Return mac corresponding WIN and MCL mac_ids
|
|
*
|
|
* @soc: handle to DP soc
|
|
* @mac_id: MAC id
|
|
*
|
|
* Single pdev using both MACs will operate on both MAC rings,
|
|
* which is the case for MCL.
|
|
* For WIN each PDEV will operate one ring, so index is zero.
|
|
*
|
|
*/
|
|
static inline int dp_get_mac_id_for_mac(struct dp_soc *soc, uint32_t mac_id)
|
|
{
|
|
/*
|
|
* Single pdev using both MACs will operate on both MAC rings,
|
|
* which is the case for MCL.
|
|
*/
|
|
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
|
|
return mac_id;
|
|
|
|
/* For WIN each PDEV will operate one ring, so index is zero. */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* dp_is_subtype_data() - check if the frame subtype is data
|
|
*
|
|
* @frame_ctrl: Frame control field
|
|
*
|
|
* check the frame control field and verify if the packet
|
|
* is a data packet.
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline bool dp_is_subtype_data(uint16_t frame_ctrl)
|
|
{
|
|
if (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_TYPE_MASK) ==
|
|
QDF_IEEE80211_FC0_TYPE_DATA) &&
|
|
(((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) ==
|
|
QDF_IEEE80211_FC0_SUBTYPE_DATA) ||
|
|
((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) ==
|
|
QDF_IEEE80211_FC0_SUBTYPE_QOS))) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifdef WDI_EVENT_ENABLE
|
|
/**
|
|
* dp_h2t_cfg_stats_msg_send(): function to construct HTT message to pass to FW
|
|
* @pdev: DP PDEV handle
|
|
* @stats_type_upload_mask: stats type requested by user
|
|
* @mac_id: Mac id number
|
|
*
|
|
* return: QDF STATUS
|
|
*/
|
|
QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev,
|
|
uint32_t stats_type_upload_mask,
|
|
uint8_t mac_id);
|
|
|
|
/**
|
|
* dp_wdi_event_unsub() - WDI event unsubscribe
|
|
* @soc: soc handle
|
|
* @pdev_id: id of pdev
|
|
* @event_cb_sub_handle: subscribed event handle
|
|
* @event: Event to be unsubscribe
|
|
*
|
|
* Return: 0 for success. nonzero for failure.
|
|
*/
|
|
int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id,
|
|
wdi_event_subscribe *event_cb_sub_handle,
|
|
uint32_t event);
|
|
|
|
/**
|
|
* dp_wdi_event_sub() - Subscribe WDI event
|
|
* @soc: soc handle
|
|
* @pdev_id: id of pdev
|
|
* @event_cb_sub_handle: subscribe event handle
|
|
* @event: Event to be subscribe
|
|
*
|
|
* Return: 0 for success. nonzero for failure.
|
|
*/
|
|
int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id,
|
|
wdi_event_subscribe *event_cb_sub_handle,
|
|
uint32_t event);
|
|
|
|
/**
|
|
* dp_wdi_event_handler() - Event handler for WDI event
|
|
* @event: wdi event number
|
|
* @soc: soc handle
|
|
* @data: pointer to data
|
|
* @peer_id: peer id number
|
|
* @status: HTT rx status
|
|
* @pdev_id: id of pdev
|
|
*
|
|
* It will be called to register WDI event
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_wdi_event_handler(enum WDI_EVENT event, struct dp_soc *soc,
|
|
void *data, u_int16_t peer_id,
|
|
int status, u_int8_t pdev_id);
|
|
|
|
/**
|
|
* dp_wdi_event_attach() - Attach wdi event
|
|
* @txrx_pdev: DP pdev handle
|
|
*
|
|
* Return: 0 for success. nonzero for failure.
|
|
*/
|
|
int dp_wdi_event_attach(struct dp_pdev *txrx_pdev);
|
|
|
|
/**
|
|
* dp_wdi_event_detach() - Detach WDI event
|
|
* @txrx_pdev: DP pdev handle
|
|
*
|
|
* Return: 0 for success. nonzero for failure.
|
|
*/
|
|
int dp_wdi_event_detach(struct dp_pdev *txrx_pdev);
|
|
|
|
static inline void
|
|
dp_hif_update_pipe_callback(struct dp_soc *dp_soc,
|
|
void *cb_context,
|
|
QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t),
|
|
uint8_t pipe_id)
|
|
{
|
|
struct hif_msg_callbacks hif_pipe_callbacks = { 0 };
|
|
|
|
/* TODO: Temporary change to bypass HTC connection for this new
|
|
* HIF pipe, which will be used for packet log and other high-
|
|
* priority HTT messages. Proper HTC connection to be added
|
|
* later once required FW changes are available
|
|
*/
|
|
hif_pipe_callbacks.rxCompletionHandler = callback;
|
|
hif_pipe_callbacks.Context = cb_context;
|
|
hif_update_pipe_callback(dp_soc->hif_handle,
|
|
DP_HTT_T2H_HP_PIPE, &hif_pipe_callbacks);
|
|
}
|
|
#else
|
|
static inline int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id,
|
|
wdi_event_subscribe *event_cb_sub_handle,
|
|
uint32_t event)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id,
|
|
wdi_event_subscribe *event_cb_sub_handle,
|
|
uint32_t event)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline
|
|
void dp_wdi_event_handler(enum WDI_EVENT event,
|
|
struct dp_soc *soc,
|
|
void *data, u_int16_t peer_id,
|
|
int status, u_int8_t pdev_id)
|
|
{
|
|
}
|
|
|
|
static inline int dp_wdi_event_attach(struct dp_pdev *txrx_pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline int dp_wdi_event_detach(struct dp_pdev *txrx_pdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev,
|
|
uint32_t stats_type_upload_mask, uint8_t mac_id)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void
|
|
dp_hif_update_pipe_callback(struct dp_soc *dp_soc, void *cb_context,
|
|
QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t),
|
|
uint8_t pipe_id)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#ifdef VDEV_PEER_PROTOCOL_COUNT
|
|
/**
|
|
* dp_vdev_peer_stats_update_protocol_cnt() - update per-peer protocol counters
|
|
* @vdev: VDEV DP object
|
|
* @nbuf: data packet
|
|
* @txrx_peer: DP TXRX Peer object
|
|
* @is_egress: whether egress or ingress
|
|
* @is_rx: whether rx or tx
|
|
*
|
|
* This function updates the per-peer protocol counters
|
|
* Return: void
|
|
*/
|
|
void dp_vdev_peer_stats_update_protocol_cnt(struct dp_vdev *vdev,
|
|
qdf_nbuf_t nbuf,
|
|
struct dp_txrx_peer *txrx_peer,
|
|
bool is_egress,
|
|
bool is_rx);
|
|
|
|
/**
|
|
* dp_peer_stats_update_protocol_cnt() - update per-peer protocol counters
|
|
* @soc: SOC DP object
|
|
* @vdev_id: vdev_id
|
|
* @nbuf: data packet
|
|
* @is_egress: whether egress or ingress
|
|
* @is_rx: whether rx or tx
|
|
*
|
|
* This function updates the per-peer protocol counters
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_peer_stats_update_protocol_cnt(struct cdp_soc_t *soc,
|
|
int8_t vdev_id,
|
|
qdf_nbuf_t nbuf,
|
|
bool is_egress,
|
|
bool is_rx);
|
|
|
|
void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl,
|
|
qdf_nbuf_t nbuf);
|
|
|
|
#else
|
|
#define dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, txrx_peer, \
|
|
is_egress, is_rx)
|
|
|
|
static inline
|
|
void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl,
|
|
qdf_nbuf_t nbuf)
|
|
{
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef QCA_LL_TX_FLOW_CONTROL_V2
|
|
/**
|
|
* dp_tx_dump_flow_pool_info() - dump global_pool and flow_pool info
|
|
* @soc_hdl: Handle to struct cdp_soc
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_tx_dump_flow_pool_info(struct cdp_soc_t *soc_hdl);
|
|
|
|
/**
|
|
* dp_tx_dump_flow_pool_info_compact() - dump flow pool info
|
|
* @soc: DP soc context
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc);
|
|
int dp_tx_delete_flow_pool(struct dp_soc *soc, struct dp_tx_desc_pool_s *pool,
|
|
bool force);
|
|
#else
|
|
static inline void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc)
|
|
{
|
|
}
|
|
#endif /* QCA_LL_TX_FLOW_CONTROL_V2 */
|
|
|
|
#ifdef QCA_OL_DP_SRNG_LOCK_LESS_ACCESS
|
|
static inline int
|
|
dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
return hal_srng_access_start_unlocked(soc, hal_ring_hdl);
|
|
}
|
|
|
|
static inline void
|
|
dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_srng_access_end_unlocked(soc, hal_ring_hdl);
|
|
}
|
|
|
|
#else
|
|
static inline int
|
|
dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
return hal_srng_access_start(soc, hal_ring_hdl);
|
|
}
|
|
|
|
static inline void
|
|
dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_srng_access_end(soc, hal_ring_hdl);
|
|
}
|
|
#endif
|
|
|
|
#ifdef WLAN_FEATURE_DP_EVENT_HISTORY
|
|
/**
|
|
* dp_srng_access_start() - Wrapper function to log access start of a hal ring
|
|
* @int_ctx: pointer to DP interrupt context. This should not be NULL
|
|
* @dp_soc: DP Soc handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be
|
|
* serviced
|
|
*
|
|
* Return: 0 on success; error on failure
|
|
*/
|
|
int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl);
|
|
|
|
/**
|
|
* dp_srng_access_end() - Wrapper function to log access end of a hal ring
|
|
* @int_ctx: pointer to DP interrupt context. This should not be NULL
|
|
* @dp_soc: DP Soc handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be
|
|
* serviced
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl);
|
|
|
|
#else
|
|
static inline int dp_srng_access_start(struct dp_intr *int_ctx,
|
|
struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_soc_handle_t hal_soc = dp_soc->hal_soc;
|
|
|
|
return dp_hal_srng_access_start(hal_soc, hal_ring_hdl);
|
|
}
|
|
|
|
static inline void dp_srng_access_end(struct dp_intr *int_ctx,
|
|
struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_soc_handle_t hal_soc = dp_soc->hal_soc;
|
|
|
|
return dp_hal_srng_access_end(hal_soc, hal_ring_hdl);
|
|
}
|
|
#endif /* WLAN_FEATURE_DP_EVENT_HISTORY */
|
|
|
|
#ifdef QCA_CACHED_RING_DESC
|
|
/**
|
|
* dp_srng_dst_get_next() - Wrapper function to get next ring desc
|
|
* @dp_soc: DP Soc handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Destination Ring
|
|
*
|
|
* Return: HAL ring descriptor
|
|
*/
|
|
static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_soc_handle_t hal_soc = dp_soc->hal_soc;
|
|
|
|
return hal_srng_dst_get_next_cached(hal_soc, hal_ring_hdl);
|
|
}
|
|
|
|
/**
|
|
* dp_srng_dst_inv_cached_descs() - Wrapper function to invalidate cached
|
|
* descriptors
|
|
* @dp_soc: DP Soc handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring
|
|
* @num_entries: Entry count
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
hal_soc_handle_t hal_soc = dp_soc->hal_soc;
|
|
|
|
hal_srng_dst_inv_cached_descs(hal_soc, hal_ring_hdl, num_entries);
|
|
}
|
|
#else
|
|
static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl)
|
|
{
|
|
hal_soc_handle_t hal_soc = dp_soc->hal_soc;
|
|
|
|
return hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
|
|
}
|
|
|
|
static inline void dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
}
|
|
#endif /* QCA_CACHED_RING_DESC */
|
|
|
|
#if defined(QCA_CACHED_RING_DESC) && \
|
|
(defined(QCA_DP_RX_HW_SW_NBUF_DESC_PREFETCH) || \
|
|
defined(QCA_DP_TX_HW_SW_NBUF_DESC_PREFETCH))
|
|
/**
|
|
* dp_srng_dst_prefetch() - Wrapper function to prefetch descs from dest ring
|
|
* @hal_soc: HAL SOC handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring
|
|
* @num_entries: Entry count
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
return hal_srng_dst_prefetch(hal_soc, hal_ring_hdl, num_entries);
|
|
}
|
|
|
|
/**
|
|
* dp_srng_dst_prefetch_32_byte_desc() - Wrapper function to prefetch
|
|
* 32 byte descriptor starting at
|
|
* 64 byte offset
|
|
* @hal_soc: HAL SOC handle
|
|
* @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring
|
|
* @num_entries: Entry count
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline
|
|
void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
return hal_srng_dst_prefetch_32_byte_desc(hal_soc, hal_ring_hdl,
|
|
num_entries);
|
|
}
|
|
#else
|
|
static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline
|
|
void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc,
|
|
hal_ring_handle_t hal_ring_hdl,
|
|
uint32_t num_entries)
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifdef QCA_ENH_V3_STATS_SUPPORT
|
|
/**
|
|
* dp_pdev_print_delay_stats(): Print pdev level delay stats
|
|
* @pdev: DP_PDEV handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void dp_pdev_print_delay_stats(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_pdev_print_tid_stats(): Print pdev level tid stats
|
|
* @pdev: DP_PDEV handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void dp_pdev_print_tid_stats(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_pdev_print_rx_error_stats(): Print pdev level rx error stats
|
|
* @pdev: DP_PDEV handle
|
|
*
|
|
* Return:void
|
|
*/
|
|
void dp_pdev_print_rx_error_stats(struct dp_pdev *pdev);
|
|
#endif /* QCA_ENH_V3_STATS_SUPPORT */
|
|
|
|
/**
|
|
* dp_pdev_get_tid_stats(): Get accumulated pdev level tid_stats
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of dp_pdev handle
|
|
* @tid_stats: Pointer for cdp_tid_stats_intf
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_INVAL
|
|
*/
|
|
QDF_STATUS dp_pdev_get_tid_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct cdp_tid_stats_intf *tid_stats);
|
|
|
|
/**
|
|
* dp_soc_set_txrx_ring_map()
|
|
* @soc: DP handler for soc
|
|
*
|
|
* Return: Void
|
|
*/
|
|
void dp_soc_set_txrx_ring_map(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_vdev_to_cdp_vdev() - typecast dp vdev to cdp vdev
|
|
* @vdev: DP vdev handle
|
|
*
|
|
* Return: struct cdp_vdev pointer
|
|
*/
|
|
static inline
|
|
struct cdp_vdev *dp_vdev_to_cdp_vdev(struct dp_vdev *vdev)
|
|
{
|
|
return (struct cdp_vdev *)vdev;
|
|
}
|
|
|
|
/**
|
|
* dp_pdev_to_cdp_pdev() - typecast dp pdev to cdp pdev
|
|
* @pdev: DP pdev handle
|
|
*
|
|
* Return: struct cdp_pdev pointer
|
|
*/
|
|
static inline
|
|
struct cdp_pdev *dp_pdev_to_cdp_pdev(struct dp_pdev *pdev)
|
|
{
|
|
return (struct cdp_pdev *)pdev;
|
|
}
|
|
|
|
/**
|
|
* dp_soc_to_cdp_soc() - typecast dp psoc to cdp psoc
|
|
* @psoc: DP psoc handle
|
|
*
|
|
* Return: struct cdp_soc pointer
|
|
*/
|
|
static inline
|
|
struct cdp_soc *dp_soc_to_cdp_soc(struct dp_soc *psoc)
|
|
{
|
|
return (struct cdp_soc *)psoc;
|
|
}
|
|
|
|
/**
|
|
* dp_soc_to_cdp_soc_t() - typecast dp psoc to ol txrx soc handle
|
|
* @psoc: DP psoc handle
|
|
*
|
|
* Return: struct cdp_soc_t pointer
|
|
*/
|
|
static inline
|
|
struct cdp_soc_t *dp_soc_to_cdp_soc_t(struct dp_soc *psoc)
|
|
{
|
|
return (struct cdp_soc_t *)psoc;
|
|
}
|
|
|
|
#if defined(WLAN_SUPPORT_RX_FLOW_TAG)
|
|
/**
|
|
* dp_rx_flow_get_fse_stats() - Retrieve a flow's statistics
|
|
* @pdev: pdev handle
|
|
* @rx_flow_info: flow information in the Rx FST
|
|
* @stats: stats to update
|
|
*
|
|
* Return: Success when flow statistcs is updated, error on failure
|
|
*/
|
|
QDF_STATUS dp_rx_flow_get_fse_stats(struct dp_pdev *pdev,
|
|
struct cdp_rx_flow_info *rx_flow_info,
|
|
struct cdp_flow_stats *stats);
|
|
|
|
/**
|
|
* dp_rx_flow_delete_entry() - Delete a flow entry from flow search table
|
|
* @pdev: pdev handle
|
|
* @rx_flow_info: DP flow parameters
|
|
*
|
|
* Return: Success when flow is deleted, error on failure
|
|
*/
|
|
QDF_STATUS dp_rx_flow_delete_entry(struct dp_pdev *pdev,
|
|
struct cdp_rx_flow_info *rx_flow_info);
|
|
|
|
/**
|
|
* dp_rx_flow_add_entry() - Add a flow entry to flow search table
|
|
* @pdev: DP pdev instance
|
|
* @rx_flow_info: DP flow parameters
|
|
*
|
|
* Return: Success when flow is added, no-memory or already exists on error
|
|
*/
|
|
QDF_STATUS dp_rx_flow_add_entry(struct dp_pdev *pdev,
|
|
struct cdp_rx_flow_info *rx_flow_info);
|
|
|
|
/**
|
|
* dp_rx_fst_attach() - Initialize Rx FST and setup necessary parameters
|
|
* @soc: SoC handle
|
|
* @pdev: Pdev handle
|
|
*
|
|
* Return: Handle to flow search table entry
|
|
*/
|
|
QDF_STATUS dp_rx_fst_attach(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_rx_fst_detach() - De-initialize Rx FST
|
|
* @soc: SoC handle
|
|
* @pdev: Pdev handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_rx_fst_detach(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_mon_rx_update_rx_flow_tag_stats() - Update a mon flow's statistics
|
|
* @pdev: pdev handle
|
|
* @flow_id: flow index (truncated hash) in the Rx FST
|
|
*
|
|
* Return: Success when flow statistcs is updated, error on failure
|
|
*/
|
|
QDF_STATUS
|
|
dp_mon_rx_update_rx_flow_tag_stats(struct dp_pdev *pdev, uint32_t flow_id);
|
|
#endif
|
|
|
|
#ifdef WLAN_SUPPORT_RX_FLOW_TAG
|
|
/**
|
|
* dp_rx_flow_send_fst_fw_setup() - Program FST parameters in FW/HW post-attach
|
|
* @soc: SoC handle
|
|
* @pdev: Pdev handle
|
|
*
|
|
* Return: Success when fst parameters are programmed in FW, error otherwise
|
|
*/
|
|
QDF_STATUS dp_rx_flow_send_fst_fw_setup(struct dp_soc *soc,
|
|
struct dp_pdev *pdev);
|
|
#endif
|
|
|
|
/**
|
|
* dp_rx_fst_attach_wrapper() - wrapper API for dp_rx_fst_attach
|
|
* @soc: SoC handle
|
|
* @pdev: Pdev handle
|
|
*
|
|
* Return: Handle to flow search table entry
|
|
*/
|
|
extern QDF_STATUS
|
|
dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_rx_fst_detach_wrapper() - wrapper API for dp_rx_fst_detach
|
|
* @soc: SoC handle
|
|
* @pdev: Pdev handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
extern void
|
|
dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_vdev_get_ref() - API to take a reference for VDEV object
|
|
*
|
|
* @soc : core DP soc context
|
|
* @vdev : DP vdev
|
|
* @mod_id : module id
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS if reference held successfully
|
|
* else QDF_STATUS_E_INVAL
|
|
*/
|
|
static inline
|
|
QDF_STATUS dp_vdev_get_ref(struct dp_soc *soc, struct dp_vdev *vdev,
|
|
enum dp_mod_id mod_id)
|
|
{
|
|
if (!qdf_atomic_inc_not_zero(&vdev->ref_cnt))
|
|
return QDF_STATUS_E_INVAL;
|
|
|
|
qdf_atomic_inc(&vdev->mod_refs[mod_id]);
|
|
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* dp_vdev_get_ref_by_id() - Returns vdev object given the vdev id
|
|
* @soc: core DP soc context
|
|
* @vdev_id: vdev id from vdev object can be retrieved
|
|
* @mod_id: module id which is requesting the reference
|
|
*
|
|
* Return: struct dp_vdev*: Pointer to DP vdev object
|
|
*/
|
|
static inline struct dp_vdev *
|
|
dp_vdev_get_ref_by_id(struct dp_soc *soc, uint8_t vdev_id,
|
|
enum dp_mod_id mod_id)
|
|
{
|
|
struct dp_vdev *vdev = NULL;
|
|
if (qdf_unlikely(vdev_id >= MAX_VDEV_CNT))
|
|
return NULL;
|
|
|
|
qdf_spin_lock_bh(&soc->vdev_map_lock);
|
|
vdev = soc->vdev_id_map[vdev_id];
|
|
|
|
if (!vdev || dp_vdev_get_ref(soc, vdev, mod_id) != QDF_STATUS_SUCCESS) {
|
|
qdf_spin_unlock_bh(&soc->vdev_map_lock);
|
|
return NULL;
|
|
}
|
|
qdf_spin_unlock_bh(&soc->vdev_map_lock);
|
|
|
|
return vdev;
|
|
}
|
|
|
|
/**
|
|
* dp_get_pdev_from_soc_pdev_id_wifi3() - Returns pdev object given the pdev id
|
|
* @soc: core DP soc context
|
|
* @pdev_id: pdev id from pdev object can be retrieved
|
|
*
|
|
* Return: struct dp_pdev*: Pointer to DP pdev object
|
|
*/
|
|
static inline struct dp_pdev *
|
|
dp_get_pdev_from_soc_pdev_id_wifi3(struct dp_soc *soc,
|
|
uint8_t pdev_id)
|
|
{
|
|
if (qdf_unlikely(pdev_id >= MAX_PDEV_CNT))
|
|
return NULL;
|
|
|
|
return soc->pdev_list[pdev_id];
|
|
}
|
|
|
|
/**
|
|
* dp_get_peer_mac_list(): function to get peer mac list of vdev
|
|
* @soc: Datapath soc handle
|
|
* @vdev_id: vdev id
|
|
* @newmac: Table of the clients mac
|
|
* @mac_cnt: No. of MACs required
|
|
* @limit: Limit the number of clients
|
|
*
|
|
* Return: no of clients
|
|
*/
|
|
uint16_t dp_get_peer_mac_list(ol_txrx_soc_handle soc, uint8_t vdev_id,
|
|
u_int8_t newmac[][QDF_MAC_ADDR_SIZE],
|
|
u_int16_t mac_cnt, bool limit);
|
|
|
|
/**
|
|
* dp_update_num_mac_rings_for_dbs() - Update No of MAC rings based on
|
|
* DBS check
|
|
* @soc: DP SoC context
|
|
* @max_mac_rings: Pointer to variable for No of MAC rings
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc,
|
|
int *max_mac_rings);
|
|
|
|
|
|
#if defined(WLAN_SUPPORT_RX_FISA)
|
|
/**
|
|
* dp_rx_fst_update_cmem_params() - Update CMEM FST params
|
|
* @soc: DP SoC context
|
|
* @num_entries: Number of flow search entries
|
|
* @cmem_ba_lo: CMEM base address low
|
|
* @cmem_ba_hi: CMEM base address high
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries,
|
|
uint32_t cmem_ba_lo, uint32_t cmem_ba_hi);
|
|
|
|
/**
|
|
* dp_fisa_config() - FISA config handler
|
|
* @cdp_soc: CDP SoC handle
|
|
* @pdev_id: PDEV ID
|
|
* @config_id: FISA config ID
|
|
* @cfg: FISA config msg data
|
|
*/
|
|
QDF_STATUS dp_fisa_config(ol_txrx_soc_handle cdp_soc, uint8_t pdev_id,
|
|
enum cdp_fisa_config_id config_id,
|
|
union cdp_fisa_config *cfg);
|
|
#else
|
|
static inline void
|
|
dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries,
|
|
uint32_t cmem_ba_lo, uint32_t cmem_ba_hi)
|
|
{
|
|
}
|
|
#endif /* WLAN_SUPPORT_RX_FISA */
|
|
|
|
#ifdef MAX_ALLOC_PAGE_SIZE
|
|
/**
|
|
* dp_set_max_page_size() - Set the max page size for hw link desc.
|
|
* @pages: link desc page handle
|
|
* @max_alloc_size: max_alloc_size
|
|
*
|
|
* For MCL the page size is set to OS defined value and for WIN
|
|
* the page size is set to the max_alloc_size cfg ini
|
|
* param.
|
|
* This is to ensure that WIN gets contiguous memory allocations
|
|
* as per requirement.
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline
|
|
void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages,
|
|
uint32_t max_alloc_size)
|
|
{
|
|
pages->page_size = qdf_page_size;
|
|
}
|
|
|
|
#else
|
|
static inline
|
|
void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages,
|
|
uint32_t max_alloc_size)
|
|
{
|
|
pages->page_size = max_alloc_size;
|
|
}
|
|
#endif /* MAX_ALLOC_PAGE_SIZE */
|
|
|
|
/**
|
|
* dp_history_get_next_index() - get the next entry to record an entry
|
|
* in the history.
|
|
* @curr_idx: Current index where the last entry is written.
|
|
* @max_entries: Max number of entries in the history
|
|
*
|
|
* This function assumes that the max number os entries is a power of 2.
|
|
*
|
|
* Return: The index where the next entry is to be written.
|
|
*/
|
|
static inline uint32_t dp_history_get_next_index(qdf_atomic_t *curr_idx,
|
|
uint32_t max_entries)
|
|
{
|
|
uint32_t idx = qdf_atomic_inc_return(curr_idx);
|
|
|
|
return idx & (max_entries - 1);
|
|
}
|
|
|
|
/**
|
|
* dp_rx_skip_tlvs() - Skip TLVs len + L3 padding, save in nbuf->cb
|
|
* @soc: Datapath soc handle
|
|
* @nbuf: nbuf cb to be updated
|
|
* @l3_padding: L3 padding
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding);
|
|
|
|
#ifndef FEATURE_WDS
|
|
static inline void
|
|
dp_hmwds_ast_add_notify(struct dp_peer *peer,
|
|
uint8_t *mac_addr,
|
|
enum cdp_txrx_ast_entry_type type,
|
|
QDF_STATUS err,
|
|
bool is_peer_map)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#ifdef HTT_STATS_DEBUGFS_SUPPORT
|
|
/**
|
|
* dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize
|
|
* debugfs for HTT stats
|
|
* @pdev: dp pdev handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for
|
|
* HTT stats
|
|
* @pdev: dp pdev handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev);
|
|
#else
|
|
|
|
/**
|
|
* dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize
|
|
* debugfs for HTT stats
|
|
* @pdev: dp pdev handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline QDF_STATUS
|
|
dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for
|
|
* HTT stats
|
|
* @pdev: dp pdev handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
static inline void
|
|
dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev)
|
|
{
|
|
}
|
|
#endif /* HTT_STATS_DEBUGFS_SUPPORT */
|
|
|
|
#ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR
|
|
/**
|
|
* dp_soc_swlm_attach() - attach the software latency manager resources
|
|
* @soc: Datapath global soc handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline QDF_STATUS dp_soc_swlm_attach(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* dp_soc_swlm_detach() - detach the software latency manager resources
|
|
* @soc: Datapath global soc handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline QDF_STATUS dp_soc_swlm_detach(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
#endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */
|
|
|
|
#ifndef WLAN_DP_PROFILE_SUPPORT
|
|
static inline void wlan_dp_soc_cfg_sync_profile(struct cdp_soc_t *cdp_soc) {}
|
|
|
|
static inline void wlan_dp_pdev_cfg_sync_profile(struct cdp_soc_t *cdp_soc,
|
|
uint8_t pdev_id) {}
|
|
#endif
|
|
|
|
/**
|
|
* dp_get_peer_id(): function to get peer id by mac
|
|
* @soc: Datapath soc handle
|
|
* @vdev_id: vdev id
|
|
* @mac: Peer mac address
|
|
*
|
|
* Return: valid peer id on success
|
|
* HTT_INVALID_PEER on failure
|
|
*/
|
|
uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac);
|
|
|
|
#ifdef QCA_SUPPORT_WDS_EXTENDED
|
|
/**
|
|
* dp_wds_ext_set_peer_rx(): function to set peer rx handler
|
|
* @soc: Datapath soc handle
|
|
* @vdev_id: vdev id
|
|
* @mac: Peer mac address
|
|
* @rx: rx function pointer
|
|
* @osif_peer: OSIF peer handle
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS on success
|
|
* QDF_STATUS_E_INVAL if peer is not found
|
|
* QDF_STATUS_E_ALREADY if rx is already set/unset
|
|
*/
|
|
QDF_STATUS dp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc,
|
|
uint8_t vdev_id,
|
|
uint8_t *mac,
|
|
ol_txrx_rx_fp rx,
|
|
ol_osif_peer_handle osif_peer);
|
|
|
|
/**
|
|
* dp_wds_ext_get_peer_osif_handle(): function to get peer osif handle
|
|
* @soc: Datapath soc handle
|
|
* @vdev_id: vdev id
|
|
* @mac: Peer mac address
|
|
* @osif_peer: OSIF peer handle
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS on success
|
|
* QDF_STATUS_E_INVAL if peer is not found
|
|
*/
|
|
QDF_STATUS dp_wds_ext_get_peer_osif_handle(
|
|
ol_txrx_soc_handle soc,
|
|
uint8_t vdev_id,
|
|
uint8_t *mac,
|
|
ol_osif_peer_handle *osif_peer);
|
|
|
|
/**
|
|
* dp_wds_ext_set_peer_bit(): function to set wds-ext peer bit
|
|
* @soc: Datapath soc handle
|
|
* @mac: Peer mac address
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS on success
|
|
* QDF_STATUS_E_INVAL if peer is not found
|
|
*/
|
|
QDF_STATUS dp_wds_ext_set_peer_bit(ol_txrx_soc_handle soc, uint8_t *mac);
|
|
|
|
#endif /* QCA_SUPPORT_WDS_EXTENDED */
|
|
|
|
#ifdef DP_MEM_PRE_ALLOC
|
|
|
|
/**
|
|
* dp_context_alloc_mem() - allocate memory for DP context
|
|
* @soc: datapath soc handle
|
|
* @ctxt_type: DP context type
|
|
* @ctxt_size: DP context size
|
|
*
|
|
* Return: DP context address
|
|
*/
|
|
void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type,
|
|
size_t ctxt_size);
|
|
|
|
/**
|
|
* dp_context_free_mem() - Free memory of DP context
|
|
* @soc: datapath soc handle
|
|
* @ctxt_type: DP context type
|
|
* @vaddr: Address of context memory
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type,
|
|
void *vaddr);
|
|
|
|
/**
|
|
* dp_desc_multi_pages_mem_alloc() - alloc memory over multiple pages
|
|
* @soc: datapath soc handle
|
|
* @desc_type: memory request source type
|
|
* @pages: multi page information storage
|
|
* @element_size: each element size
|
|
* @element_num: total number of elements should be allocated
|
|
* @memctxt: memory context
|
|
* @cacheable: coherent memory or cacheable memory
|
|
*
|
|
* This function is a wrapper for memory allocation over multiple
|
|
* pages, if dp prealloc method is registered, then will try prealloc
|
|
* firstly. if prealloc failed, fall back to regular way over
|
|
* qdf_mem_multi_pages_alloc().
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc,
|
|
enum qdf_dp_desc_type desc_type,
|
|
struct qdf_mem_multi_page_t *pages,
|
|
size_t element_size,
|
|
uint32_t element_num,
|
|
qdf_dma_context_t memctxt,
|
|
bool cacheable);
|
|
|
|
/**
|
|
* dp_desc_multi_pages_mem_free() - free multiple pages memory
|
|
* @soc: datapath soc handle
|
|
* @desc_type: memory request source type
|
|
* @pages: multi page information storage
|
|
* @memctxt: memory context
|
|
* @cacheable: coherent memory or cacheable memory
|
|
*
|
|
* This function is a wrapper for multiple pages memory free,
|
|
* if memory is got from prealloc pool, put it back to pool.
|
|
* otherwise free by qdf_mem_multi_pages_free().
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_desc_multi_pages_mem_free(struct dp_soc *soc,
|
|
enum qdf_dp_desc_type desc_type,
|
|
struct qdf_mem_multi_page_t *pages,
|
|
qdf_dma_context_t memctxt,
|
|
bool cacheable);
|
|
|
|
#else
|
|
static inline
|
|
void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type,
|
|
size_t ctxt_size)
|
|
{
|
|
return qdf_mem_malloc(ctxt_size);
|
|
}
|
|
|
|
static inline
|
|
void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type,
|
|
void *vaddr)
|
|
{
|
|
qdf_mem_free(vaddr);
|
|
}
|
|
|
|
static inline
|
|
void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc,
|
|
enum qdf_dp_desc_type desc_type,
|
|
struct qdf_mem_multi_page_t *pages,
|
|
size_t element_size,
|
|
uint32_t element_num,
|
|
qdf_dma_context_t memctxt,
|
|
bool cacheable)
|
|
{
|
|
qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size,
|
|
element_num, memctxt, cacheable);
|
|
}
|
|
|
|
static inline
|
|
void dp_desc_multi_pages_mem_free(struct dp_soc *soc,
|
|
enum qdf_dp_desc_type desc_type,
|
|
struct qdf_mem_multi_page_t *pages,
|
|
qdf_dma_context_t memctxt,
|
|
bool cacheable)
|
|
{
|
|
qdf_mem_multi_pages_free(soc->osdev, pages,
|
|
memctxt, cacheable);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* struct dp_frag_history_opaque_atomic - Opaque struct for adding a fragmented
|
|
* history.
|
|
* @index: atomic index
|
|
* @num_entries_per_slot: Number of entries per slot
|
|
* @allocated: is allocated or not
|
|
* @entry: pointers to array of records
|
|
*/
|
|
struct dp_frag_history_opaque_atomic {
|
|
qdf_atomic_t index;
|
|
uint16_t num_entries_per_slot;
|
|
uint16_t allocated;
|
|
void *entry[0];
|
|
};
|
|
|
|
static inline QDF_STATUS
|
|
dp_soc_frag_history_attach(struct dp_soc *soc, void *history_hdl,
|
|
uint32_t max_slots, uint32_t max_entries_per_slot,
|
|
uint32_t entry_size,
|
|
bool attempt_prealloc, enum dp_ctxt_type ctxt_type)
|
|
{
|
|
struct dp_frag_history_opaque_atomic *history =
|
|
(struct dp_frag_history_opaque_atomic *)history_hdl;
|
|
size_t alloc_size = max_entries_per_slot * entry_size;
|
|
int i;
|
|
|
|
for (i = 0; i < max_slots; i++) {
|
|
if (attempt_prealloc)
|
|
history->entry[i] = dp_context_alloc_mem(soc, ctxt_type,
|
|
alloc_size);
|
|
else
|
|
history->entry[i] = qdf_mem_malloc(alloc_size);
|
|
|
|
if (!history->entry[i])
|
|
goto exit;
|
|
}
|
|
|
|
qdf_atomic_init(&history->index);
|
|
history->allocated = 1;
|
|
history->num_entries_per_slot = max_entries_per_slot;
|
|
|
|
return QDF_STATUS_SUCCESS;
|
|
exit:
|
|
for (i = i - 1; i >= 0; i--) {
|
|
if (attempt_prealloc)
|
|
dp_context_free_mem(soc, ctxt_type, history->entry[i]);
|
|
else
|
|
qdf_mem_free(history->entry[i]);
|
|
}
|
|
|
|
return QDF_STATUS_E_NOMEM;
|
|
}
|
|
|
|
static inline
|
|
void dp_soc_frag_history_detach(struct dp_soc *soc,
|
|
void *history_hdl, uint32_t max_slots,
|
|
bool attempt_prealloc,
|
|
enum dp_ctxt_type ctxt_type)
|
|
{
|
|
struct dp_frag_history_opaque_atomic *history =
|
|
(struct dp_frag_history_opaque_atomic *)history_hdl;
|
|
int i;
|
|
|
|
for (i = 0; i < max_slots; i++) {
|
|
if (attempt_prealloc)
|
|
dp_context_free_mem(soc, ctxt_type, history->entry[i]);
|
|
else
|
|
qdf_mem_free(history->entry[i]);
|
|
}
|
|
|
|
history->allocated = 0;
|
|
}
|
|
|
|
/**
|
|
* dp_get_frag_hist_next_atomic_idx() - get the next entry index to record an
|
|
* entry in a fragmented history with
|
|
* index being atomic.
|
|
* @curr_idx: address of the current index where the last entry was written
|
|
* @next_idx: pointer to update the next index
|
|
* @slot: pointer to update the history slot to be selected
|
|
* @slot_shift: BITwise shift mask for slot (in index)
|
|
* @max_entries_per_slot: Max number of entries in a slot of history
|
|
* @max_entries: Total number of entries in the history (sum of all slots)
|
|
*
|
|
* This function assumes that the "max_entries_per_slot" and "max_entries"
|
|
* are a power-of-2.
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void
|
|
dp_get_frag_hist_next_atomic_idx(qdf_atomic_t *curr_idx, uint32_t *next_idx,
|
|
uint16_t *slot, uint32_t slot_shift,
|
|
uint32_t max_entries_per_slot,
|
|
uint32_t max_entries)
|
|
{
|
|
uint32_t idx;
|
|
|
|
idx = qdf_do_div_rem(qdf_atomic_inc_return(curr_idx), max_entries);
|
|
|
|
*slot = idx >> slot_shift;
|
|
*next_idx = idx & (max_entries_per_slot - 1);
|
|
}
|
|
|
|
#ifdef FEATURE_RUNTIME_PM
|
|
/**
|
|
* dp_runtime_get() - Get dp runtime refcount
|
|
* @soc: Datapath soc handle
|
|
*
|
|
* Get dp runtime refcount by increment of an atomic variable, which can block
|
|
* dp runtime resume to wait to flush pending tx by runtime suspend.
|
|
*
|
|
* Return: Current refcount
|
|
*/
|
|
static inline int32_t dp_runtime_get(struct dp_soc *soc)
|
|
{
|
|
return qdf_atomic_inc_return(&soc->dp_runtime_refcount);
|
|
}
|
|
|
|
/**
|
|
* dp_runtime_put() - Return dp runtime refcount
|
|
* @soc: Datapath soc handle
|
|
*
|
|
* Return dp runtime refcount by decrement of an atomic variable, allow dp
|
|
* runtime resume finish.
|
|
*
|
|
* Return: Current refcount
|
|
*/
|
|
static inline int32_t dp_runtime_put(struct dp_soc *soc)
|
|
{
|
|
return qdf_atomic_dec_return(&soc->dp_runtime_refcount);
|
|
}
|
|
|
|
/**
|
|
* dp_runtime_get_refcount() - Get dp runtime refcount
|
|
* @soc: Datapath soc handle
|
|
*
|
|
* Get dp runtime refcount by returning an atomic variable
|
|
*
|
|
* Return: Current refcount
|
|
*/
|
|
static inline int32_t dp_runtime_get_refcount(struct dp_soc *soc)
|
|
{
|
|
return qdf_atomic_read(&soc->dp_runtime_refcount);
|
|
}
|
|
|
|
/**
|
|
* dp_runtime_init() - Init DP related runtime PM clients and runtime refcount
|
|
* @soc: Datapath soc handle
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
static inline void dp_runtime_init(struct dp_soc *soc)
|
|
{
|
|
hif_rtpm_register(HIF_RTPM_ID_DP, NULL);
|
|
hif_rtpm_register(HIF_RTPM_ID_DP_RING_STATS, NULL);
|
|
qdf_atomic_init(&soc->dp_runtime_refcount);
|
|
}
|
|
|
|
/**
|
|
* dp_runtime_deinit() - Deinit DP related runtime PM clients
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void dp_runtime_deinit(void)
|
|
{
|
|
hif_rtpm_deregister(HIF_RTPM_ID_DP);
|
|
hif_rtpm_deregister(HIF_RTPM_ID_DP_RING_STATS);
|
|
}
|
|
|
|
/**
|
|
* dp_runtime_pm_mark_last_busy() - Mark last busy when rx path in use
|
|
* @soc: Datapath soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc)
|
|
{
|
|
soc->rx_last_busy = qdf_get_log_timestamp_usecs();
|
|
|
|
hif_rtpm_mark_last_busy(HIF_RTPM_ID_DP);
|
|
}
|
|
#else
|
|
static inline int32_t dp_runtime_get(struct dp_soc *soc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline int32_t dp_runtime_put(struct dp_soc *soc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline QDF_STATUS dp_runtime_init(struct dp_soc *soc)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline void dp_runtime_deinit(void)
|
|
{
|
|
}
|
|
|
|
static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static inline enum QDF_GLOBAL_MODE dp_soc_get_con_mode(struct dp_soc *soc)
|
|
{
|
|
if (soc->cdp_soc.ol_ops->get_con_mode)
|
|
return soc->cdp_soc.ol_ops->get_con_mode();
|
|
|
|
return QDF_GLOBAL_MAX_MODE;
|
|
}
|
|
|
|
/**
|
|
* dp_pdev_bkp_stats_detach() - detach resources for back pressure stats
|
|
* processing
|
|
* @pdev: Datapath PDEV handle
|
|
*
|
|
*/
|
|
void dp_pdev_bkp_stats_detach(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_pdev_bkp_stats_attach() - attach resources for back pressure stats
|
|
* processing
|
|
* @pdev: Datapath PDEV handle
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_NOMEM: Error
|
|
*/
|
|
|
|
QDF_STATUS dp_pdev_bkp_stats_attach(struct dp_pdev *pdev);
|
|
|
|
/**
|
|
* dp_peer_flush_frags() - Flush all fragments for a particular
|
|
* peer
|
|
* @soc_hdl: data path soc handle
|
|
* @vdev_id: vdev id
|
|
* @peer_mac: peer mac address
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
uint8_t *peer_mac);
|
|
|
|
/**
|
|
* dp_soc_reset_mon_intr_mask() - reset mon intr mask
|
|
* @soc: pointer to dp_soc handle
|
|
*
|
|
* Return:
|
|
*/
|
|
void dp_soc_reset_mon_intr_mask(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_txrx_get_soc_stats() - will return cdp_soc_stats
|
|
* @soc_hdl: soc handle
|
|
* @soc_stats: buffer to hold the values
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS dp_txrx_get_soc_stats(struct cdp_soc_t *soc_hdl,
|
|
struct cdp_soc_stats *soc_stats);
|
|
|
|
/**
|
|
* dp_txrx_get_peer_delay_stats() - to get peer delay stats per TIDs
|
|
* @soc_hdl: soc handle
|
|
* @vdev_id: id of vdev handle
|
|
* @peer_mac: mac of DP_PEER handle
|
|
* @delay_stats: pointer to delay stats array
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_txrx_get_peer_delay_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
|
|
uint8_t *peer_mac,
|
|
struct cdp_delay_tid_stats *delay_stats);
|
|
|
|
/**
|
|
* dp_txrx_get_peer_jitter_stats() - to get peer jitter stats per TIDs
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of pdev handle
|
|
* @vdev_id: id of vdev handle
|
|
* @peer_mac: mac of DP_PEER handle
|
|
* @tid_stats: pointer to jitter stats array
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_txrx_get_peer_jitter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
uint8_t vdev_id, uint8_t *peer_mac,
|
|
struct cdp_peer_tid_stats *tid_stats);
|
|
|
|
/**
|
|
* dp_peer_get_tx_capture_stats() - to get peer Tx Capture stats
|
|
* @soc_hdl: soc handle
|
|
* @vdev_id: id of vdev handle
|
|
* @peer_mac: mac of DP_PEER handle
|
|
* @stats: pointer to peer tx capture stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_peer_get_tx_capture_stats(struct cdp_soc_t *soc_hdl,
|
|
uint8_t vdev_id, uint8_t *peer_mac,
|
|
struct cdp_peer_tx_capture_stats *stats);
|
|
|
|
/**
|
|
* dp_pdev_get_tx_capture_stats() - to get pdev Tx Capture stats
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of pdev handle
|
|
* @stats: pointer to pdev tx capture stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_pdev_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct cdp_pdev_tx_capture_stats *stats);
|
|
|
|
#ifdef HW_TX_DELAY_STATS_ENABLE
|
|
/**
|
|
* dp_is_vdev_tx_delay_stats_enabled(): Check if tx delay stats
|
|
* is enabled for vdev
|
|
* @vdev: dp vdev
|
|
*
|
|
* Return: true if tx delay stats is enabled for vdev else false
|
|
*/
|
|
static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev)
|
|
{
|
|
return vdev->hw_tx_delay_stats_enabled;
|
|
}
|
|
|
|
/**
|
|
* dp_pdev_print_tx_delay_stats(): Print vdev tx delay stats
|
|
* for pdev
|
|
* @soc: dp soc
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_pdev_print_tx_delay_stats(struct dp_soc *soc);
|
|
|
|
/**
|
|
* dp_pdev_clear_tx_delay_stats() - clear tx delay stats
|
|
* @soc: soc handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc);
|
|
#else
|
|
static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void dp_pdev_print_tx_delay_stats(struct dp_soc *soc)
|
|
{
|
|
}
|
|
|
|
static inline void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static inline void
|
|
dp_get_rx_hash_key_bytes(struct cdp_lro_hash_config *lro_hash)
|
|
{
|
|
qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv4,
|
|
(sizeof(lro_hash->toeplitz_hash_ipv4[0]) *
|
|
LRO_IPV4_SEED_ARR_SZ));
|
|
qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv6,
|
|
(sizeof(lro_hash->toeplitz_hash_ipv6[0]) *
|
|
LRO_IPV6_SEED_ARR_SZ));
|
|
}
|
|
|
|
#ifdef WLAN_CONFIG_TELEMETRY_AGENT
|
|
/**
|
|
* dp_get_pdev_telemetry_stats- API to get pdev telemetry stats
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of pdev handle
|
|
* @stats: pointer to pdev telemetry stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_get_pdev_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct cdp_pdev_telemetry_stats *stats);
|
|
|
|
/**
|
|
* dp_get_peer_telemetry_stats() - API to get peer telemetry stats
|
|
* @soc_hdl: soc handle
|
|
* @addr: peer mac
|
|
* @stats: pointer to peer telemetry stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_get_peer_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t *addr,
|
|
struct cdp_peer_telemetry_stats *stats);
|
|
|
|
/**
|
|
* dp_get_peer_deter_stats() - API to get peer deterministic stats
|
|
* @soc_hdl: soc handle
|
|
* @vdev_id: id of vdev handle
|
|
* @addr: peer mac
|
|
* @stats: pointer to peer deterministic stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_get_peer_deter_stats(struct cdp_soc_t *soc_hdl,
|
|
uint8_t vdev_id,
|
|
uint8_t *addr,
|
|
struct cdp_peer_deter_stats *stats);
|
|
|
|
/**
|
|
* dp_get_pdev_deter_stats() - API to get pdev deterministic stats
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of pdev handle
|
|
* @stats: pointer to pdev deterministic stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_get_pdev_deter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct cdp_pdev_deter_stats *stats);
|
|
|
|
/**
|
|
* dp_update_pdev_chan_util_stats() - API to update channel utilization stats
|
|
* @soc_hdl: soc handle
|
|
* @pdev_id: id of pdev handle
|
|
* @ch_util: Pointer to channel util stats
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS: Success
|
|
* QDF_STATUS_E_FAILURE: Error
|
|
*/
|
|
QDF_STATUS
|
|
dp_update_pdev_chan_util_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
|
|
struct cdp_pdev_chan_util_stats *ch_util);
|
|
#endif /* WLAN_CONFIG_TELEMETRY_AGENT */
|
|
|
|
#ifdef CONNECTIVITY_PKTLOG
|
|
/**
|
|
* dp_tx_send_pktlog() - send tx packet log
|
|
* @soc: soc handle
|
|
* @pdev: pdev handle
|
|
* @tx_desc: TX software descriptor
|
|
* @nbuf: nbuf
|
|
* @status: status of tx packet
|
|
*
|
|
* This function is used to send tx packet for logging
|
|
*
|
|
* Return: None
|
|
*
|
|
*/
|
|
static inline
|
|
void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
struct dp_tx_desc_s *tx_desc,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status)
|
|
{
|
|
ol_txrx_pktdump_cb packetdump_cb = pdev->dp_tx_packetdump_cb;
|
|
|
|
if (qdf_unlikely(packetdump_cb) &&
|
|
dp_tx_frm_std == tx_desc->frm_type) {
|
|
packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id,
|
|
tx_desc->vdev_id, nbuf, status, QDF_TX_DATA_PKT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_rx_send_pktlog() - send rx packet log
|
|
* @soc: soc handle
|
|
* @pdev: pdev handle
|
|
* @nbuf: nbuf
|
|
* @status: status of rx packet
|
|
*
|
|
* This function is used to send rx packet for logging
|
|
*
|
|
* Return: None
|
|
*
|
|
*/
|
|
static inline
|
|
void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status)
|
|
{
|
|
ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb;
|
|
|
|
if (qdf_unlikely(packetdump_cb)) {
|
|
packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id,
|
|
QDF_NBUF_CB_RX_VDEV_ID(nbuf),
|
|
nbuf, status, QDF_RX_DATA_PKT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_rx_err_send_pktlog() - send rx error packet log
|
|
* @soc: soc handle
|
|
* @pdev: pdev handle
|
|
* @mpdu_desc_info: MPDU descriptor info
|
|
* @nbuf: nbuf
|
|
* @status: status of rx packet
|
|
* @set_pktlen: weither to set packet length
|
|
*
|
|
* This API should only be called when we have not removed
|
|
* Rx TLV from head, and head is pointing to rx_tlv
|
|
*
|
|
* This function is used to send rx packet from error path
|
|
* for logging for which rx packet tlv is not removed.
|
|
*
|
|
* Return: None
|
|
*
|
|
*/
|
|
static inline
|
|
void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
struct hal_rx_mpdu_desc_info *mpdu_desc_info,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status,
|
|
bool set_pktlen)
|
|
{
|
|
ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb;
|
|
qdf_size_t skip_size;
|
|
uint16_t msdu_len, nbuf_len;
|
|
uint8_t *rx_tlv_hdr;
|
|
struct hal_rx_msdu_metadata msdu_metadata;
|
|
|
|
if (qdf_unlikely(packetdump_cb)) {
|
|
rx_tlv_hdr = qdf_nbuf_data(nbuf);
|
|
nbuf_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc,
|
|
rx_tlv_hdr);
|
|
hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr,
|
|
&msdu_metadata);
|
|
|
|
if (mpdu_desc_info->bar_frame ||
|
|
(mpdu_desc_info->mpdu_flags & HAL_MPDU_F_FRAGMENT))
|
|
skip_size = soc->rx_pkt_tlv_size;
|
|
else
|
|
skip_size = soc->rx_pkt_tlv_size +
|
|
msdu_metadata.l3_hdr_pad;
|
|
|
|
if (set_pktlen) {
|
|
msdu_len = nbuf_len + skip_size;
|
|
qdf_nbuf_set_pktlen(nbuf, qdf_min(msdu_len,
|
|
(uint16_t)RX_DATA_BUFFER_SIZE));
|
|
}
|
|
|
|
qdf_nbuf_pull_head(nbuf, skip_size);
|
|
packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id,
|
|
QDF_NBUF_CB_RX_VDEV_ID(nbuf),
|
|
nbuf, status, QDF_RX_DATA_PKT);
|
|
qdf_nbuf_push_head(nbuf, skip_size);
|
|
}
|
|
}
|
|
|
|
#else
|
|
static inline
|
|
void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
struct dp_tx_desc_s *tx_desc,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev,
|
|
struct hal_rx_mpdu_desc_info *mpdu_desc_info,
|
|
qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status,
|
|
bool set_pktlen)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* dp_pdev_update_fast_rx_flag() - Update Fast rx flag for a PDEV
|
|
* @soc : Data path soc handle
|
|
* @pdev : PDEV handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
|
|
#ifdef FEATURE_DIRECT_LINK
|
|
/**
|
|
* dp_setup_direct_link_refill_ring(): Setup direct link refill ring for pdev
|
|
* @soc_hdl: DP SOC handle
|
|
* @pdev_id: pdev id
|
|
*
|
|
* Return: Handle to SRNG
|
|
*/
|
|
struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl,
|
|
uint8_t pdev_id);
|
|
|
|
/**
|
|
* dp_destroy_direct_link_refill_ring(): Destroy direct link refill ring for
|
|
* pdev
|
|
* @soc_hdl: DP SOC handle
|
|
* @pdev_id: pdev id
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl,
|
|
uint8_t pdev_id);
|
|
#else
|
|
static inline
|
|
struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl,
|
|
uint8_t pdev_id)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline
|
|
void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl,
|
|
uint8_t pdev_id)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#ifdef WLAN_FEATURE_DP_CFG_EVENT_HISTORY
|
|
static inline
|
|
void dp_cfg_event_record(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
union dp_cfg_event_desc *cfg_event_desc)
|
|
{
|
|
struct dp_cfg_event_history *cfg_event_history =
|
|
&soc->cfg_event_history;
|
|
struct dp_cfg_event *entry;
|
|
uint32_t idx;
|
|
uint16_t slot;
|
|
|
|
dp_get_frag_hist_next_atomic_idx(&cfg_event_history->index, &idx,
|
|
&slot,
|
|
DP_CFG_EVT_HIST_SLOT_SHIFT,
|
|
DP_CFG_EVT_HIST_PER_SLOT_MAX,
|
|
DP_CFG_EVT_HISTORY_SIZE);
|
|
|
|
entry = &cfg_event_history->entry[slot][idx];
|
|
|
|
entry->timestamp = qdf_get_log_timestamp();
|
|
entry->type = event;
|
|
qdf_mem_copy(&entry->event_desc, cfg_event_desc,
|
|
sizeof(entry->event_desc));
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event,
|
|
struct dp_vdev *vdev)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_vdev_attach_detach_desc *vdev_evt =
|
|
&cfg_evt_desc.vdev_evt;
|
|
|
|
if (qdf_unlikely(event != DP_CFG_EVENT_VDEV_ATTACH &&
|
|
event != DP_CFG_EVENT_VDEV_UNREF_DEL &&
|
|
event != DP_CFG_EVENT_VDEV_DETACH)) {
|
|
qdf_assert_always(0);
|
|
return;
|
|
}
|
|
|
|
vdev_evt->vdev = vdev;
|
|
vdev_evt->vdev_id = vdev->vdev_id;
|
|
vdev_evt->ref_count = qdf_atomic_read(&vdev->ref_cnt);
|
|
vdev_evt->mac_addr = vdev->mac_addr;
|
|
|
|
dp_cfg_event_record(soc, event, &cfg_evt_desc);
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event,
|
|
struct dp_peer *peer, struct dp_vdev *vdev,
|
|
uint8_t is_reuse)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_peer_cmn_ops_desc *peer_evt = &cfg_evt_desc.peer_cmn_evt;
|
|
|
|
if (qdf_unlikely(event != DP_CFG_EVENT_PEER_CREATE &&
|
|
event != DP_CFG_EVENT_PEER_DELETE &&
|
|
event != DP_CFG_EVENT_PEER_UNREF_DEL)) {
|
|
qdf_assert_always(0);
|
|
return;
|
|
}
|
|
|
|
peer_evt->peer = peer;
|
|
peer_evt->vdev = vdev;
|
|
peer_evt->vdev_id = vdev->vdev_id;
|
|
peer_evt->is_reuse = is_reuse;
|
|
peer_evt->peer_ref_count = qdf_atomic_read(&peer->ref_cnt);
|
|
peer_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt);
|
|
peer_evt->mac_addr = peer->mac_addr;
|
|
peer_evt->vdev_mac_addr = vdev->mac_addr;
|
|
|
|
dp_cfg_event_record(soc, event, &cfg_evt_desc);
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *mld_peer,
|
|
struct dp_peer *link_peer,
|
|
uint8_t idx, uint8_t result)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_mlo_add_del_link_desc *mlo_link_delink_evt =
|
|
&cfg_evt_desc.mlo_link_delink_evt;
|
|
|
|
if (qdf_unlikely(event != DP_CFG_EVENT_MLO_ADD_LINK &&
|
|
event != DP_CFG_EVENT_MLO_DEL_LINK)) {
|
|
qdf_assert_always(0);
|
|
return;
|
|
}
|
|
|
|
mlo_link_delink_evt->link_peer = link_peer;
|
|
mlo_link_delink_evt->mld_peer = mld_peer;
|
|
mlo_link_delink_evt->link_mac_addr = link_peer->mac_addr;
|
|
mlo_link_delink_evt->mld_mac_addr = mld_peer->mac_addr;
|
|
mlo_link_delink_evt->num_links = mld_peer->num_links;
|
|
mlo_link_delink_evt->action_result = result;
|
|
mlo_link_delink_evt->idx = idx;
|
|
|
|
dp_cfg_event_record(soc, event, &cfg_evt_desc);
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc,
|
|
struct dp_peer *mld_peer,
|
|
struct dp_vdev *prev_vdev,
|
|
struct dp_vdev *new_vdev)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_mlo_setup_vdev_update_desc *vdev_update_evt =
|
|
&cfg_evt_desc.mlo_setup_vdev_update;
|
|
|
|
vdev_update_evt->mld_peer = mld_peer;
|
|
vdev_update_evt->prev_vdev = prev_vdev;
|
|
vdev_update_evt->new_vdev = new_vdev;
|
|
|
|
dp_cfg_event_record(soc, DP_CFG_EVENT_MLO_SETUP_VDEV_UPDATE,
|
|
&cfg_evt_desc);
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *peer,
|
|
uint8_t *mac_addr,
|
|
uint8_t is_ml_peer,
|
|
uint16_t peer_id, uint16_t ml_peer_id,
|
|
uint16_t hw_peer_id, uint8_t vdev_id)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_rx_peer_map_unmap_desc *peer_map_unmap_evt =
|
|
&cfg_evt_desc.peer_map_unmap_evt;
|
|
|
|
if (qdf_unlikely(event != DP_CFG_EVENT_PEER_MAP &&
|
|
event != DP_CFG_EVENT_PEER_UNMAP &&
|
|
event != DP_CFG_EVENT_MLO_PEER_MAP &&
|
|
event != DP_CFG_EVENT_MLO_PEER_UNMAP)) {
|
|
qdf_assert_always(0);
|
|
return;
|
|
}
|
|
|
|
peer_map_unmap_evt->peer_id = peer_id;
|
|
peer_map_unmap_evt->ml_peer_id = ml_peer_id;
|
|
peer_map_unmap_evt->hw_peer_id = hw_peer_id;
|
|
peer_map_unmap_evt->vdev_id = vdev_id;
|
|
/* Peer may be NULL at times, but its not an issue. */
|
|
peer_map_unmap_evt->peer = peer;
|
|
peer_map_unmap_evt->is_ml_peer = is_ml_peer;
|
|
qdf_mem_copy(&peer_map_unmap_evt->mac_addr.raw, mac_addr,
|
|
QDF_MAC_ADDR_SIZE);
|
|
|
|
dp_cfg_event_record(soc, event, &cfg_evt_desc);
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *peer,
|
|
struct dp_vdev *vdev,
|
|
uint8_t vdev_id,
|
|
struct cdp_peer_setup_info *peer_setup_info)
|
|
{
|
|
union dp_cfg_event_desc cfg_evt_desc = {0};
|
|
struct dp_peer_setup_desc *peer_setup_evt =
|
|
&cfg_evt_desc.peer_setup_evt;
|
|
|
|
if (qdf_unlikely(event != DP_CFG_EVENT_PEER_SETUP &&
|
|
event != DP_CFG_EVENT_MLO_SETUP)) {
|
|
qdf_assert_always(0);
|
|
return;
|
|
}
|
|
|
|
peer_setup_evt->peer = peer;
|
|
peer_setup_evt->vdev = vdev;
|
|
if (vdev)
|
|
peer_setup_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt);
|
|
peer_setup_evt->mac_addr = peer->mac_addr;
|
|
peer_setup_evt->vdev_id = vdev_id;
|
|
if (peer_setup_info) {
|
|
peer_setup_evt->is_first_link = peer_setup_info->is_first_link;
|
|
peer_setup_evt->is_primary_link = peer_setup_info->is_primary_link;
|
|
qdf_mem_copy(peer_setup_evt->mld_mac_addr.raw,
|
|
peer_setup_info->mld_peer_mac,
|
|
QDF_MAC_ADDR_SIZE);
|
|
}
|
|
|
|
dp_cfg_event_record(soc, event, &cfg_evt_desc);
|
|
}
|
|
#else
|
|
|
|
static inline void
|
|
dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event,
|
|
struct dp_vdev *vdev)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event,
|
|
struct dp_peer *peer, struct dp_vdev *vdev,
|
|
uint8_t is_reuse)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *mld_peer,
|
|
struct dp_peer *link_peer,
|
|
uint8_t idx, uint8_t result)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc,
|
|
struct dp_peer *mld_peer,
|
|
struct dp_vdev *prev_vdev,
|
|
struct dp_vdev *new_vdev)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *peer,
|
|
uint8_t *mac_addr,
|
|
uint8_t is_ml_peer,
|
|
uint16_t peer_id, uint16_t ml_peer_id,
|
|
uint16_t hw_peer_id, uint8_t vdev_id)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc,
|
|
enum dp_cfg_event_type event,
|
|
struct dp_peer *peer,
|
|
struct dp_vdev *vdev,
|
|
uint8_t vdev_id,
|
|
struct cdp_peer_setup_info *peer_setup_info)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#ifndef WLAN_SOFTUMAC_SUPPORT
|
|
/**
|
|
* dp_soc_interrupt_detach() - Deregister any allocations done for interrupts
|
|
* @txrx_soc: DP SOC handle
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_soc_interrupt_detach(struct cdp_soc_t *txrx_soc);
|
|
#endif
|
|
|
|
/**
|
|
* dp_get_peer_stats()- Get peer stats
|
|
* @peer: Datapath peer
|
|
* @peer_stats: buffer for peer stats
|
|
*
|
|
* Return: none
|
|
*/
|
|
void dp_get_peer_stats(struct dp_peer *peer,
|
|
struct cdp_peer_stats *peer_stats);
|
|
|
|
/**
|
|
* dp_get_per_link_peer_stats()- Get per link peer stats
|
|
* @peer: Datapath peer
|
|
* @peer_stats: buffer for peer stats
|
|
* @peer_type: Peer type
|
|
* @num_link: Number of ML links
|
|
*
|
|
* Return: status success/failure
|
|
*/
|
|
QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer,
|
|
struct cdp_peer_stats *peer_stats,
|
|
enum cdp_peer_type peer_type,
|
|
uint8_t num_link);
|
|
/**
|
|
* dp_get_peer_hw_link_id() - get peer hardware link id
|
|
* @soc: soc handle
|
|
* @pdev: data path pdev
|
|
*
|
|
* Return: link_id
|
|
*/
|
|
static inline int
|
|
dp_get_peer_hw_link_id(struct dp_soc *soc,
|
|
struct dp_pdev *pdev)
|
|
{
|
|
if (wlan_cfg_is_peer_link_stats_enabled(soc->wlan_cfg_ctx))
|
|
return ((soc->arch_ops.get_hw_link_id(pdev)) + 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef QCA_MULTIPASS_SUPPORT
|
|
/**
|
|
* dp_tx_remove_vlan_tag() - Remove 4 bytes of vlan tag
|
|
* @vdev: DP vdev handle
|
|
* @nbuf: network buffer
|
|
*
|
|
* Return: void
|
|
*/
|
|
void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf);
|
|
#endif
|
|
|
|
/**
|
|
* dp_print_per_link_stats() - Print per link peer stats.
|
|
* @soc_hdl: soc handle.
|
|
* @vdev_id: vdev_id.
|
|
*
|
|
* Return: None.
|
|
*/
|
|
void dp_print_per_link_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id);
|
|
|
|
/**
|
|
* dp_get_ring_stats_from_hal(): get hal level ring pointer values
|
|
* @soc: DP_SOC handle
|
|
* @srng: DP_SRNG handle
|
|
* @ring_type: srng src/dst ring
|
|
* @_tailp: pointer to tail of ring
|
|
* @_headp: pointer to head of ring
|
|
* @_hw_headp: pointer to head of ring in HW
|
|
* @_hw_tailp: pointer to tail of ring in HW
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline void
|
|
dp_get_ring_stats_from_hal(struct dp_soc *soc, struct dp_srng *srng,
|
|
enum hal_ring_type ring_type,
|
|
uint32_t *_tailp, uint32_t *_headp,
|
|
int32_t *_hw_headp, int32_t *_hw_tailp)
|
|
{
|
|
uint32_t tailp;
|
|
uint32_t headp;
|
|
int32_t hw_headp = -1;
|
|
int32_t hw_tailp = -1;
|
|
struct hal_soc *hal_soc;
|
|
|
|
if (soc && srng && srng->hal_srng) {
|
|
hal_soc = (struct hal_soc *)soc->hal_soc;
|
|
hal_get_sw_hptp(soc->hal_soc, srng->hal_srng, &tailp, &headp);
|
|
*_headp = headp;
|
|
*_tailp = tailp;
|
|
|
|
hal_get_hw_hptp(soc->hal_soc, srng->hal_srng, &hw_headp,
|
|
&hw_tailp, ring_type);
|
|
*_hw_headp = hw_headp;
|
|
*_hw_tailp = hw_tailp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* dp_update_vdev_be_basic_stats() - Update vdev basic stats
|
|
* @txrx_peer: DP txrx_peer handle
|
|
* @tgtobj: Pointer to buffer for be vdev stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_be_basic_stats(struct dp_txrx_peer *txrx_peer,
|
|
struct dp_vdev_stats *tgtobj);
|
|
|
|
/**
|
|
* dp_update_vdev_basic_stats() - Update vdev basic stats
|
|
* @txrx_peer: DP txrx_peer handle
|
|
* @tgtobj: Pointer to buffer for vdev stats
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_update_vdev_basic_stats(struct dp_txrx_peer *txrx_peer,
|
|
struct cdp_vdev_stats *tgtobj);
|
|
|
|
/**
|
|
* dp_get_vdev_stats_for_unmap_peer_legacy() - Update vdev basic stats
|
|
* @vdev: vdev associated with the peer
|
|
* @peer: unmapped peer
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_get_vdev_stats_for_unmap_peer_legacy(struct dp_vdev *vdev,
|
|
struct dp_peer *peer);
|
|
|
|
#ifdef WLAN_FEATURE_TX_LATENCY_STATS
|
|
/**
|
|
* dp_h2t_tx_latency_stats_cfg_msg_send(): send HTT message for tx latency
|
|
* stats config to FW
|
|
* @dp_soc: DP SOC handle
|
|
* @vdev_id: vdev id
|
|
* @enable: indicates enablement of the feature
|
|
* @period: statistical period for transmit latency in terms of ms
|
|
* @granularity: granularity for tx latency distribution
|
|
*
|
|
* return: QDF STATUS
|
|
*/
|
|
QDF_STATUS
|
|
dp_h2t_tx_latency_stats_cfg_msg_send(struct dp_soc *dp_soc, uint16_t vdev_id,
|
|
bool enable, uint32_t period,
|
|
uint32_t granularity);
|
|
|
|
/**
|
|
* dp_tx_latency_stats_update_cca() - update transmit latency statistics for
|
|
* CCA
|
|
* @soc: dp soc handle
|
|
* @peer_id: peer id
|
|
* @granularity: granularity of distribution
|
|
* @distribution: distribution of transmit latency statistics
|
|
* @avg: average of CCA latency(in microseconds) within a cycle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void
|
|
dp_tx_latency_stats_update_cca(struct dp_soc *soc, uint16_t peer_id,
|
|
uint32_t granularity, uint32_t *distribution,
|
|
uint32_t avg);
|
|
|
|
/**
|
|
* dp_tx_latency_stats_report() - report transmit latency statistics for each
|
|
* vdev of specified pdev
|
|
* @soc: dp soc handle
|
|
* @pdev: dp pdev Handle
|
|
*
|
|
* Return: None
|
|
*/
|
|
void dp_tx_latency_stats_report(struct dp_soc *soc, struct dp_pdev *pdev);
|
|
#endif
|
|
#ifdef WLAN_FEATURE_SSR_DRIVER_DUMP
|
|
/**
|
|
* dp_ssr_dump_srng_register() - Register DP ring with SSR dump.
|
|
* @region_name: ring name to register.
|
|
* @srng: dp srng handler.
|
|
* @num: Ring number
|
|
*
|
|
* num = -1. If there is only single ring
|
|
* num = ring number. If there are multiple rings pass ring number.
|
|
* e.g. in case of REO pass reo number (0..n).
|
|
*
|
|
* Return: None.
|
|
*/
|
|
void
|
|
dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num);
|
|
|
|
/**
|
|
* dp_ssr_dump_srng_unregister() - Unegister DP ring with SSR dump.
|
|
* @region_name: ring name to unregister.
|
|
* @num: Ring number
|
|
*
|
|
* num = -1. If there is only single ring
|
|
* num = ring number. If there are multiple rings pass ring number.
|
|
* e.g. in case of REO pass reo number (0..n).
|
|
*
|
|
* Return: None.
|
|
*/
|
|
void dp_ssr_dump_srng_unregister(char *region_name, int num);
|
|
|
|
/**
|
|
* dp_ssr_dump_pdev_register() - Register DP Pdev with SSR dump.
|
|
* @pdev: Pdev handle to register.
|
|
* @pdev_id: Pdev ID.
|
|
*
|
|
* Return: None.
|
|
*/
|
|
void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id);
|
|
|
|
/**
|
|
* dp_ssr_dump_pdev_unregister() - Unregister DP Pdev with SSR dump.
|
|
* @pdev_id: Pdev ID.
|
|
*
|
|
* Return: None.
|
|
*/
|
|
void dp_ssr_dump_pdev_unregister(uint8_t pdev_id);
|
|
#else
|
|
static inline
|
|
void dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_ssr_dump_srng_unregister(char *region_name, int num)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void dp_ssr_dump_pdev_unregister(uint8_t pdev_id)
|
|
{
|
|
}
|
|
#endif
|
|
#endif /* #ifndef _DP_INTERNAL_H_ */
|