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

qcacmn: Move get_peer_info into cp_stats component

Browse Source 
Move WMI_REQUEST_PEER_STATS_INFO_CMDID related statistics into
cp_stats component.

Change-Id: Ie57f64e4ee195de30271260887c48ecf76f4a2ff
CRs-Fixed: 2680626
This commit is contained in:
Min Liu
2020-05-06 20:56:51 +08:00
committed by snandini
parent 697ceba7e1
commit 44150359c9
11 changed files with 744 additions and 903 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
os_if/linux/cp_stats/inc/wlan_cfg80211_mc_cp_stats.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011-2019 The Linux Foundation. All rights reserved. * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the * any purpose with or without fee is hereby granted, provided that the
@@ -105,6 +105,22 @@ void wlan_cfg80211_mc_cp_stats_free_stats_event(struct stats_event *info);
struct stats_event * struct stats_event *
wlan_cfg80211_mc_cp_stats_get_peer_rssi(struct wlan_objmgr_vdev *vdev, wlan_cfg80211_mc_cp_stats_get_peer_rssi(struct wlan_objmgr_vdev *vdev,
uint8_t *macaddress, int *errno); uint8_t *macaddress, int *errno);
/**
* wlan_cfg80211_mc_cp_stats_get_peer_stats() - API to get peer
* statistics from firmware
* @vdev: Pointer to vdev
* @mac_addr: mac address
* @errno: error type in case of failure
*
* Call of this API must call wlan_cfg80211_mc_cp_stats_free_stats_event
* API when done with information provided by info.
* Return: stats buffer on success, Null on failure
*/
struct stats_event *
wlan_cfg80211_mc_cp_stats_get_peer_stats(struct wlan_objmgr_vdev *vdev,
const uint8_t *mac_addr,
int *errno);
#else #else
static inline int wlan_cfg80211_mc_cp_stats_get_tx_power( static inline int wlan_cfg80211_mc_cp_stats_get_tx_power(
struct wlan_objmgr_vdev *vdev, struct wlan_objmgr_vdev *vdev,
@@ -137,5 +153,13 @@ wlan_cfg80211_mc_cp_stats_get_station_stats(struct wlan_objmgr_vdev *vdev,
{ {
return NULL; return NULL;
} }
static inline struct stats_event *
wlan_cfg80211_mc_cp_stats_get_peer_stats(struct wlan_objmgr_vdev *vdev,
const uint8_t *mac_addr,
int *errno)
{
return NULL;
}
#endif /* QCA_SUPPORT_CP_STATS */ #endif /* QCA_SUPPORT_CP_STATS */
#endif /* __WLAN_CFG80211_MC_CP_STATS_H__ */ #endif /* __WLAN_CFG80211_MC_CP_STATS_H__ */

6
umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h
View File

@@ -114,6 +114,10 @@ typedef struct wake_lock_stats stats_wake_lock;
* control plane statistics component * control plane statistics component
* @cp_stats_attach: function pointer to register events from FW * @cp_stats_attach: function pointer to register events from FW
* @cp_stats_detach: function pointer to unregister events from FW * @cp_stats_detach: function pointer to unregister events from FW
* @inc_wake_lock_stats: function pointer to increase wake lock stats
* @send_req_stats: function pointer to send request stats command to FW
* @send_req_peer_stats: function pointer to send request peer stats command
* to FW
*/ */
struct wlan_lmac_if_cp_stats_tx_ops { struct wlan_lmac_if_cp_stats_tx_ops {
QDF_STATUS (*cp_stats_attach)(struct wlan_objmgr_psoc *psoc); QDF_STATUS (*cp_stats_attach)(struct wlan_objmgr_psoc *psoc);
@@ -124,6 +128,8 @@ struct wlan_lmac_if_cp_stats_tx_ops {
QDF_STATUS (*send_req_stats)(struct wlan_objmgr_psoc *psoc, QDF_STATUS (*send_req_stats)(struct wlan_objmgr_psoc *psoc,
enum stats_req_type type, enum stats_req_type type,
stats_req_info *req); stats_req_info *req);
QDF_STATUS (*send_req_peer_stats)(struct wlan_objmgr_psoc *psoc,
stats_req_info *req);
}; };
/** /**

126
wmi/inc/wmi_unified_api.h
View File

@@ -113,6 +113,8 @@
#include "wlan_iot_sim_public_structs.h" #include "wlan_iot_sim_public_structs.h"
#endif #endif
#include "wmi_unified_cp_stats_api.h"
typedef qdf_nbuf_t wmi_buf_t; typedef qdf_nbuf_t wmi_buf_t;
#define wmi_buf_data(_buf) qdf_nbuf_data(_buf) #define wmi_buf_data(_buf) qdf_nbuf_data(_buf)
@@ -333,6 +335,22 @@ static inline int wmi_process_qmi_fw_event(void *wmi_cb_ctx, void *buf, int len)
} }
#endif #endif
/**
* wmi_unified_cmd_send_pm_chk() - send unified WMI command with PM check,
* if target is in suspended state, WMI command will be sent over QMI.
* @wmi_handle: handle to WMI.
* @buf: wmi command buffer
* @buflen: wmi command buffer length
* @cmd_id: WMI cmd id
*
* Note, it is NOT safe to access buf after calling this function!
*
* Return: QDF_STATUS
*/
QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
wmi_buf_t buf, uint32_t buflen,
uint32_t cmd_id);
/** /**
* wmi_unified_register_event() - WMI event handler * wmi_unified_register_event() - WMI event handler
* registration function for converged components * registration function for converged components
@@ -832,10 +850,6 @@ wmi_set_peer_param_send(wmi_unified_t wmi_handle,
QDF_STATUS wmi_unified_peer_create_send(wmi_unified_t wmi_handle, QDF_STATUS wmi_unified_peer_create_send(wmi_unified_t wmi_handle,
struct peer_create_params *param); struct peer_create_params *param);
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param);
/** /**
* wmi_unified_green_ap_ps_send() - enable green ap powersave command * wmi_unified_green_ap_ps_send() - enable green ap powersave command
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -2961,31 +2975,6 @@ QDF_STATUS
wmi_extract_profile_data(wmi_unified_t wmi_handle, void *evt_buf, uint8_t idx, wmi_extract_profile_data(wmi_unified_t wmi_handle, void *evt_buf, uint8_t idx,
wmi_host_wlan_profile_t *profile_data); wmi_host_wlan_profile_t *profile_data);
/**
* wmi_extract_stats_param() - extract all stats count from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @stats_param: Pointer to hold stats count
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param);
/**
* wmi_extract_pdev_stats() - extract pdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into pdev stats
* @pdev_stats: Pointer to hold pdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats);
/** /**
* extract_unit_test() - extract unit test from event * extract_unit_test() - extract unit test from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -3013,32 +3002,6 @@ wmi_extract_pdev_ext_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, uint32_t index,
wmi_host_pdev_ext_stats *pdev_ext_stats); wmi_host_pdev_ext_stats *pdev_ext_stats);
/**
* wmi_extract_peer_extd_stats() - extract extended peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into extended peer stats
* @peer_extd_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats);
/**
* wmi_extract_peer_adv_stats() - extract advance (extd2) peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @peer_adv_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_peer_adv_stats(
wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_peer_adv_stats *peer_adv_stats);
/** /**
* wmi_extract_bss_chan_info_event() - extract bss channel information * wmi_extract_bss_chan_info_event() - extract bss channel information
* from event * from event
@@ -3052,19 +3015,6 @@ QDF_STATUS wmi_extract_bss_chan_info_event(
wmi_unified_t wmi_handle, void *evt_buf, wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_pdev_bss_chan_info_event *bss_chan_info); wmi_host_pdev_bss_chan_info_event *bss_chan_info);
/**
* wmi_extract_peer_stats() - extract peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into peer stats
* @peer_stats: Pointer to hold peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats);
/** /**
* wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control * wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control
* from event * from event
@@ -3078,46 +3028,6 @@ QDF_STATUS
wmi_extract_tx_data_traffic_ctrl_ev(wmi_unified_t wmi_handle, void *evt_buf, wmi_extract_tx_data_traffic_ctrl_ev(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_tx_data_traffic_ctrl_event *ev); wmi_host_tx_data_traffic_ctrl_event *ev);
/**
* wmi_extract_vdev_stats() - extract vdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into vdev stats
* @vdev_stats: Pointer to hold vdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats);
/**
* wmi_extract_per_chain_rssi_stats() - extract rssi stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into rssi stats
* @rssi_stats: Pointer to hold rssi stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_per_chain_rssi_stats(
wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
struct wmi_host_per_chain_rssi_stats *rssi_stats);
#ifdef WLAN_FEATURE_MIB_STATS
/**
* wmi_extract_mib_stats() - extract mib stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @mib_stats: pointer to hold mib stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_mib_stats(wmi_unified_t wmi_handle, void *evt_buf,
struct mib_stats_metrics *mib_stats);
#endif
/** /**
* wmi_extract_vdev_extd_stats() - extract extended vdev stats from event * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle

103
wmi/inc/wmi_unified_cp_stats_api.h Normal file
View File

@@ -0,0 +1,103 @@
/*
* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to cp stats component.
*/
#ifndef _WMI_UNIFIED_CP_STATS_API_H_
#define _WMI_UNIFIED_CP_STATS_API_H_
#ifdef QCA_SUPPORT_MC_CP_STATS
#include <wmi_unified_mc_cp_stats_api.h>
#endif
/**
* wmi_unified_stats_request_send() - WMI request stats function
* @wmi_handle: handle to WMI
* @macaddr: MAC address
* @param: pointer to hold stats request parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param);
/**
* wmi_extract_stats_param() - extract all stats count from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @stats_param: Pointer to hold stats count
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param);
/**
* wmi_extract_pdev_stats() - extract pdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into pdev stats
* @pdev_stats: Pointer to hold pdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats);
/**
* wmi_extract_vdev_stats() - extract vdev stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into vdev stats
* @vdev_stats: Pointer to hold vdev stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats);
/**
* wmi_extract_peer_stats() - extract peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into peer stats
* @peer_stats: Pointer to hold peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats);
/**
* wmi_extract_peer_extd_stats() - extract extended peer stats from event
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into extended peer stats
* @peer_extd_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats);
#endif /* _WMI_UNIFIED_CP_STATS_API_H_ */

2
wmi/inc/wmi_unified_param.h
View File

@@ -3869,6 +3869,7 @@ struct rx_reorder_queue_remove_params {
* @num_peer_adv_stats: number of peer adv stats * @num_peer_adv_stats: number of peer adv stats
* @num_mib_stats: number of mib stats * @num_mib_stats: number of mib stats
* @num_mib_extd_stats: number of extended mib stats * @num_mib_extd_stats: number of extended mib stats
* @num_peer_stats_info_ext: number of peer extended stats info
* @last_event: specify if the current event is the last event * @last_event: specify if the current event is the last event
*/ */
typedef struct { typedef struct {
@@ -3886,6 +3887,7 @@ typedef struct {
uint32_t num_peer_adv_stats; uint32_t num_peer_adv_stats;
uint32_t num_mib_stats; uint32_t num_mib_stats;
uint32_t num_mib_extd_stats; uint32_t num_mib_extd_stats;
uint32_t num_peer_stats_info_ext;
uint32_t last_event; uint32_t last_event;
} wmi_host_stats_event; } wmi_host_stats_event;

29
wmi/inc/wmi_unified_priv.h
View File

@@ -463,6 +463,11 @@ QDF_STATUS (*send_stats_request_cmd)(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE], uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param); struct stats_request_params *param);
#ifdef QCA_SUPPORT_MC_CP_STATS
QDF_STATUS (*send_request_peer_stats_info_cmd)(wmi_unified_t wmi_handle,
struct peer_stats_request_params *param);
#endif /* QCA_SUPPORT_MC_CP_STATS */
QDF_STATUS (*send_packet_log_enable_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_packet_log_enable_cmd)(wmi_unified_t wmi_handle,
WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id); WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id);
@@ -1789,6 +1794,14 @@ QDF_STATUS (*extract_vdev_nac_rssi_stats)(wmi_unified_t wmi_handle, void *evt_bu
QDF_STATUS (*extract_bcn_stats)(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS (*extract_bcn_stats)(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_bcn_stats *bcn_stats); uint32_t index, wmi_host_bcn_stats *bcn_stats);
#ifdef QCA_SUPPORT_MC_CP_STATS
QDF_STATUS (*extract_peer_stats_count)(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param);
QDF_STATUS (*extract_peer_stats_info)(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats_info *peer_stats_info);
#endif /* QCA_SUPPORT_MC_CP_STATS */
#ifdef OL_ATH_SMART_LOGGING #ifdef OL_ATH_SMART_LOGGING
QDF_STATUS (*extract_smartlog_event)(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS (*extract_smartlog_event)(wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_debug_fatal_events *event); struct wmi_debug_fatal_events *event);
@@ -2940,4 +2953,20 @@ static inline void wmi_cfr_attach_tlv(struct wmi_unified *wmi_handle)
{ {
} }
#endif #endif
#ifdef QCA_SUPPORT_CP_STATS
void wmi_cp_stats_attach_tlv(struct wmi_unified *wmi_handle);
#else
static inline void wmi_cp_stats_attach_tlv(struct wmi_unified *wmi_handle)
{
}
#endif /* QCA_SUPPORT_CP_STATS */
#ifdef QCA_SUPPORT_MC_CP_STATS
void wmi_mc_cp_stats_attach_tlv(struct wmi_unified *wmi_handle);
#else
static inline void wmi_mc_cp_stats_attach_tlv(struct wmi_unified *wmi_handle)
{
}
#endif /* QCA_SUPPORT_MC_CP_STATS */
#endif #endif

1
wmi/src/wmi_unified.c
View File

@@ -3123,6 +3123,7 @@ bool wmi_is_target_suspended(struct wmi_unified *wmi_handle)
{ {
return qdf_atomic_read(&wmi_handle->is_target_suspended); return qdf_atomic_read(&wmi_handle->is_target_suspended);
} }
qdf_export_symbol(wmi_is_target_suspended);
#ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI #ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI
void wmi_set_qmi_stats(wmi_unified_t wmi_handle, bool val) void wmi_set_qmi_stats(wmi_unified_t wmi_handle, bool val)

111
wmi/src/wmi_unified_api.c
View File

@@ -411,25 +411,6 @@ QDF_STATUS wmi_unified_sifs_trigger_send(wmi_unified_t wmi_handle,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
/**
* wmi_unified_stats_request_send() - WMI request stats function
* @param wmi_handle : handle to WMI.
* @param macaddr : MAC address
* @param param : pointer to hold stats request parameter
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param)
{
if (wmi_handle->ops->send_stats_request_cmd)
return wmi_handle->ops->send_stats_request_cmd(wmi_handle,
macaddr, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS QDF_STATUS
wmi_unified_packet_log_enable_send(wmi_unified_t wmi_handle, wmi_unified_packet_log_enable_send(wmi_unified_t wmi_handle,
WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT,
@@ -2123,28 +2104,6 @@ wmi_extract_composite_phyerr(wmi_unified_t wmi_handle, void *evt_buf,
} }
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param)
{
if (wmi_handle->ops->extract_all_stats_count)
return wmi_handle->ops->extract_all_stats_count(wmi_handle,
evt_buf, stats_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats)
{
if (wmi_handle->ops->extract_pdev_stats)
return wmi_handle->ops->extract_pdev_stats(wmi_handle,
evt_buf, index, pdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS QDF_STATUS
wmi_extract_unit_test(wmi_unified_t wmi_handle, void *evt_buf, wmi_extract_unit_test(wmi_unified_t wmi_handle, void *evt_buf,
wmi_unit_test_event *unit_test, uint32_t maxspace) wmi_unit_test_event *unit_test, uint32_t maxspace)
@@ -2168,40 +2127,6 @@ wmi_extract_pdev_ext_stats(wmi_unified_t wmi_handle, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats)
{
if (wmi_handle->ops->extract_peer_stats)
return wmi_handle->ops->extract_peer_stats(wmi_handle,
evt_buf, index, peer_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats)
{
if (wmi_handle->ops->extract_vdev_stats)
return wmi_handle->ops->extract_vdev_stats(wmi_handle,
evt_buf, index, vdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_per_chain_rssi_stats(
wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
struct wmi_host_per_chain_rssi_stats *rssi_stats)
{
if (wmi_handle->ops->extract_per_chain_rssi_stats)
return wmi_handle->ops->extract_per_chain_rssi_stats(wmi_handle,
evt_buf, index, rssi_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_rtt_hdr(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS wmi_extract_rtt_hdr(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_rtt_event_hdr *ev) wmi_host_rtt_event_hdr *ev)
{ {
@@ -2234,18 +2159,6 @@ QDF_STATUS wmi_extract_rtt_ev(wmi_unified_t wmi_handle, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats)
{
if (wmi_handle->ops->extract_peer_extd_stats)
return wmi_handle->ops->extract_peer_extd_stats(wmi_handle,
evt_buf, index, peer_extd_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS wmi_extract_peer_retry_stats( QDF_STATUS wmi_extract_peer_retry_stats(
wmi_unified_t wmi_handle, void *evt_buf, wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, struct wmi_host_peer_retry_stats *peer_retry_stats) uint32_t index, struct wmi_host_peer_retry_stats *peer_retry_stats)
@@ -2257,17 +2170,6 @@ QDF_STATUS wmi_extract_peer_retry_stats(
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
QDF_STATUS wmi_extract_peer_adv_stats(
wmi_unified_t wmi_handle, void *evt_buf,
struct wmi_host_peer_adv_stats *peer_adv_stats)
{
if (wmi_handle->ops->extract_peer_adv_stats)
return wmi_handle->ops->extract_peer_adv_stats(wmi_handle,
evt_buf, peer_adv_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS QDF_STATUS
wmi_extract_rtt_error_report_ev(wmi_unified_t wmi_handle, void *evt_buf, wmi_extract_rtt_error_report_ev(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_rtt_error_report_event *ev) wmi_host_rtt_error_report_event *ev)
@@ -2290,19 +2192,6 @@ wmi_extract_chan_stats(wmi_unified_t wmi_handle, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
#ifdef WLAN_FEATURE_MIB_STATS
QDF_STATUS wmi_extract_mib_stats(wmi_unified_t wmi_handle, void *evt_buf,
struct mib_stats_metrics *mib_stats)
{
if (wmi_handle->ops->extract_mib_stats)
return wmi_handle->ops->extract_mib_stats(wmi_handle,
evt_buf,
mib_stats);
return QDF_STATUS_E_FAILURE;
}
#endif
QDF_STATUS wmi_extract_thermal_stats(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS wmi_extract_thermal_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t *temp, uint32_t *level, uint32_t *temp, uint32_t *level,
uint32_t *pdev_id) uint32_t *pdev_id)

89
wmi/src/wmi_unified_cp_stats_api.c Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* DOC: Implement API's specific to cp stats component.
*/
#include "wmi_unified_priv.h"
#include "wmi_unified_param.h"
#include "wmi_unified_cp_stats_api.h"
QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param)
{
if (wmi_handle->ops->send_stats_request_cmd)
return wmi_handle->ops->send_stats_request_cmd(wmi_handle,
macaddr, param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_stats_param(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param)
{
if (wmi_handle->ops->extract_all_stats_count)
return wmi_handle->ops->extract_all_stats_count(wmi_handle,
evt_buf, stats_param);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_pdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_pdev_stats *pdev_stats)
{
if (wmi_handle->ops->extract_pdev_stats)
return wmi_handle->ops->extract_pdev_stats(wmi_handle,
evt_buf, index, pdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_vdev_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats)
{
if (wmi_handle->ops->extract_vdev_stats)
return wmi_handle->ops->extract_vdev_stats(wmi_handle,
evt_buf, index, vdev_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_peer_stats *peer_stats)
{
if (wmi_handle->ops->extract_peer_stats)
return wmi_handle->ops->extract_peer_stats(wmi_handle,
evt_buf, index, peer_stats);
return QDF_STATUS_E_FAILURE;
}
QDF_STATUS
wmi_extract_peer_extd_stats(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats)
{
if (wmi_handle->ops->extract_peer_extd_stats)
return wmi_handle->ops->extract_peer_extd_stats(wmi_handle,
evt_buf, index, peer_extd_stats);
return QDF_STATUS_E_FAILURE;
}

466
wmi/src/wmi_unified_cp_stats_tlv.c Normal file
View File

@@ -0,0 +1,466 @@
/*
* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "osdep.h"
#include "wmi.h"
#include "wmi_unified_priv.h"
#include "wmi_unified_param.h"
/**
* send_stats_request_cmd_tlv() - WMI request stats function
* @param wmi_handle: handle to WMI.
* @param macaddr: MAC address
* @param param: pointer to hold stats request parameter
*
* Return: 0 on success and -ve on failure.
*/
static QDF_STATUS
send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param)
{
int32_t ret;
wmi_request_stats_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint16_t len = sizeof(wmi_request_stats_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return QDF_STATUS_E_NOMEM;
cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_request_stats_cmd_fixed_param));
cmd->stats_id = param->stats_id;
cmd->vdev_id = param->vdev_id;
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
param->pdev_id);
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
WMI_LOGD("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
cmd->stats_id, cmd->vdev_id, cmd->pdev_id);
wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send_pm_chk(wmi_handle, buf, len,
WMI_REQUEST_STATS_CMDID);
if (ret) {
WMI_LOGE("Failed to send status request to fw =%d", ret);
wmi_buf_free(buf);
}
return qdf_status_from_os_return(ret);
}
/**
* extract_all_stats_counts_tlv() - extract all stats count from event
* @param wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param stats_param: Pointer to hold stats count
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_all_stats_counts_tlv(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_stats_event *stats_param)
{
wmi_stats_event_fixed_param *ev;
wmi_per_chain_rssi_stats *rssi_event;
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
uint64_t min_data_len;
qdf_mem_zero(stats_param, sizeof(*stats_param));
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
rssi_event = param_buf->chain_stats;
if (!ev) {
WMI_LOGE("%s: event fixed param NULL", __func__);
return QDF_STATUS_E_FAILURE;
}
if (param_buf->num_data > WMI_SVC_MSG_MAX_SIZE - sizeof(*ev)) {
WMI_LOGE("num_data : %u is invalid", param_buf->num_data);
return QDF_STATUS_E_FAULT;
}
switch (ev->stats_id) {
case WMI_REQUEST_PEER_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PEER_STAT;
break;
case WMI_REQUEST_AP_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_AP_STAT;
break;
case WMI_REQUEST_PDEV_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PDEV_STAT;
break;
case WMI_REQUEST_VDEV_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_STAT;
break;
case WMI_REQUEST_BCNFLT_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_BCNFLT_STAT;
break;
case WMI_REQUEST_VDEV_RATE_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_RATE_STAT;
break;
case WMI_REQUEST_BCN_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_BCN_STAT;
break;
case WMI_REQUEST_PEER_EXTD_STAT:
stats_param->stats_id |= WMI_REQUEST_PEER_EXTD_STAT;
break;
case WMI_REQUEST_PEER_EXTD2_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PEER_ADV_STATS;
break;
default:
stats_param->stats_id = 0;
break;
}
/* ev->num_*_stats may cause uint32_t overflow, so use uint64_t
* to save total length calculated
*/
min_data_len =
(((uint64_t)ev->num_pdev_stats) * sizeof(wmi_pdev_stats)) +
(((uint64_t)ev->num_vdev_stats) * sizeof(wmi_vdev_stats)) +
(((uint64_t)ev->num_peer_stats) * sizeof(wmi_peer_stats)) +
(((uint64_t)ev->num_bcnflt_stats) *
sizeof(wmi_bcnfilter_stats_t)) +
(((uint64_t)ev->num_chan_stats) * sizeof(wmi_chan_stats)) +
(((uint64_t)ev->num_mib_stats) * sizeof(wmi_mib_stats)) +
(((uint64_t)ev->num_bcn_stats) * sizeof(wmi_bcn_stats)) +
(((uint64_t)ev->num_peer_extd_stats) *
sizeof(wmi_peer_extd_stats)) +
(((uint64_t)ev->num_mib_extd_stats) *
sizeof(wmi_mib_extd_stats));
if (param_buf->num_data != min_data_len) {
WMI_LOGE("data len: %u isn't same as calculated: %llu",
param_buf->num_data, min_data_len);
return QDF_STATUS_E_FAULT;
}
stats_param->last_event = ev->last_event;
stats_param->num_pdev_stats = ev->num_pdev_stats;
stats_param->num_pdev_ext_stats = 0;
stats_param->num_vdev_stats = ev->num_vdev_stats;
stats_param->num_peer_stats = ev->num_peer_stats;
stats_param->num_peer_extd_stats = ev->num_peer_extd_stats;
stats_param->num_bcnflt_stats = ev->num_bcnflt_stats;
stats_param->num_chan_stats = ev->num_chan_stats;
stats_param->num_mib_stats = ev->num_mib_stats;
stats_param->num_mib_extd_stats = ev->num_mib_extd_stats;
stats_param->num_bcn_stats = ev->num_bcn_stats;
stats_param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
wmi_handle,
ev->pdev_id);
/* if chain_stats is not populated */
if (!param_buf->chain_stats || !param_buf->num_chain_stats)
return QDF_STATUS_SUCCESS;
if (WMITLV_TAG_STRUC_wmi_per_chain_rssi_stats !=
WMITLV_GET_TLVTAG(rssi_event->tlv_header))
return QDF_STATUS_SUCCESS;
if (WMITLV_GET_STRUCT_TLVLEN(wmi_per_chain_rssi_stats) !=
WMITLV_GET_TLVLEN(rssi_event->tlv_header))
return QDF_STATUS_SUCCESS;
if (rssi_event->num_per_chain_rssi_stats >=
WMITLV_GET_TLVLEN(rssi_event->tlv_header)) {
WMI_LOGE("num_per_chain_rssi_stats:%u is out of bounds",
rssi_event->num_per_chain_rssi_stats);
return QDF_STATUS_E_INVAL;
}
stats_param->num_rssi_stats = rssi_event->num_per_chain_rssi_stats;
/* if peer_adv_stats is not populated */
if (!param_buf->num_peer_extd2_stats)
return QDF_STATUS_SUCCESS;
stats_param->num_peer_adv_stats = param_buf->num_peer_extd2_stats;
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_tx_stats() - extract pdev tx stats from event
*/
static void extract_pdev_tx_stats(wmi_host_dbg_tx_stats *tx,
struct wlan_dbg_tx_stats *tx_stats)
{
/* Tx Stats */
tx->comp_queued = tx_stats->comp_queued;
tx->comp_delivered = tx_stats->comp_delivered;
tx->msdu_enqued = tx_stats->msdu_enqued;
tx->mpdu_enqued = tx_stats->mpdu_enqued;
tx->wmm_drop = tx_stats->wmm_drop;
tx->local_enqued = tx_stats->local_enqued;
tx->local_freed = tx_stats->local_freed;
tx->hw_queued = tx_stats->hw_queued;
tx->hw_reaped = tx_stats->hw_reaped;
tx->underrun = tx_stats->underrun;
tx->tx_abort = tx_stats->tx_abort;
tx->mpdus_requed = tx_stats->mpdus_requed;
tx->data_rc = tx_stats->data_rc;
tx->self_triggers = tx_stats->self_triggers;
tx->sw_retry_failure = tx_stats->sw_retry_failure;
tx->illgl_rate_phy_err = tx_stats->illgl_rate_phy_err;
tx->pdev_cont_xretry = tx_stats->pdev_cont_xretry;
tx->pdev_tx_timeout = tx_stats->pdev_tx_timeout;
tx->pdev_resets = tx_stats->pdev_resets;
tx->stateless_tid_alloc_failure = tx_stats->stateless_tid_alloc_failure;
tx->phy_underrun = tx_stats->phy_underrun;
tx->txop_ovf = tx_stats->txop_ovf;
return;
}
/**
* extract_pdev_rx_stats() - extract pdev rx stats from event
*/
static void extract_pdev_rx_stats(wmi_host_dbg_rx_stats *rx,
struct wlan_dbg_rx_stats *rx_stats)
{
/* Rx Stats */
rx->mid_ppdu_route_change = rx_stats->mid_ppdu_route_change;
rx->status_rcvd = rx_stats->status_rcvd;
rx->r0_frags = rx_stats->r0_frags;
rx->r1_frags = rx_stats->r1_frags;
rx->r2_frags = rx_stats->r2_frags;
/* Only TLV */
rx->r3_frags = 0;
rx->htt_msdus = rx_stats->htt_msdus;
rx->htt_mpdus = rx_stats->htt_mpdus;
rx->loc_msdus = rx_stats->loc_msdus;
rx->loc_mpdus = rx_stats->loc_mpdus;
rx->oversize_amsdu = rx_stats->oversize_amsdu;
rx->phy_errs = rx_stats->phy_errs;
rx->phy_err_drop = rx_stats->phy_err_drop;
rx->mpdu_errs = rx_stats->mpdu_errs;
return;
}
/**
* extract_pdev_stats_tlv() - extract pdev stats from event
* @param wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into pdev stats
* @param pdev_stats: Pointer to hold pdev stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_pdev_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, uint32_t index,
wmi_host_pdev_stats *pdev_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = param_buf->data;
if (index < ev_param->num_pdev_stats) {
wmi_pdev_stats *ev = (wmi_pdev_stats *) ((data) +
(index * sizeof(wmi_pdev_stats)));
pdev_stats->chan_nf = ev->chan_nf;
pdev_stats->tx_frame_count = ev->tx_frame_count;
pdev_stats->rx_frame_count = ev->rx_frame_count;
pdev_stats->rx_clear_count = ev->rx_clear_count;
pdev_stats->cycle_count = ev->cycle_count;
pdev_stats->phy_err_count = ev->phy_err_count;
pdev_stats->chan_tx_pwr = ev->chan_tx_pwr;
extract_pdev_tx_stats(&(pdev_stats->pdev_stats.tx),
&(ev->pdev_stats.tx));
extract_pdev_rx_stats(&(pdev_stats->pdev_stats.rx),
&(ev->pdev_stats.rx));
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_vdev_stats_tlv() - extract vdev stats from event
* @param wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into vdev stats
* @param vdev_stats: Pointer to hold vdev stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_vdev_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index, wmi_host_vdev_stats *vdev_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = (uint8_t *) param_buf->data;
if (index < ev_param->num_vdev_stats) {
wmi_vdev_stats *ev = (wmi_vdev_stats *) ((data) +
((ev_param->num_pdev_stats) *
sizeof(wmi_pdev_stats)) +
(index * sizeof(wmi_vdev_stats)));
vdev_stats->vdev_id = ev->vdev_id;
vdev_stats->vdev_snr.bcn_snr = ev->vdev_snr.bcn_snr;
vdev_stats->vdev_snr.dat_snr = ev->vdev_snr.dat_snr;
OS_MEMCPY(vdev_stats->tx_frm_cnt, ev->tx_frm_cnt,
sizeof(ev->tx_frm_cnt));
vdev_stats->rx_frm_cnt = ev->rx_frm_cnt;
OS_MEMCPY(vdev_stats->multiple_retry_cnt,
ev->multiple_retry_cnt,
sizeof(ev->multiple_retry_cnt));
OS_MEMCPY(vdev_stats->fail_cnt, ev->fail_cnt,
sizeof(ev->fail_cnt));
vdev_stats->rts_fail_cnt = ev->rts_fail_cnt;
vdev_stats->rts_succ_cnt = ev->rts_succ_cnt;
vdev_stats->rx_err_cnt = ev->rx_err_cnt;
vdev_stats->rx_discard_cnt = ev->rx_discard_cnt;
vdev_stats->ack_fail_cnt = ev->ack_fail_cnt;
OS_MEMCPY(vdev_stats->tx_rate_history, ev->tx_rate_history,
sizeof(ev->tx_rate_history));
OS_MEMCPY(vdev_stats->bcn_rssi_history, ev->bcn_rssi_history,
sizeof(ev->bcn_rssi_history));
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_stats_tlv() - extract peer stats from event
* @param wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into peer stats
* @param peer_stats: Pointer to hold peer stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_peer_stats_tlv(wmi_unified_t wmi_handle, void *evt_buf, uint32_t index,
wmi_host_peer_stats *peer_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = (uint8_t *) param_buf->data;
if (index < ev_param->num_peer_stats) {
wmi_peer_stats *ev = (wmi_peer_stats *) ((data) +
((ev_param->num_pdev_stats) * sizeof(wmi_pdev_stats)) +
((ev_param->num_vdev_stats) * sizeof(wmi_vdev_stats)) +
(index * sizeof(wmi_peer_stats)));
OS_MEMSET(peer_stats, 0, sizeof(wmi_host_peer_stats));
OS_MEMCPY(&(peer_stats->peer_macaddr),
&(ev->peer_macaddr), sizeof(wmi_mac_addr));
peer_stats->peer_rssi = ev->peer_rssi;
peer_stats->peer_tx_rate = ev->peer_tx_rate;
peer_stats->peer_rx_rate = ev->peer_rx_rate;
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_extd_stats_tlv() - extract extended peer stats from event
* @param wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into extended peer stats
* @param peer_extd_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS
extract_peer_extd_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf;
ev_param = (wmi_stats_event_fixed_param *)param_buf->fixed_param;
data = (uint8_t *)param_buf->data;
if (!data)
return QDF_STATUS_E_FAILURE;
if (index < ev_param->num_peer_extd_stats) {
wmi_peer_extd_stats *ev = (wmi_peer_extd_stats *) (data +
(ev_param->num_pdev_stats * sizeof(wmi_pdev_stats)) +
(ev_param->num_vdev_stats * sizeof(wmi_vdev_stats)) +
(ev_param->num_peer_stats * sizeof(wmi_peer_stats)) +
(ev_param->num_bcnflt_stats *
sizeof(wmi_bcnfilter_stats_t)) +
(ev_param->num_chan_stats * sizeof(wmi_chan_stats)) +
(ev_param->num_mib_stats * sizeof(wmi_mib_stats)) +
(ev_param->num_bcn_stats * sizeof(wmi_bcn_stats)) +
(index * sizeof(wmi_peer_extd_stats)));
qdf_mem_zero(peer_extd_stats, sizeof(wmi_host_peer_extd_stats));
qdf_mem_copy(&peer_extd_stats->peer_macaddr, &ev->peer_macaddr,
sizeof(wmi_mac_addr));
peer_extd_stats->rx_mc_bc_cnt = ev->rx_mc_bc_cnt;
}
return QDF_STATUS_SUCCESS;
}
void wmi_cp_stats_attach_tlv(wmi_unified_t wmi_handle)
{
struct wmi_ops *ops = wmi_handle->ops;
ops->send_stats_request_cmd = send_stats_request_cmd_tlv;
ops->extract_all_stats_count = extract_all_stats_counts_tlv;
ops->extract_pdev_stats = extract_pdev_stats_tlv;
ops->extract_vdev_stats = extract_vdev_stats_tlv;
ops->extract_peer_stats = extract_peer_stats_tlv;
ops->extract_peer_extd_stats = extract_peer_extd_stats_tlv;
wmi_mc_cp_stats_attach_tlv(wmi_handle);
}

688
wmi/src/wmi_unified_tlv.c
View File

@@ -703,10 +703,9 @@ void wmi_mtrace(uint32_t message_id, uint16_t vdev_id, uint32_t data)
} }
qdf_export_symbol(wmi_mtrace); qdf_export_symbol(wmi_mtrace);
#ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
static QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle, wmi_buf_t buf,
wmi_buf_t buf, uint32_t buflen, uint32_t cmd_id)
uint32_t buflen, uint32_t cmd_id)
{ {
if (!wmi_is_qmi_stats_enabled(wmi_handle)) if (!wmi_is_qmi_stats_enabled(wmi_handle))
goto send_over_wmi; goto send_over_wmi;
@@ -714,7 +713,7 @@ static QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
if (wmi_is_target_suspended(wmi_handle)) { if (wmi_is_target_suspended(wmi_handle)) {
if (QDF_IS_STATUS_SUCCESS( if (QDF_IS_STATUS_SUCCESS(
wmi_unified_cmd_send_over_qmi(wmi_handle, buf, wmi_unified_cmd_send_over_qmi(wmi_handle, buf,
buflen, cmd_id))) buflen, cmd_id)))
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
@@ -723,15 +722,6 @@ send_over_wmi:
return wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id); return wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id);
} }
#else
static inline
QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
wmi_buf_t buf,
uint32_t buflen, uint32_t cmd_id)
{
return wmi_unified_cmd_send(wmi_handle, buf, buflen, cmd_id);
}
#endif
/** /**
* send_vdev_create_cmd_tlv() - send VDEV create command to fw * send_vdev_create_cmd_tlv() - send VDEV create command to fw
@@ -2122,55 +2112,6 @@ static QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
return ret; return ret;
} }
/**
* send_stats_request_cmd_tlv() - WMI request stats function
* @param wmi_handle : handle to WMI.
* @param macaddr : MAC address
* @param param : pointer to hold stats request parameter
*
* Return: 0 on success and -ve on failure.
*/
static QDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
uint8_t macaddr[QDF_MAC_ADDR_SIZE],
struct stats_request_params *param)
{
int32_t ret;
wmi_request_stats_cmd_fixed_param *cmd;
wmi_buf_t buf;
uint16_t len = sizeof(wmi_request_stats_cmd_fixed_param);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf)
return -QDF_STATUS_E_NOMEM;
cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
WMITLV_SET_HDR(&cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_request_stats_cmd_fixed_param));
cmd->stats_id = param->stats_id;
cmd->vdev_id = param->vdev_id;
cmd->pdev_id = wmi_handle->ops->convert_pdev_id_host_to_target(
wmi_handle,
param->pdev_id);
WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
WMI_LOGD("STATS REQ STATS_ID:%d VDEV_ID:%d PDEV_ID:%d-->",
cmd->stats_id, cmd->vdev_id, cmd->pdev_id);
wmi_mtrace(WMI_REQUEST_STATS_CMDID, cmd->vdev_id, 0);
ret = wmi_unified_cmd_send_pm_chk(wmi_handle, buf, len,
WMI_REQUEST_STATS_CMDID);
if (ret) {
WMI_LOGE("Failed to send status request to fw =%d", ret);
wmi_buf_free(buf);
}
return ret;
}
/** /**
* send_peer_based_pktlog_cmd() - Send WMI command to enable packet-log * send_peer_based_pktlog_cmd() - Send WMI command to enable packet-log
* @wmi_handle: handle to WMI. * @wmi_handle: handle to WMI.
@@ -10134,246 +10075,6 @@ static QDF_STATUS extract_nlo_complete_ev_param_tlv(wmi_unified_t wmi_handle,
} }
#endif #endif
/**
* extract_all_stats_counts_tlv() - extract all stats count from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param stats_param: Pointer to hold stats count
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_all_stats_counts_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_stats_event *stats_param)
{
wmi_stats_event_fixed_param *ev;
wmi_per_chain_rssi_stats *rssi_event;
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
uint64_t min_data_len;
qdf_mem_zero(stats_param, sizeof(*stats_param));
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
rssi_event = param_buf->chain_stats;
if (!ev) {
WMI_LOGE("%s: event fixed param NULL", __func__);
return QDF_STATUS_E_FAILURE;
}
if (param_buf->num_data > WMI_SVC_MSG_MAX_SIZE - sizeof(*ev)) {
WMI_LOGE("num_data : %u is invalid", param_buf->num_data);
return QDF_STATUS_E_FAULT;
}
switch (ev->stats_id) {
case WMI_REQUEST_PEER_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PEER_STAT;
break;
case WMI_REQUEST_AP_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_AP_STAT;
break;
case WMI_REQUEST_PDEV_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PDEV_STAT;
break;
case WMI_REQUEST_VDEV_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_STAT;
break;
case WMI_REQUEST_BCNFLT_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_BCNFLT_STAT;
break;
case WMI_REQUEST_VDEV_RATE_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_RATE_STAT;
break;
case WMI_REQUEST_BCN_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_BCN_STAT;
break;
case WMI_REQUEST_PEER_EXTD_STAT:
stats_param->stats_id |= WMI_REQUEST_PEER_EXTD_STAT;
break;
case WMI_REQUEST_PEER_EXTD2_STAT:
stats_param->stats_id |= WMI_HOST_REQUEST_PEER_ADV_STATS;
break;
default:
stats_param->stats_id = 0;
break;
}
/* ev->num_*_stats may cause uint32_t overflow, so use uint64_t
* to save total length calculated
*/
min_data_len =
(((uint64_t)ev->num_pdev_stats) * sizeof(wmi_pdev_stats)) +
(((uint64_t)ev->num_vdev_stats) * sizeof(wmi_vdev_stats)) +
(((uint64_t)ev->num_peer_stats) * sizeof(wmi_peer_stats)) +
(((uint64_t)ev->num_bcnflt_stats) *
sizeof(wmi_bcnfilter_stats_t)) +
(((uint64_t)ev->num_chan_stats) * sizeof(wmi_chan_stats)) +
(((uint64_t)ev->num_mib_stats) * sizeof(wmi_mib_stats)) +
(((uint64_t)ev->num_bcn_stats) * sizeof(wmi_bcn_stats)) +
(((uint64_t)ev->num_peer_extd_stats) *
sizeof(wmi_peer_extd_stats)) +
(((uint64_t)ev->num_mib_extd_stats) *
sizeof(wmi_mib_extd_stats));
if (param_buf->num_data != min_data_len) {
WMI_LOGE("data len: %u isn't same as calculated: %llu",
param_buf->num_data, min_data_len);
return QDF_STATUS_E_FAULT;
}
stats_param->last_event = ev->last_event;
stats_param->num_pdev_stats = ev->num_pdev_stats;
stats_param->num_pdev_ext_stats = 0;
stats_param->num_vdev_stats = ev->num_vdev_stats;
stats_param->num_peer_stats = ev->num_peer_stats;
stats_param->num_peer_extd_stats = ev->num_peer_extd_stats;
stats_param->num_bcnflt_stats = ev->num_bcnflt_stats;
stats_param->num_chan_stats = ev->num_chan_stats;
stats_param->num_mib_stats = ev->num_mib_stats;
stats_param->num_mib_extd_stats = ev->num_mib_extd_stats;
stats_param->num_bcn_stats = ev->num_bcn_stats;
stats_param->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
wmi_handle,
ev->pdev_id);
/* if chain_stats is not populated */
if (!param_buf->chain_stats || !param_buf->num_chain_stats)
return QDF_STATUS_SUCCESS;
if (WMITLV_TAG_STRUC_wmi_per_chain_rssi_stats !=
WMITLV_GET_TLVTAG(rssi_event->tlv_header))
return QDF_STATUS_SUCCESS;
if (WMITLV_GET_STRUCT_TLVLEN(wmi_per_chain_rssi_stats) !=
WMITLV_GET_TLVLEN(rssi_event->tlv_header))
return QDF_STATUS_SUCCESS;
if (rssi_event->num_per_chain_rssi_stats >=
WMITLV_GET_TLVLEN(rssi_event->tlv_header)) {
WMI_LOGE("num_per_chain_rssi_stats:%u is out of bounds",
rssi_event->num_per_chain_rssi_stats);
return QDF_STATUS_E_INVAL;
}
stats_param->num_rssi_stats = rssi_event->num_per_chain_rssi_stats;
/* if peer_adv_stats is not populated */
if (!param_buf->num_peer_extd2_stats)
return QDF_STATUS_SUCCESS;
stats_param->num_peer_adv_stats = param_buf->num_peer_extd2_stats;
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_tx_stats() - extract pdev tx stats from event
*/
static void extract_pdev_tx_stats(wmi_host_dbg_tx_stats *tx,
struct wlan_dbg_tx_stats *tx_stats)
{
/* Tx Stats */
tx->comp_queued = tx_stats->comp_queued;
tx->comp_delivered = tx_stats->comp_delivered;
tx->msdu_enqued = tx_stats->msdu_enqued;
tx->mpdu_enqued = tx_stats->mpdu_enqued;
tx->wmm_drop = tx_stats->wmm_drop;
tx->local_enqued = tx_stats->local_enqued;
tx->local_freed = tx_stats->local_freed;
tx->hw_queued = tx_stats->hw_queued;
tx->hw_reaped = tx_stats->hw_reaped;
tx->underrun = tx_stats->underrun;
tx->tx_abort = tx_stats->tx_abort;
tx->mpdus_requed = tx_stats->mpdus_requed;
tx->data_rc = tx_stats->data_rc;
tx->self_triggers = tx_stats->self_triggers;
tx->sw_retry_failure = tx_stats->sw_retry_failure;
tx->illgl_rate_phy_err = tx_stats->illgl_rate_phy_err;
tx->pdev_cont_xretry = tx_stats->pdev_cont_xretry;
tx->pdev_tx_timeout = tx_stats->pdev_tx_timeout;
tx->pdev_resets = tx_stats->pdev_resets;
tx->stateless_tid_alloc_failure = tx_stats->stateless_tid_alloc_failure;
tx->phy_underrun = tx_stats->phy_underrun;
tx->txop_ovf = tx_stats->txop_ovf;
return;
}
/**
* extract_pdev_rx_stats() - extract pdev rx stats from event
*/
static void extract_pdev_rx_stats(wmi_host_dbg_rx_stats *rx,
struct wlan_dbg_rx_stats *rx_stats)
{
/* Rx Stats */
rx->mid_ppdu_route_change = rx_stats->mid_ppdu_route_change;
rx->status_rcvd = rx_stats->status_rcvd;
rx->r0_frags = rx_stats->r0_frags;
rx->r1_frags = rx_stats->r1_frags;
rx->r2_frags = rx_stats->r2_frags;
/* Only TLV */
rx->r3_frags = 0;
rx->htt_msdus = rx_stats->htt_msdus;
rx->htt_mpdus = rx_stats->htt_mpdus;
rx->loc_msdus = rx_stats->loc_msdus;
rx->loc_mpdus = rx_stats->loc_mpdus;
rx->oversize_amsdu = rx_stats->oversize_amsdu;
rx->phy_errs = rx_stats->phy_errs;
rx->phy_err_drop = rx_stats->phy_err_drop;
rx->mpdu_errs = rx_stats->mpdu_errs;
return;
}
/**
* extract_pdev_stats_tlv() - extract pdev stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into pdev stats
* @param pdev_stats: Pointer to hold pdev stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_pdev_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index, wmi_host_pdev_stats *pdev_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = param_buf->data;
if (index < ev_param->num_pdev_stats) {
wmi_pdev_stats *ev = (wmi_pdev_stats *) ((data) +
(index * sizeof(wmi_pdev_stats)));
pdev_stats->chan_nf = ev->chan_nf;
pdev_stats->tx_frame_count = ev->tx_frame_count;
pdev_stats->rx_frame_count = ev->rx_frame_count;
pdev_stats->rx_clear_count = ev->rx_clear_count;
pdev_stats->cycle_count = ev->cycle_count;
pdev_stats->phy_err_count = ev->phy_err_count;
pdev_stats->chan_tx_pwr = ev->chan_tx_pwr;
extract_pdev_tx_stats(&(pdev_stats->pdev_stats.tx),
&(ev->pdev_stats.tx));
extract_pdev_rx_stats(&(pdev_stats->pdev_stats.rx),
&(ev->pdev_stats.rx));
}
return QDF_STATUS_SUCCESS;
}
/** /**
* extract_unit_test_tlv() - extract unit test data * extract_unit_test_tlv() - extract unit test data
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -10431,112 +10132,6 @@ static QDF_STATUS extract_pdev_ext_stats_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* extract_vdev_stats_tlv() - extract vdev stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into vdev stats
* @param vdev_stats: Pointer to hold vdev stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_vdev_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index, wmi_host_vdev_stats *vdev_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = (uint8_t *) param_buf->data;
if (index < ev_param->num_vdev_stats) {
wmi_vdev_stats *ev = (wmi_vdev_stats *) ((data) +
((ev_param->num_pdev_stats) *
sizeof(wmi_pdev_stats)) +
(index * sizeof(wmi_vdev_stats)));
vdev_stats->vdev_id = ev->vdev_id;
vdev_stats->vdev_snr.bcn_snr = ev->vdev_snr.bcn_snr;
vdev_stats->vdev_snr.dat_snr = ev->vdev_snr.dat_snr;
OS_MEMCPY(vdev_stats->tx_frm_cnt, ev->tx_frm_cnt,
sizeof(ev->tx_frm_cnt));
vdev_stats->rx_frm_cnt = ev->rx_frm_cnt;
OS_MEMCPY(vdev_stats->multiple_retry_cnt,
ev->multiple_retry_cnt,
sizeof(ev->multiple_retry_cnt));
OS_MEMCPY(vdev_stats->fail_cnt, ev->fail_cnt,
sizeof(ev->fail_cnt));
vdev_stats->rts_fail_cnt = ev->rts_fail_cnt;
vdev_stats->rts_succ_cnt = ev->rts_succ_cnt;
vdev_stats->rx_err_cnt = ev->rx_err_cnt;
vdev_stats->rx_discard_cnt = ev->rx_discard_cnt;
vdev_stats->ack_fail_cnt = ev->ack_fail_cnt;
OS_MEMCPY(vdev_stats->tx_rate_history, ev->tx_rate_history,
sizeof(ev->tx_rate_history));
OS_MEMCPY(vdev_stats->bcn_rssi_history, ev->bcn_rssi_history,
sizeof(ev->bcn_rssi_history));
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_per_chain_rssi_stats_tlv() - api to extract rssi stats from event
* buffer
* @wmi_handle: wmi handle
* @evt_buf: pointer to event buffer
* @index: Index into vdev stats
* @rssi_stats: Pointer to hold rssi stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_per_chain_rssi_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index,
struct wmi_host_per_chain_rssi_stats *rssi_stats)
{
uint8_t *data;
wmi_rssi_stats *fw_rssi_stats;
wmi_per_chain_rssi_stats *rssi_event;
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
if (!evt_buf) {
WMI_LOGE("evt_buf is null");
return QDF_STATUS_E_NULL_VALUE;
}
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
rssi_event = param_buf->chain_stats;
if (index >= rssi_event->num_per_chain_rssi_stats) {
WMI_LOGE("invalid index");
return QDF_STATUS_E_INVAL;
}
data = ((uint8_t *)(&rssi_event[1])) + WMI_TLV_HDR_SIZE;
fw_rssi_stats = &((wmi_rssi_stats *)data)[index];
if (fw_rssi_stats->vdev_id >= WLAN_UMAC_PDEV_MAX_VDEVS)
return QDF_STATUS_E_INVAL;
rssi_stats->vdev_id = fw_rssi_stats->vdev_id;
qdf_mem_copy(rssi_stats->rssi_avg_beacon,
fw_rssi_stats->rssi_avg_beacon,
sizeof(fw_rssi_stats->rssi_avg_beacon));
qdf_mem_copy(rssi_stats->rssi_avg_data,
fw_rssi_stats->rssi_avg_data,
sizeof(fw_rssi_stats->rssi_avg_data));
qdf_mem_copy(&rssi_stats->peer_macaddr,
&fw_rssi_stats->peer_macaddr,
sizeof(fw_rssi_stats->peer_macaddr));
return QDF_STATUS_SUCCESS;
}
/** /**
* extract_bcn_stats_tlv() - extract bcn stats from event * extract_bcn_stats_tlv() - extract bcn stats from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -10574,45 +10169,6 @@ static QDF_STATUS extract_bcn_stats_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* extract_peer_stats_tlv() - extract peer stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into peer stats
* @param peer_stats: Pointer to hold peer stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_peer_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index, wmi_host_peer_stats *peer_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *) evt_buf;
ev_param = (wmi_stats_event_fixed_param *) param_buf->fixed_param;
data = (uint8_t *) param_buf->data;
if (index < ev_param->num_peer_stats) {
wmi_peer_stats *ev = (wmi_peer_stats *) ((data) +
((ev_param->num_pdev_stats) * sizeof(wmi_pdev_stats)) +
((ev_param->num_vdev_stats) * sizeof(wmi_vdev_stats)) +
(index * sizeof(wmi_peer_stats)));
OS_MEMSET(peer_stats, 0, sizeof(wmi_host_peer_stats));
OS_MEMCPY(&(peer_stats->peer_macaddr),
&(ev->peer_macaddr), sizeof(wmi_mac_addr));
peer_stats->peer_rssi = ev->peer_rssi;
peer_stats->peer_tx_rate = ev->peer_tx_rate;
peer_stats->peer_rx_rate = ev->peer_rx_rate;
}
return QDF_STATUS_SUCCESS;
}
/** /**
* extract_bcnflt_stats_tlv() - extract bcn fault stats from event * extract_bcnflt_stats_tlv() - extract bcn fault stats from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -10628,92 +10184,6 @@ static QDF_STATUS extract_bcnflt_stats_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* extract_peer_adv_stats_tlv() - extract adv peer stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into extended peer stats
* @param peer_adv_stats: Pointer to hold adv peer stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_peer_adv_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct wmi_host_peer_adv_stats
*peer_adv_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_peer_extd2_stats *adv_stats;
int i;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf;
adv_stats = param_buf->peer_extd2_stats;
if (!adv_stats) {
WMI_LOGD("%s: no peer_adv stats in event buffer", __func__);
return QDF_STATUS_E_INVAL;
}
for (i = 0; i < param_buf->num_peer_extd2_stats; i++) {
WMI_MAC_ADDR_TO_CHAR_ARRAY(&adv_stats[i].peer_macaddr,
peer_adv_stats[i].peer_macaddr);
peer_adv_stats[i].fcs_count = adv_stats[i].rx_fcs_err;
peer_adv_stats[i].rx_bytes =
(uint64_t)adv_stats[i].rx_bytes_u32 <<
WMI_LOWER_BITS_SHIFT_32 |
adv_stats[i].rx_bytes_l32;
peer_adv_stats[i].rx_count = adv_stats[i].rx_mpdus;
}
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_extd_stats_tlv() - extract extended peer stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param index: Index into extended peer stats
* @param peer_extd_stats: Pointer to hold extended peer stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_peer_extd_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint32_t index,
wmi_host_peer_extd_stats *peer_extd_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf;
ev_param = (wmi_stats_event_fixed_param *)param_buf->fixed_param;
data = (uint8_t *)param_buf->data;
if (!data)
return QDF_STATUS_E_FAILURE;
if (index < ev_param->num_peer_extd_stats) {
wmi_peer_extd_stats *ev = (wmi_peer_extd_stats *) (data +
(ev_param->num_pdev_stats * sizeof(wmi_pdev_stats)) +
(ev_param->num_vdev_stats * sizeof(wmi_vdev_stats)) +
(ev_param->num_peer_stats * sizeof(wmi_peer_stats)) +
(ev_param->num_bcnflt_stats *
sizeof(wmi_bcnfilter_stats_t)) +
(ev_param->num_chan_stats * sizeof(wmi_chan_stats)) +
(ev_param->num_mib_stats * sizeof(wmi_mib_stats)) +
(ev_param->num_bcn_stats * sizeof(wmi_bcn_stats)) +
(index * sizeof(wmi_peer_extd_stats)));
qdf_mem_zero(peer_extd_stats, sizeof(wmi_host_peer_extd_stats));
qdf_mem_copy(&peer_extd_stats->peer_macaddr, &ev->peer_macaddr,
sizeof(wmi_mac_addr));
peer_extd_stats->rx_mc_bc_cnt = ev->rx_mc_bc_cnt;
}
return QDF_STATUS_SUCCESS;
}
/** /**
* extract_chan_stats_tlv() - extract chan stats from event * extract_chan_stats_tlv() - extract chan stats from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -10753,144 +10223,6 @@ static QDF_STATUS extract_chan_stats_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
#ifdef WLAN_FEATURE_MIB_STATS
/**
* extract_mib_stats_tlv() - extract mib stats from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param mib_stats: pointer to hold mib stats
*
* Return: QDF_STATUS_SUCCESS for success or error code
*/
static QDF_STATUS extract_mib_stats_tlv(wmi_unified_t wmi_handle,
void *evt_buf,
struct mib_stats_metrics
*mib_stats)
{
WMI_UPDATE_STATS_EVENTID_param_tlvs *param_buf;
wmi_stats_event_fixed_param *ev_param;
uint8_t *data;
wmi_mib_stats *ev;
wmi_mib_extd_stats *ev_extd;
param_buf = (WMI_UPDATE_STATS_EVENTID_param_tlvs *)evt_buf;
ev_param = (wmi_stats_event_fixed_param *)param_buf->fixed_param;
data = (uint8_t *)param_buf->data;
ev = (wmi_mib_stats *)(data +
ev_param->num_pdev_stats * sizeof(wmi_pdev_stats) +
ev_param->num_vdev_stats * sizeof(wmi_vdev_stats) +
ev_param->num_peer_stats * sizeof(wmi_peer_stats) +
ev_param->num_bcnflt_stats *
sizeof(wmi_bcnfilter_stats_t) +
ev_param->num_chan_stats * sizeof(wmi_chan_stats));
qdf_mem_zero(mib_stats, sizeof(*mib_stats));
mib_stats->mib_counters.tx_frags =
ev->tx_mpdu_grp_frag_cnt;
mib_stats->mib_counters.group_tx_frames =
ev->tx_msdu_grp_frm_cnt;
mib_stats->mib_counters.failed_cnt = ev->tx_msdu_fail_cnt;
mib_stats->mib_counters.rx_frags = ev->rx_mpdu_frag_cnt;
mib_stats->mib_counters.group_rx_frames =
ev->rx_msdu_grp_frm_cnt;
mib_stats->mib_counters.fcs_error_cnt =
ev->rx_mpdu_fcs_err;
mib_stats->mib_counters.tx_frames =
ev->tx_msdu_frm_cnt;
mib_stats->mib_mac_statistics.retry_cnt =
ev->tx_msdu_retry_cnt;
mib_stats->mib_mac_statistics.frame_dup_cnt =
ev->rx_frm_dup_cnt;
mib_stats->mib_mac_statistics.rts_success_cnt =
ev->tx_rts_success_cnt;
mib_stats->mib_mac_statistics.rts_fail_cnt =
ev->tx_rts_fail_cnt;
mib_stats->mib_qos_counters.qos_tx_frag_cnt =
ev->tx_Qos_mpdu_grp_frag_cnt;
mib_stats->mib_qos_counters.qos_retry_cnt =
ev->tx_Qos_msdu_retry_UP;
mib_stats->mib_qos_counters.qos_failed_cnt =
ev->tx_Qos_msdu_fail_UP;
mib_stats->mib_qos_counters.qos_frame_dup_cnt =
ev->rx_Qos_frm_dup_cnt_UP;
mib_stats->mib_qos_counters.qos_rts_success_cnt =
ev->tx_Qos_rts_success_cnt_UP;
mib_stats->mib_qos_counters.qos_rts_fail_cnt =
ev->tx_Qos_rts_fail_cnt_UP;
mib_stats->mib_qos_counters.qos_rx_frag_cnt =
ev->rx_Qos_mpdu_frag_cnt_UP;
mib_stats->mib_qos_counters.qos_tx_frame_cnt =
ev->tx_Qos_msdu_frm_cnt_UP;
mib_stats->mib_qos_counters.qos_discarded_frame_cnt =
ev->rx_Qos_msdu_discard_cnt_UP;
mib_stats->mib_qos_counters.qos_mpdu_rx_cnt =
ev->rx_Qos_mpdu_cnt;
mib_stats->mib_qos_counters.qos_retries_rx_cnt =
ev->rx_Qos_mpdu_retryBit_cnt;
mib_stats->mib_rsna_stats.tkip_icv_err =
ev->rsna_TKIP_icv_err_cnt;
mib_stats->mib_rsna_stats.tkip_replays =
ev->rsna_TKIP_replay_err_cnt;
mib_stats->mib_rsna_stats.ccmp_decrypt_err =
ev->rsna_CCMP_decrypt_err_cnt;
mib_stats->mib_rsna_stats.ccmp_replays =
ev->rsna_CCMP_replay_err_cnt;
mib_stats->mib_counters_group3.tx_ampdu_cnt =
ev->tx_ampdu_cnt;
mib_stats->mib_counters_group3.tx_mpdus_in_ampdu_cnt =
ev->tx_mpdu_cnt_in_ampdu;
mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt =
ev->tx_octets_in_ampdu.upload.high;
mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt =
mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt << 32;
mib_stats->mib_counters_group3.tx_octets_in_ampdu_cnt +=
ev->tx_octets_in_ampdu.upload.low;
mib_stats->mib_counters_group3.ampdu_rx_cnt =
ev->rx_ampdu_cnt;
mib_stats->mib_counters_group3.mpdu_in_rx_ampdu_cnt =
ev->rx_mpdu_cnt_in_ampdu;
mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt =
ev->rx_octets_in_ampdu.upload.rx_octets_in_ampdu_high;
mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt =
mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt << 32;
mib_stats->mib_counters_group3.rx_octets_in_ampdu_cnt +=
ev->rx_octets_in_ampdu.upload.rx_octets_in_ampdu_low;
if (ev_param->num_mib_extd_stats) {
ev_extd = (wmi_mib_extd_stats *)((uint8_t *)ev +
ev_param->num_mib_stats * sizeof(wmi_mib_stats) +
ev_param->num_bcn_stats * sizeof(wmi_bcn_stats) +
ev_param->num_peer_extd_stats *
sizeof(wmi_peer_extd_stats));
mib_stats->mib_mac_statistics.multi_retry_cnt =
ev_extd->tx_msdu_multi_retry_cnt;
mib_stats->mib_mac_statistics.tx_ack_fail_cnt =
ev_extd->tx_ack_fail_cnt;
mib_stats->mib_qos_counters.qos_multi_retry_cnt =
ev_extd->tx_qos_msdu_multi_retry_up;
mib_stats->mib_qos_counters.tx_qos_ack_fail_cnt_up =
ev_extd->tx_qos_ack_fail_cnt_up;
mib_stats->mib_rsna_stats.cmac_icv_err =
ev_extd->rsna_cmac_icv_err_cnt;
mib_stats->mib_rsna_stats.cmac_replays =
ev_extd->rsna_cmac_replay_err_cnt;
mib_stats->mib_counters_group3.rx_ampdu_deli_crc_err_cnt =
ev_extd->rx_ampdu_deli_crc_err_cnt;
}
return QDF_STATUS_SUCCESS;
}
#endif
/** /**
* extract_profile_ctx_tlv() - extract profile context from event * extract_profile_ctx_tlv() - extract profile context from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -14356,7 +13688,6 @@ struct wmi_ops tlv_ops = {
.send_dbglog_cmd = send_dbglog_cmd_tlv, .send_dbglog_cmd = send_dbglog_cmd_tlv,
#endif #endif
.send_vdev_set_param_cmd = send_vdev_set_param_cmd_tlv, .send_vdev_set_param_cmd = send_vdev_set_param_cmd_tlv,
.send_stats_request_cmd = send_stats_request_cmd_tlv,
.send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv, .send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv,
.send_peer_based_pktlog_cmd = send_peer_based_pktlog_cmd, .send_peer_based_pktlog_cmd = send_peer_based_pktlog_cmd,
.send_time_stamp_sync_cmd = send_time_stamp_sync_cmd_tlv, .send_time_stamp_sync_cmd = send_time_stamp_sync_cmd_tlv,
@@ -14503,21 +13834,11 @@ struct wmi_ops tlv_ops = {
.extract_nlo_match_ev_param = extract_nlo_match_ev_param_tlv, .extract_nlo_match_ev_param = extract_nlo_match_ev_param_tlv,
.extract_nlo_complete_ev_param = extract_nlo_complete_ev_param_tlv, .extract_nlo_complete_ev_param = extract_nlo_complete_ev_param_tlv,
#endif #endif
.extract_all_stats_count = extract_all_stats_counts_tlv,
.extract_pdev_stats = extract_pdev_stats_tlv,
.extract_unit_test = extract_unit_test_tlv, .extract_unit_test = extract_unit_test_tlv,
.extract_pdev_ext_stats = extract_pdev_ext_stats_tlv, .extract_pdev_ext_stats = extract_pdev_ext_stats_tlv,
.extract_vdev_stats = extract_vdev_stats_tlv,
.extract_per_chain_rssi_stats = extract_per_chain_rssi_stats_tlv,
.extract_peer_stats = extract_peer_stats_tlv,
.extract_bcn_stats = extract_bcn_stats_tlv, .extract_bcn_stats = extract_bcn_stats_tlv,
.extract_bcnflt_stats = extract_bcnflt_stats_tlv, .extract_bcnflt_stats = extract_bcnflt_stats_tlv,
.extract_peer_extd_stats = extract_peer_extd_stats_tlv,
.extract_peer_adv_stats = extract_peer_adv_stats_tlv,
.extract_chan_stats = extract_chan_stats_tlv, .extract_chan_stats = extract_chan_stats_tlv,
#ifdef WLAN_FEATURE_MIB_STATS
.extract_mib_stats = extract_mib_stats_tlv,
#endif
.extract_profile_ctx = extract_profile_ctx_tlv, .extract_profile_ctx = extract_profile_ctx_tlv,
.extract_profile_data = extract_profile_data_tlv, .extract_profile_data = extract_profile_data_tlv,
.send_fw_test_cmd = send_fw_test_cmd_tlv, .send_fw_test_cmd = send_fw_test_cmd_tlv,
@@ -15452,6 +14773,7 @@ void wmi_tlv_attach(wmi_unified_t wmi_handle)
wmi_fwol_attach_tlv(wmi_handle); wmi_fwol_attach_tlv(wmi_handle);
wmi_vdev_attach_tlv(wmi_handle); wmi_vdev_attach_tlv(wmi_handle);
wmi_cfr_attach_tlv(wmi_handle); wmi_cfr_attach_tlv(wmi_handle);
wmi_cp_stats_attach_tlv(wmi_handle);
} }
qdf_export_symbol(wmi_tlv_attach); qdf_export_symbol(wmi_tlv_attach);