qcacmn: Move get_peer_info into cp_stats component

Move WMI_REQUEST_PEER_STATS_INFO_CMDID related statistics into
cp_stats component.

Change-Id: Ie57f64e4ee195de30271260887c48ecf76f4a2ff
CRs-Fixed: 2680626

os_if/linux/cp_stats/inc/wlan_cfg80211_mc_cp_stats.h

@@ -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
  * 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 *
 wlan_cfg80211_mc_cp_stats_get_peer_rssi(struct wlan_objmgr_vdev *vdev,
 					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
 static inline int wlan_cfg80211_mc_cp_stats_get_tx_power(
 				struct wlan_objmgr_vdev *vdev,
@@ -137,5 +153,13 @@ wlan_cfg80211_mc_cp_stats_get_station_stats(struct wlan_objmgr_vdev *vdev,
 {
 	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 /* __WLAN_CFG80211_MC_CP_STATS_H__ */

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -114,6 +114,10 @@ typedef struct wake_lock_stats stats_wake_lock;
  * control plane statistics component
  * @cp_stats_attach:	function pointer to register 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 {
 	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,
 				     enum stats_req_type type,
 				     stats_req_info *req);
+	QDF_STATUS (*send_req_peer_stats)(struct wlan_objmgr_psoc *psoc,
+					  stats_req_info *req);
 };
 
 /**

wmi/inc/wmi_unified_api.h

@@ -113,6 +113,8 @@
 #include "wlan_iot_sim_public_structs.h"
 #endif
 
+#include "wmi_unified_cp_stats_api.h"
+
 typedef qdf_nbuf_t wmi_buf_t;
 #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
 
+/**
+ * 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
  * 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,
 					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_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_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
  * @wmi_handle: wmi handle
@@ -3013,32 +3002,6 @@ wmi_extract_pdev_ext_stats(wmi_unified_t wmi_handle, void *evt_buf,
 			   uint32_t index,
 			   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
  * from event
@@ -3052,19 +3015,6 @@ QDF_STATUS wmi_extract_bss_chan_info_event(
 		wmi_unified_t wmi_handle, void *evt_buf,
 		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
  * from event
@@ -3078,46 +3028,6 @@ QDF_STATUS
 wmi_extract_tx_data_traffic_ctrl_ev(wmi_unified_t wmi_handle, void *evt_buf,
 				    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_handle: wmi handle

wmi/inc/wmi_unified_cp_stats_api.h

@@ -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_ */

wmi/inc/wmi_unified_param.h

@@ -3869,6 +3869,7 @@ struct rx_reorder_queue_remove_params {
  * @num_peer_adv_stats: number of peer adv stats
  * @num_mib_stats: number of 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
  */
 typedef struct {
@@ -3886,6 +3887,7 @@ typedef struct {
 	uint32_t num_peer_adv_stats;
 	uint32_t num_mib_stats;
 	uint32_t num_mib_extd_stats;
+	uint32_t num_peer_stats_info_ext;
 	uint32_t last_event;
 } wmi_host_stats_event;
 

wmi/inc/wmi_unified_priv.h

@@ -463,6 +463,11 @@ QDF_STATUS (*send_stats_request_cmd)(wmi_unified_t wmi_handle,
 				uint8_t macaddr[QDF_MAC_ADDR_SIZE],
 				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,
 			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,
 		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
 QDF_STATUS (*extract_smartlog_event)(wmi_unified_t wmi_handle, void *evt_buf,
 				     struct wmi_debug_fatal_events *event);
@@ -2940,4 +2953,20 @@ static inline void wmi_cfr_attach_tlv(struct wmi_unified *wmi_handle)
 {
 }
 #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

wmi/src/wmi_unified.c

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

wmi/src/wmi_unified_api.c

@@ -411,25 +411,6 @@ QDF_STATUS wmi_unified_sifs_trigger_send(wmi_unified_t wmi_handle,
 	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
 wmi_unified_packet_log_enable_send(wmi_unified_t wmi_handle,
 				   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
 wmi_extract_unit_test(wmi_unified_t wmi_handle, void *evt_buf,
 		      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;
 }
 
-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,
 			       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;
 }
 
-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(
 	wmi_unified_t wmi_handle, void *evt_buf,
 	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;
 }
 
-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
 wmi_extract_rtt_error_report_ev(wmi_unified_t wmi_handle, void *evt_buf,
 				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;
 }
 
-#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,
 				     uint32_t *temp, uint32_t *level,
 				     uint32_t *pdev_id)

wmi/src/wmi_unified_cp_stats_api.c

@@ -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;
+}

wmi/src/wmi_unified_cp_stats_tlv.c

@@ -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);
+}

wmi/src/wmi_unified_tlv.c

@@ -703,10 +703,9 @@ void wmi_mtrace(uint32_t message_id, uint16_t vdev_id, uint32_t data)
 }
 qdf_export_symbol(wmi_mtrace);
 
-#ifdef WLAN_FEATURE_WMI_SEND_RECV_QMI
-static QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
-					      wmi_buf_t buf,
-					      uint32_t buflen, uint32_t cmd_id)
+QDF_STATUS wmi_unified_cmd_send_pm_chk(struct wmi_unified *wmi_handle,
+				       wmi_buf_t buf,
+				       uint32_t buflen, uint32_t cmd_id)
 {
 	if (!wmi_is_qmi_stats_enabled(wmi_handle))
 		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 (QDF_IS_STATUS_SUCCESS(
 		    wmi_unified_cmd_send_over_qmi(wmi_handle, buf,
-					     buflen, cmd_id)))
+						  buflen, cmd_id)))
 			return QDF_STATUS_SUCCESS;
 	}
 
@@ -723,15 +722,6 @@ send_over_wmi:
 
 	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
@@ -2122,55 +2112,6 @@ static QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
 	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
  *  @wmi_handle: handle to WMI.
@@ -10134,246 +10075,6 @@ static QDF_STATUS extract_nlo_complete_ev_param_tlv(wmi_unified_t wmi_handle,
 }
 #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
  * @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;
 }
 
-/**
- * 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
  * @wmi_handle: wmi handle
@@ -10574,45 +10169,6 @@ static QDF_STATUS extract_bcn_stats_tlv(wmi_unified_t wmi_handle,
 	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
  * @wmi_handle: wmi handle
@@ -10628,92 +10184,6 @@ static QDF_STATUS extract_bcnflt_stats_tlv(wmi_unified_t wmi_handle,
 	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
  * @wmi_handle: wmi handle
@@ -10753,144 +10223,6 @@ static QDF_STATUS extract_chan_stats_tlv(wmi_unified_t wmi_handle,
 	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
  * @wmi_handle: wmi handle
@@ -14356,7 +13688,6 @@ struct wmi_ops tlv_ops =  {
 	.send_dbglog_cmd = send_dbglog_cmd_tlv,
 #endif
 	.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_peer_based_pktlog_cmd = send_peer_based_pktlog_cmd,
 	.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_complete_ev_param = extract_nlo_complete_ev_param_tlv,
 #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_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_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,
-#ifdef WLAN_FEATURE_MIB_STATS
-	.extract_mib_stats = extract_mib_stats_tlv,
-#endif
 	.extract_profile_ctx = extract_profile_ctx_tlv,
 	.extract_profile_data = extract_profile_data_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_vdev_attach_tlv(wmi_handle);
 	wmi_cfr_attach_tlv(wmi_handle);
+	wmi_cp_stats_attach_tlv(wmi_handle);
 }
 qdf_export_symbol(wmi_tlv_attach);