Merge "qcacmn: Send STA authorized status to supplicant for AP"

dp/inc/cdp_txrx_stats_struct.h

@@ -1565,7 +1565,7 @@ enum _ol_ath_param_t {
 	OL_ATH_PARAM_HE_SR = 401,
 	OL_ATH_PARAM_HE_UL_PPDU_DURATION = 402,
 	OL_ATH_PARAM_HE_UL_RU_ALLOCATION = 403,
-
+	OL_ATH_PARAM_PERIODIC_CFR_CAPTURE = 404,
 };
 
 /* Enumeration of PDEV Configuration parameter */

dp/wifi3.0/dp_htt.c

@@ -2634,15 +2634,23 @@ struct ppdu_info *dp_get_ppdu_desc(struct dp_pdev *pdev, uint32_t ppdu_id,
 	}
 
 	if (ppdu_info) {
-		/**
-		 * if we get tlv_type that is already been processed for ppdu,
-		 * that means we got a new ppdu with same ppdu id.
-		 * Hence Flush the older ppdu
-		 */
-		if (ppdu_info->tlv_bitmap & (1 << tlv_type))
+		if (ppdu_info->tlv_bitmap & (1 << tlv_type)) {
+			/**
+			 * if we get tlv_type that is already been processed
+			 * for ppdu, that means we got a new ppdu with same
+			 * ppdu id. Hence Flush the older ppdu
+			 * for MUMIMO and OFDMA, In a PPDU we have
+			 * multiple user with same tlv types. tlv bitmap is
+			 * used to check whether SU or MU_MIMO/OFDMA
+			 */
+			if (!(ppdu_info->tlv_bitmap &
+			    (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV)))
+				return ppdu_info;
+
 			dp_ppdu_desc_deliver(pdev, ppdu_info);
-		else
+		} else {
 			return ppdu_info;
+		}
 	}
 
 	/**

dp/wifi3.0/dp_main.c

@@ -415,7 +415,7 @@ void dp_pkt_log_init(struct cdp_pdev *ppdev, void *scn)
 	}
 
 	pktlog_sethandle(&handle->pl_dev, scn);
-	pktlog_set_callback_regtype(PKTLOG_LITE_CALLBACK_REGISTRATION);
+	pktlog_set_callback_regtype(PKTLOG_DEFAULT_CALLBACK_REGISTRATION);
 
 	if (pktlogmod_init(scn)) {
 		QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,

dp/wifi3.0/dp_rx_mon_status.c

@@ -518,6 +518,7 @@ dp_rx_mon_status_process_tlv(struct dp_soc *soc, uint32_t mac_id,
 	QDF_STATUS m_copy_status = QDF_STATUS_SUCCESS;
 	struct cdp_pdev_mon_stats *rx_mon_stats;
 	int smart_mesh_status;
+	enum WDI_EVENT pktlog_mode = WDI_NO_VAL;
 
 	ppdu_info = &pdev->ppdu_info;
 	rx_mon_stats = &pdev->rx_mon_stats;
@@ -553,9 +554,16 @@ dp_rx_mon_status_process_tlv(struct dp_soc *soc, uint32_t mac_id,
 			dp_rx_process_peer_based_pktlog(soc, ppdu_info,
 							status_nbuf, mac_id);
 		} else {
-			dp_wdi_event_handler(WDI_EVENT_RX_DESC, soc,
-					     status_nbuf, HTT_INVALID_PEER,
-					     WDI_NO_VAL, mac_id);
+			if (pdev->rx_pktlog_mode == DP_RX_PKTLOG_FULL)
+				pktlog_mode = WDI_EVENT_RX_DESC;
+			else if (pdev->rx_pktlog_mode == DP_RX_PKTLOG_LITE)
+				pktlog_mode = WDI_EVENT_LITE_RX;
+
+			if (pktlog_mode != WDI_NO_VAL)
+				dp_wdi_event_handler(pktlog_mode, soc,
+						     status_nbuf,
+						     HTT_INVALID_PEER,
+						     WDI_NO_VAL, mac_id);
 		}
 
 		/* smart monitor vap and m_copy cannot co-exist */

dp/wifi3.0/dp_wdi_event.c

@@ -137,11 +137,7 @@ dp_wdi_event_handler(
 	 *  Subscribers must do the sanity based on the requirements
 	 */
 	event_index = event - WDI_EVENT_BASE;
-	if (!(txrx_pdev->wdi_event_list[event_index]) &&
-		(event == WDI_EVENT_RX_DESC)) {
-		/* WDI_EVEN_RX_DESC is indicated for RX_LITE also */
-		event_index = WDI_EVENT_LITE_RX - WDI_EVENT_BASE;
-	}
+
 	wdi_sub = txrx_pdev->wdi_event_list[event_index];
 
 	/* Find the subscriber */

hif/src/ce/ce_assignment.h

@@ -905,7 +905,7 @@ static struct CE_attr host_ce_config_wlan_qca6390[] = {
 	{ /* CE4 */ (CE_ATTR_FLAGS | CE_ATTR_DISABLE_INTR), 0,
 		CE_HTT_H2T_MSG_SRC_NENTRIES, 256, 0, NULL,},
 	/* target -> host PKTLOG */
-	{ /* CE5 */ CE_ATTR_FLAGS, 0, 0, 0, 0, NULL,},
+	{ /* CE5 */ CE_ATTR_FLAGS, 0, 0, 2048, 512, NULL,},
 	/* Target autonomous HIF_memcpy */
 	{ /* CE6 */ CE_ATTR_FLAGS, 0, 0, 0, 0, NULL,},
 	/* ce_diag, the Diagnostic Window */

hif/src/ce/ce_main.c

@@ -578,6 +578,7 @@ static struct service_to_pipe target_service_to_ce_map_qca6390[] = {
 	{ HTC_CTRL_RSVD_SVC, PIPEDIR_IN, 2, },
 	{ HTT_DATA_MSG_SVC, PIPEDIR_OUT, 4, },
 	{ HTT_DATA_MSG_SVC, PIPEDIR_IN, 1, },
+	{ PACKET_LOG_SVC, PIPEDIR_IN, 5, },
 	/* (Additions here) */
 	{ 0, 0, 0, },
 };

os_if/linux/qca_vendor.h

@@ -904,6 +904,7 @@ enum qca_nl80211_vendor_subcmds_index {
 	QCA_NL80211_VENDOR_SUBCMD_WLAN_MAC_INFO_INDEX,
 	QCA_NL80211_VENDOR_SUBCMD_NAN_EXT_INDEX,
 	QCA_NL80211_VENDOR_SUBCMD_THROUGHPUT_CHANGE_EVENT_INDEX,
+	QCA_NL80211_VENDOR_SUBCMD_LINK_PROPERTIES_INDEX,
 };
 
 /**
@@ -2932,6 +2933,12 @@ enum qca_wlan_vendor_attr_get_logger_features {
  *	to specify negotiated rate flags i.e. ht, vht and channel width
  * @QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_FREQ: Unsigned 32bit value to
  *	specify the operating frequency
+ * @QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_MAC_ADDR: MAC Address of the peer
+ * (STA / AP ) for the connected link.
+ * @QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_STA_FLAGS: Attribute containing a
+ * &struct nl80211_sta_flag_update for the respective connected link. MAC
+ * address of the peer represented by
+ * QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_MAC_ADDR.
  * @QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_AFTER_LAST: after last
  * @QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_MAX: max value
  */
@@ -2940,6 +2947,8 @@ enum qca_wlan_vendor_attr_link_properties {
 	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_NSS = 1,
 	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_RATE_FLAGS = 2,
 	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_FREQ = 3,
+	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_MAC_ADDR  = 4,
+	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_STA_FLAGS  = 5,
 
 	/* KEEP LAST */
 	QCA_WLAN_VENDOR_ATTR_LINK_PROPERTIES_AFTER_LAST,

umac/cmn_services/inc/wlan_cmn.h

@@ -306,6 +306,7 @@ enum wlan_umac_comp_id {
 	WLAN_UMAC_COMP_CP_STATS           = 27,
 	WLAN_UMAC_COMP_ACTION_OUI         = 28,
 	WLAN_UMAC_COMP_FWOL               = 29,
+	WLAN_UMAC_COMP_CFR                = 30,
 	WLAN_UMAC_COMP_ID_MAX,
 };
 

umac/cmn_services/obj_mgr/inc/wlan_objmgr_cmn.h

@@ -286,6 +286,7 @@ typedef enum {
 	WLAN_TGT_IF_DP_PEER_REF_ID = 45,
 	WLAN_MLME_SER_IF_ID        = 46,
 	WLAN_SCHEDULER_ID          = 47,
+	WLAN_CFR_ID                = 48,
 	WLAN_REF_ID_MAX,
 } wlan_objmgr_ref_dbgid;
 
@@ -347,6 +348,7 @@ static inline char *string_from_dbgid(wlan_objmgr_ref_dbgid id)
 					"WLAN_TGT_IF_DP_PEER_REF_ID",
 					"WLAN_MLME_SER_IF_ID",
 					"WLAN_SCHEDULER_ID",
+					"WLAN_CFR_ID",
 					"WLAN_REF_ID_MAX"};
 
 	return (char *)strings[id];

umac/cmn_services/obj_mgr/inc/wlan_objmgr_pdev_obj.h

@@ -117,6 +117,8 @@
 #define WLAN_PDEV_OP_MIN_RSSI_ENABLE    0x00010000
    /* PDEV VDEV restart is in progress */
 #define WLAN_PDEV_OP_RESTART_INPROGRESS 0x00020000
+   /* PDEV MBSSID VDEV restart trigger */
+#define WLAN_PDEV_OP_MBSSID_RESTART     0x00040000
 
 
 struct osif_pdev_priv;

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -47,6 +47,10 @@
 #include "wlan_crypto_global_def.h"
 #endif
 
+#ifdef WLAN_CFR_ENABLE
+#include "wlan_cfr_utils_api.h"
+#endif
+
 #include <wlan_dfs_tgt_api.h>
 #include <wlan_dfs_ioctl.h>
 
@@ -456,6 +460,30 @@ struct wlan_lmac_if_sa_api_tx_ops {
 
 #endif
 
+#ifdef WLAN_CFR_ENABLE
+/**
+ * struct wlan_lmac_if_cfr_tx_ops - CFR specific tx function pointers
+ * @cfr_init_pdev: Initialize CFR
+ * @cfr_deinit_pdev: De-initialize CFR
+ * @cfr_enable_cfr_timer: Function to enable CFR timer
+ * @cfr_start_capture: Function to start CFR capture
+ * @cfr_stop_capture: Function to stop CFR capture
+ */
+struct wlan_lmac_if_cfr_tx_ops {
+	int (*cfr_init_pdev)(struct wlan_objmgr_psoc *psoc,
+			     struct wlan_objmgr_pdev *pdev);
+	int (*cfr_deinit_pdev)(struct wlan_objmgr_psoc *psoc,
+			       struct wlan_objmgr_pdev *pdev);
+	int (*cfr_enable_cfr_timer)(struct wlan_objmgr_pdev *pdev,
+				    uint32_t cfr_timer);
+	int (*cfr_start_capture)(struct wlan_objmgr_pdev *pdev,
+				 struct wlan_objmgr_peer *peer,
+				 struct cfr_capture_params *params);
+	int (*cfr_stop_capture)(struct wlan_objmgr_pdev *pdev,
+				struct wlan_objmgr_peer *peer);
+};
+#endif /* WLAN_CFR_ENABLE */
+
 #ifdef WLAN_CONV_SPECTRAL_ENABLE
 struct wmi_spectral_cmd_ops;
 /**
@@ -819,6 +847,10 @@ struct wlan_lmac_if_tx_ops {
 	struct wlan_lmac_if_sa_api_tx_ops sa_api_tx_ops;
 #endif
 
+#ifdef WLAN_CFR_ENABLE
+	struct wlan_lmac_if_cfr_tx_ops cfr_tx_ops;
+#endif
+
 #ifdef WLAN_CONV_SPECTRAL_ENABLE
 	struct wlan_lmac_if_sptrl_tx_ops sptrl_tx_ops;
 #endif

utils/logging/src/wlan_logging_sock_svc.c

@@ -736,7 +736,7 @@ void wlan_report_log_completion(uint32_t is_fatal,
 }
 #endif
 
-#ifdef CONFIG_MCL
+#ifdef FEATURE_WLAN_DIAG_SUPPORT
 /**
  * send_flush_completion_to_user() - Indicate flush completion to the user
  * @ring_id:  Ring id of logging entities
@@ -823,7 +823,7 @@ static int wlan_logging_thread(void *Arg)
 			ret = send_filled_buffers_to_user();
 			if (-ENOMEM == ret)
 				msleep(200);
-#ifdef CONFIG_MCL
+#ifdef FEATURE_WLAN_DIAG_SUPPORT
 			if (WLAN_LOG_INDICATOR_HOST_ONLY ==
 			   cds_get_log_indicator()) {
 				send_flush_completion_to_user(
@@ -848,7 +848,7 @@ static int wlan_logging_thread(void *Arg)
 			 */
 			if (gwlan_logging.is_flush_complete == true) {
 				gwlan_logging.is_flush_complete = false;
-#ifdef CONFIG_MCL
+#ifdef FEATURE_WLAN_DIAG_SUPPORT
 				send_flush_completion_to_user(
 						RING_ID_DRIVER_DEBUG);
 #endif

utils/pktlog/pktlog_ac.c

@@ -235,7 +235,7 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 	if ((log_state & ATH_PKTLOG_TX) ||
 	    (log_state  & ATH_PKTLOG_RCFIND) ||
 	    (log_state & ATH_PKTLOG_RCUPDATE) ||
-	    (log_state & ATH_PKTLOG_RX)) {
+	    (log_state & ATH_PKTLOG_SW_EVENT)) {
 		if (cdp_wdi_event_sub(soc,
 				      cdp_pdev,
 				      &PKTLOG_OFFLOAD_SUBSCRIBER,
@@ -246,8 +246,8 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 
 	if (log_state & ATH_PKTLOG_RX) {
 		if (cdp_wdi_event_sub(soc, cdp_pdev,
-				      &PKTLOG_RX_SUBSCRIBER,
-				      WDI_EVENT_RX_DESC)) {
+					&PKTLOG_RX_SUBSCRIBER,
+					WDI_EVENT_RX_DESC)) {
 			return A_ERROR;
 		}
 	}
@@ -465,7 +465,7 @@ wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
 	if ((log_state & ATH_PKTLOG_TX) ||
 	    (log_state  & ATH_PKTLOG_RCFIND) ||
 	    (log_state & ATH_PKTLOG_RCUPDATE) ||
-	    (log_state & ATH_PKTLOG_RX)) {
+	    (log_state & ATH_PKTLOG_SW_EVENT)) {
 		if (cdp_wdi_event_unsub(soc,
 					pdev,
 					&PKTLOG_OFFLOAD_SUBSCRIBER,
@@ -557,6 +557,39 @@ int pktlog_disable(struct hif_opaque_softc *scn)
 	return 0;
 }
 
+#ifdef HELIUMPLUS
+/**
+ * pktlog_callback_registration() - Register pktlog handlers based on
+ *                                  on callback type
+ * @callback_type: pktlog full or lite registration
+ *
+ * Return: None
+ */
+static void pktlog_callback_registration(uint8_t callback_type)
+{
+	if (callback_type == PKTLOG_DEFAULT_CALLBACK_REGISTRATION) {
+		PKTLOG_TX_SUBSCRIBER.callback = pktlog_callback;
+		PKTLOG_RX_SUBSCRIBER.callback = pktlog_callback;
+		PKTLOG_RX_REMOTE_SUBSCRIBER.callback = pktlog_callback;
+		PKTLOG_RCFIND_SUBSCRIBER.callback = pktlog_callback;
+		PKTLOG_RCUPDATE_SUBSCRIBER.callback = pktlog_callback;
+		PKTLOG_SW_EVENT_SUBSCRIBER.callback = pktlog_callback;
+	}
+}
+#else
+static void pktlog_callback_registration(uint8_t callback_type)
+{
+	if (callback_type == PKTLOG_DEFAULT_CALLBACK_REGISTRATION) {
+		PKTLOG_RX_SUBSCRIBER.callback = lit_pktlog_callback;
+		PKTLOG_LITE_T2H_SUBSCRIBER.callback = lit_pktlog_callback;
+		PKTLOG_OFFLOAD_SUBSCRIBER.callback = pktlog_callback;
+	} else if (callback_type == PKTLOG_LITE_CALLBACK_REGISTRATION) {
+		PKTLOG_LITE_T2H_SUBSCRIBER.callback = lit_pktlog_callback;
+		PKTLOG_LITE_RX_SUBSCRIBER.callback = lit_pktlog_callback;
+	}
+}
+#endif
+
 void pktlog_init(struct hif_opaque_softc *scn)
 {
 	struct pktlog_dev_t *pl_dev = get_pktlog_handle();
@@ -589,18 +622,7 @@ void pktlog_init(struct hif_opaque_softc *scn)
 	pl_info->start_time_per = 0;
 	pl_dev->vendor_cmd_send = false;
 
-	if (pl_dev->callback_type == PKTLOG_DEFAULT_CALLBACK_REGISTRATION) {
-		PKTLOG_TX_SUBSCRIBER.callback = pktlog_callback;
-		PKTLOG_RX_SUBSCRIBER.callback = pktlog_callback;
-		PKTLOG_RX_REMOTE_SUBSCRIBER.callback = pktlog_callback;
-		PKTLOG_RCFIND_SUBSCRIBER.callback = pktlog_callback;
-		PKTLOG_RCUPDATE_SUBSCRIBER.callback = pktlog_callback;
-		PKTLOG_SW_EVENT_SUBSCRIBER.callback = pktlog_callback;
-	} else if (pl_dev->callback_type == PKTLOG_LITE_CALLBACK_REGISTRATION) {
-		PKTLOG_LITE_T2H_SUBSCRIBER.callback = lit_pktlog_callback;
-		PKTLOG_LITE_RX_SUBSCRIBER.callback = lit_pktlog_callback;
-		PKTLOG_OFFLOAD_SUBSCRIBER.callback = pktlog_callback;
-	}
+	pktlog_callback_registration(pl_dev->callback_type);
 }
 
 static int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
@@ -764,7 +786,7 @@ int pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 }
 
 #define ONE_MEGABYTE (1024 * 1024)
-#define MAX_ALLOWED_PKTLOG_SIZE (16 * ONE_MEGABYTE)
+#define MAX_ALLOWED_PKTLOG_SIZE (64 * ONE_MEGABYTE)
 
 static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 {

utils/pktlog/pktlog_internal.c

@@ -1455,8 +1455,7 @@ process_pktlog_lite(void *context, void *log_data, uint16_t log_type)
 	pl_hdr.timestamp = 0;
 	log_size = pl_hdr.size;
 	rxstat_log.rx_desc = (void *)pktlog_getbuf(pl_dev, pl_info,
-						  log_size, &pl_hdr);
-
+						   log_size, &pl_hdr);
 	if (rxstat_log.rx_desc == NULL) {
 		QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_DEBUG,
 			"%s: Rx descriptor is NULL", __func__);

wmi/inc/wmi_unified_api.h

@@ -1730,4 +1730,18 @@ enum cdp_sec_type wlan_crypto_cipher_to_cdp_sec_type(
 		enum wlan_crypto_cipher_type crypto_cipher);
 
 #endif
+
+#ifdef WLAN_CFR_ENABLE
+/**
+ * wmi_unified_send_peer_cfr_capture_cmd() - WMI function to start CFR capture
+ * for a peer
+ * @wmi_hdl: WMI handle
+ * @param: configuration params for capture
+ *
+ * Return: QDF_STATUS_SUCCESS if success, else returns proper error code.
+ */
+QDF_STATUS
+wmi_unified_send_peer_cfr_capture_cmd(void *wmi_hdl,
+				      struct peer_cfr_params *param);
+#endif /* WLAN_CFR_ENABLE */
 #endif /* _WMI_UNIFIED_API_H_ */

wmi/inc/wmi_unified_param.h

@@ -875,6 +875,31 @@ struct hidden_ssid_vdev_restart_params {
 #endif
 };
 
+#ifdef WLAN_CFR_ENABLE
+
+#define WMI_HOST_PEER_CFR_TIMER_ENABLE   1
+#define WMI_HOST_PEER_CFR_TIMER_DISABLE  0
+
+/**
+ * struct peer_cfr_params - peer cfr capture cmd parameter
+ * @request: enable/disable cfr capture
+ * @macaddr: macaddr of the client
+ * @vdev_id: vdev id
+ * @periodicity: cfr capture period
+ * @bandwidth: bandwidth of cfr capture
+ * @capture_method: cfr capture method/type
+ */
+struct peer_cfr_params {
+	uint32_t request;
+	uint8_t  *macaddr;
+	uint32_t vdev_id;
+	uint32_t periodicity;
+	uint32_t bandwidth;
+	uint32_t capture_method;
+};
+
+#endif /* WLAN_CFR_ENABLE */
+
 #ifndef CMN_VDEV_MGR_TGT_IF_ENABLE
 /**
  * struct vdev_set_params - vdev set cmd parameter
@@ -4882,7 +4907,7 @@ typedef enum {
 	wmi_pdev_param_sub_channel_marking,
 	wmi_pdev_param_ul_ppdu_duration,
 	wmi_pdev_param_equal_ru_allocation_enable,
-
+	wmi_pdev_param_per_peer_prd_cfr_enable,
 	wmi_pdev_param_max,
 } wmi_conv_pdev_params_id;
 
@@ -5198,6 +5223,7 @@ typedef enum {
 	wmi_service_hw_db2dbm_support,
 	wmi_service_wlm_stats_support,
 	wmi_service_ul_ru26_allowed,
+	wmi_service_cfr_capture_support,
 	wmi_services_max,
 } wmi_conv_service_ids;
 #define WMI_SERVICE_UNAVAILABLE 0xFFFF

wmi/inc/wmi_unified_priv.h

@@ -1896,6 +1896,10 @@ QDF_STATUS
 QDF_STATUS (*send_peer_del_all_wds_entries_cmd)(wmi_unified_t wmi_handle,
 		struct peer_del_all_wds_entries_params *param);
 
+#ifdef WLAN_CFR_ENABLE
+QDF_STATUS (*send_peer_cfr_capture_cmd)(wmi_unified_t wmi_handle,
+					struct peer_cfr_params *param);
+#endif
 };
 
 /* Forward declartion for psoc*/

wmi/src/wmi_unified_api.c

@@ -4622,3 +4622,17 @@ QDF_STATUS wmi_unified_extract_obss_color_collision_info(void *wmi_hdl,
 
 	return QDF_STATUS_E_FAILURE;
 }
+
+#ifdef WLAN_CFR_ENABLE
+QDF_STATUS wmi_unified_send_peer_cfr_capture_cmd(void *wmi_hdl,
+						 struct peer_cfr_params *param)
+{
+	wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl;
+
+	if (wmi_handle->ops->send_peer_cfr_capture_cmd)
+		return wmi_handle->ops->send_peer_cfr_capture_cmd(wmi_hdl,
+								  param);
+
+	return QDF_STATUS_E_FAILURE;
+}
+#endif /* WLAN_CFR_ENABLE */

wmi/src/wmi_unified_tlv.c

@@ -10676,6 +10676,52 @@ static QDF_STATUS extract_single_phyerr_tlv(wmi_unified_t wmi_handle,
 	return QDF_STATUS_SUCCESS;
 }
 
+#ifdef WLAN_CFR_ENABLE
+/**
+ * send_peer_cfr_capture_cmd_tlv() - configure cfr params in fw
+ * @wmi_handle: wmi handle
+ * @param: pointer to hold peer cfr config parameter
+ *
+ * Return: 0 for success or error code
+ */
+static QDF_STATUS send_peer_cfr_capture_cmd_tlv(wmi_unified_t wmi_handle,
+						struct peer_cfr_params *param)
+{
+	wmi_peer_cfr_capture_cmd_fixed_param *cmd;
+	wmi_buf_t buf;
+	int len = sizeof(*cmd);
+	int ret;
+
+	buf = wmi_buf_alloc(wmi_handle, len);
+	if (!buf) {
+		qdf_print("%s:wmi_buf_alloc failed\n", __func__);
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	cmd = (wmi_peer_cfr_capture_cmd_fixed_param *)wmi_buf_data(buf);
+	WMITLV_SET_HDR(&cmd->tlv_header,
+		       WMITLV_TAG_STRUC_wmi_peer_cfr_capture_cmd_fixed_param,
+		       WMITLV_GET_STRUCT_TLVLEN
+		       (wmi_peer_cfr_capture_cmd_fixed_param));
+
+	WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->mac_addr);
+	cmd->request = param->request;
+	cmd->vdev_id = param->vdev_id;
+	cmd->periodicity = param->periodicity;
+	cmd->bandwidth = param->bandwidth;
+	cmd->capture_method = param->capture_method;
+
+	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
+				   WMI_PEER_CFR_CAPTURE_CMDID);
+	if (QDF_IS_STATUS_ERROR(ret)) {
+		WMI_LOGE("Failed to send WMI_PEER_CFR_CAPTURE_CMDID");
+		wmi_buf_free(buf);
+	}
+
+	return ret;
+}
+#endif /* WLAN_CFR_ENABLE */
+
 /**
  * extract_esp_estimation_ev_param_tlv() - extract air time from event
  * @wmi_handle: wmi handle
@@ -11137,6 +11183,11 @@ struct wmi_ops tlv_ops =  {
 	.extract_offload_bcn_tx_status_evt = extract_offload_bcn_tx_status_evt,
 	.extract_ctl_failsafe_check_ev_param =
 		extract_ctl_failsafe_check_ev_param_tlv,
+#ifdef WLAN_CFR_ENABLE
+	.send_peer_cfr_capture_cmd =
+		send_peer_cfr_capture_cmd_tlv,
+#endif
+
 };
 
 /**
@@ -11689,6 +11740,8 @@ static void populate_tlv_service(uint32_t *wmi_service)
 			WMI_SERVICE_WLM_STATS_REQUEST;
 	wmi_service[wmi_service_infra_mbssid] = WMI_SERVICE_INFRA_MBSSID;
 	wmi_service[wmi_service_ul_ru26_allowed] = WMI_SERVICE_UL_RU26_ALLOWED;
+	wmi_service[wmi_service_cfr_capture_support] =
+			WMI_SERVICE_CFR_CAPTURE_SUPPORT;
 }
 #ifndef CONFIG_MCL
 
@@ -11948,6 +12001,8 @@ static void populate_pdev_param_tlv(uint32_t *pdev_param)
 				WMI_PDEV_PARAM_SET_UL_PPDU_DURATION;
 	pdev_param[wmi_pdev_param_equal_ru_allocation_enable] =
 				WMI_PDEV_PARAM_EQUAL_RU_ALLOCATION_ENABLE;
+	pdev_param[wmi_pdev_param_per_peer_prd_cfr_enable] =
+				WMI_PDEV_PARAM_PER_PEER_PERIODIC_CFR_ENABLE;
 }
 
 /**