qcacld-3.0: Add support to get thermal throttle stats

Add support for sending WMI_REQUEST_THERMAL_STATS_CMDID
to request for the thermal stats via vendor cmd:
QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_GET_THERMAL_STATS
This vendor cmd can either be used to clear the thermal
stats or to request for the thermal stats.
Added ini gThermalStatsTempOffset, which can
configure thermal temperature offset value for capturing
thermal stats in  thermal range such as Thermal STATS
starts capturing from temperature threshold to temperature
threshold + offset.
If this ini is set to 0, then the events are disabled.
Also, add support for the FW event where the requested
thermal stats are sent in FW event
WMI_THERM_THROT_STATS_EVENTID().
The following attributes are sent in the events for every
level:
	STATS_MIN_TEMPERATURE
	STATS_MAX_TEMPERATURE
	STATS_DWELL_TIME
	STATS_TEMP_LEVEL_COUNTER

Change-Id: If8acdeec5bde33be346332ccaf39d78d0151203d
CRs-Fixed: 3016818

Kbuild

@@ -2817,6 +2817,7 @@ cppflags-y +=	-DANI_OS_TYPE_ANDROID=6 \
 		-Werror\
 		-D__linux__
 
+cppflags-$(CONFIG_THERMAL_STATS_SUPPORT) += -DTHERMAL_STATS_SUPPORT
 cppflags-$(CONFIG_PTT_SOCK_SVC_ENABLE) += -DPTT_SOCK_SVC_ENABLE
 cppflags-$(CONFIG_FEATURE_WLAN_WAPI) += -DFEATURE_WLAN_WAPI
 cppflags-$(CONFIG_FEATURE_WLAN_WAPI) += -DATH_SUPPORT_WAPI

components/fw_offload/core/inc/wlan_fw_offload_main.h

@@ -51,10 +51,12 @@
 /**
  * enum wlan_fwol_southbound_event - fw offload south bound event type
  * @WLAN_FWOL_EVT_GET_ELNA_BYPASS_RESPONSE: get eLNA bypass response
+ * @WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE: get Thermal Stats response
  */
 enum wlan_fwol_southbound_event {
 	WLAN_FWOL_EVT_INVALID = 0,
 	WLAN_FWOL_EVT_GET_ELNA_BYPASS_RESPONSE,
+	WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE,
 	WLAN_FWOL_EVT_LAST,
 	WLAN_FWOL_EVT_MAX = WLAN_FWOL_EVT_LAST - 1
 };
@@ -116,6 +118,7 @@ struct wlan_fwol_coex_config {
  * @priority_apps: Priority of the apps mitigation to consider by fw
  * @priority_wpps: Priority of the wpps mitigation to consider by fw
  * @thermal_action: thermal action as defined enum thermal_mgmt_action_code
+ * @therm_stats_offset: thermal temp offset as set in gThermalStatsTempOffset
  */
 struct wlan_fwol_thermal_temp {
 	bool     thermal_mitigation_enable;
@@ -128,6 +131,9 @@ struct wlan_fwol_thermal_temp {
 	uint8_t priority_apps;
 	uint8_t priority_wpps;
 	enum thermal_mgmt_action_code thermal_action;
+#ifdef THERMAL_STATS_SUPPORT
+	uint8_t therm_stats_offset;
+#endif
 };
 
 /**
@@ -287,6 +293,16 @@ struct wlan_fwol_thermal_throttle_info {
 	uint32_t pdev_id;
 };
 
+/**
+ * struct wlan_fwol_capability_info - FW offload capability component
+ * @fw_thermal_stats_cap: Thermal Stats Fw capability
+ **/
+struct wlan_fwol_capability_info {
+#ifdef THERMAL_STATS_SUPPORT
+	bool fw_thermal_stats_cap;
+#endif
+};
+
 /**
  * struct wlan_fwol_psoc_obj - FW offload psoc priv object
  * @cfg:     cfg items
@@ -295,6 +311,7 @@ struct wlan_fwol_thermal_throttle_info {
  * @rx_ops: rx operations for target interface
  * @thermal_throttle: cached target thermal stats information
  * @thermal_cbs: thermal notification callbacks to hdd layer
+ * @capability_info: fwol capability info
  */
 struct wlan_fwol_psoc_obj {
 	struct wlan_fwol_cfg cfg;
@@ -305,6 +322,7 @@ struct wlan_fwol_psoc_obj {
 	struct wlan_fwol_thermal_throttle_info thermal_throttle;
 	struct fwol_thermal_callbacks thermal_cbs;
 #endif
+	struct wlan_fwol_capability_info capability_info;
 };
 
 /**
@@ -312,6 +330,7 @@ struct wlan_fwol_psoc_obj {
  * @psoc: psoc handle
  * @event_id: event ID
  * @get_elna_bypass_response: get eLNA bypass response
+ * @get_thermal_stats_response: get thermal stats response
  */
 struct wlan_fwol_rx_event {
 	struct wlan_objmgr_psoc *psoc;
@@ -319,6 +338,9 @@ struct wlan_fwol_rx_event {
 	union {
 #ifdef WLAN_FEATURE_ELNA
 		struct get_elna_bypass_response get_elna_bypass_response;
+#endif
+#ifdef THERMAL_STATS_SUPPORT
+		struct thermal_throttle_info get_thermal_stats_response;
 #endif
 	};
 };

components/fw_offload/core/src/wlan_fw_offload_main.c

@@ -111,6 +111,22 @@ fwol_init_coex_config_in_cfg(struct wlan_objmgr_psoc *psoc,
 						    CFG_BLE_SCAN_COEX_POLICY);
 }
 
+#ifdef THERMAL_STATS_SUPPORT
+static void
+fwol_init_thermal_stats_in_cfg(struct wlan_objmgr_psoc *psoc,
+			       struct wlan_fwol_thermal_temp *thermal_temp)
+{
+	thermal_temp->therm_stats_offset =
+				cfg_get(psoc, CFG_THERMAL_STATS_TEMP_OFFSET);
+}
+#else
+static void
+fwol_init_thermal_stats_in_cfg(struct wlan_objmgr_psoc *psoc,
+			       struct wlan_fwol_thermal_temp *thermal_temp)
+{
+}
+#endif
+
 static void
 fwol_init_thermal_temp_in_cfg(struct wlan_objmgr_psoc *psoc,
 			      struct wlan_fwol_thermal_temp *thermal_temp)
@@ -155,7 +171,7 @@ fwol_init_thermal_temp_in_cfg(struct wlan_objmgr_psoc *psoc,
 				cfg_get(psoc, CFG_THERMAL_WPPS_PRIOITY);
 	thermal_temp->thermal_action =
 				cfg_get(psoc, CFG_THERMAL_MGMT_ACTION);
-
+	fwol_init_thermal_stats_in_cfg(psoc, thermal_temp);
 }
 
 /**
@@ -680,6 +696,59 @@ fwol_process_get_elna_bypass_resp(struct wlan_fwol_rx_event *event)
 }
 #endif /* WLAN_FEATURE_ELNA */
 
+#ifdef THERMAL_STATS_SUPPORT
+/**
+ * fwol_process_get_thermal_stats_resp() - Process get thermal stats response
+ * @event: response event
+ *
+ * Return: QDF_STATUS_SUCCESS on success
+ */
+static QDF_STATUS
+fwol_process_get_thermal_stats_resp(struct wlan_fwol_rx_event *event)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_fwol_psoc_obj *fwol_obj;
+	struct wlan_fwol_callbacks *cbs;
+	struct thermal_throttle_info *resp;
+
+	if (!event) {
+		fwol_err("Event buffer is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	psoc = event->psoc;
+	if (!psoc) {
+		fwol_err("psoc is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		fwol_err("Failed to get FWOL Obj");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	cbs = &fwol_obj->cbs;
+	if (cbs && cbs->get_thermal_stats_callback) {
+		resp = &event->get_thermal_stats_response;
+		cbs->get_thermal_stats_callback(cbs->get_thermal_stats_context,
+						resp);
+	} else {
+		fwol_err("NULL pointer for callback");
+		status = QDF_STATUS_E_IO;
+	}
+
+	return status;
+}
+#else
+static QDF_STATUS
+fwol_process_get_thermal_stats_resp(struct wlan_fwol_rx_event *event)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+#endif /* THERMAL_STATS_SUPPORT */
+
 QDF_STATUS fwol_process_event(struct scheduler_msg *msg)
 {
 	QDF_STATUS status;
@@ -699,6 +768,9 @@ QDF_STATUS fwol_process_event(struct scheduler_msg *msg)
 	case WLAN_FWOL_EVT_GET_ELNA_BYPASS_RESPONSE:
 		status = fwol_process_get_elna_bypass_resp(event);
 		break;
+	case WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE:
+		status = fwol_process_get_thermal_stats_resp(event);
+		break;
 	default:
 		status = QDF_STATUS_E_INVAL;
 		break;

components/fw_offload/dispatcher/inc/cfg_thermal_temp.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2018,2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2018,2020-2021 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
@@ -430,6 +430,31 @@
 				CFG_VALUE_OR_DEFAULT, \
 				"Thermal management action")
 
+/* <ini>
+ * gThermalStatsTempOffset - Configure the thermal stats offset
+ *
+ * @Min: 0
+ * @Max: 10
+ * @Default: 5
+ *
+ * This ini will configure Thermal temperature offset value for capturing
+ * thermal stats in  thermal range.
+ * Thermal STATS start capturing from temperature threshold to temperature
+ * threshold + offset.
+ * If the value 0 is given then then thermal STATS capture is disabled
+ *
+ * Usage: External
+ *
+ * </ini>
+ */
+#define CFG_THERMAL_STATS_TEMP_OFFSET CFG_INI_UINT( \
+					"gThermalStatsTempOffset", \
+					0, \
+					10, \
+					5, \
+					CFG_VALUE_OR_DEFAULT, \
+					"Thermal Stats Temperature Offset")
+
 #define CFG_THERMAL_TEMP_ALL \
 	CFG(CFG_THERMAL_TEMP_MIN_LEVEL0) \
 	CFG(CFG_THERMAL_TEMP_MAX_LEVEL0) \
@@ -450,6 +475,7 @@
 	CFG(CFG_THERMAL_SAMPLING_TIME) \
 	CFG(CFG_THERMAL_APPS_PRIORITY) \
 	CFG(CFG_THERMAL_WPPS_PRIOITY) \
-	CFG(CFG_THERMAL_MGMT_ACTION)
-#endif
+	CFG(CFG_THERMAL_MGMT_ACTION) \
+	CFG(CFG_THERMAL_STATS_TEMP_OFFSET)\
 
+#endif

components/fw_offload/dispatcher/inc/wlan_fwol_public_structs.h

@@ -25,6 +25,7 @@
 
 #include "wlan_objmgr_psoc_obj.h"
 #include "wlan_thermal_public_struct.h"
+#include "wmi_unified.h"
 
 #ifdef WLAN_FEATURE_ELNA
 /**
@@ -58,10 +59,28 @@ struct get_elna_bypass_response {
 };
 #endif
 
+/**
+ * struct thermal_throttle_info - thermal throttle info from Target
+ * @temperature: current temperature in c Degree
+ * @level: target thermal level info
+ * @pdev_id: pdev id
+ * @therm_throt_levels: Number of thermal throttle levels
+ * @level_info: Thermal Stats for each level
+ */
+struct thermal_throttle_info {
+	uint32_t temperature;
+	enum thermal_throttle_level level;
+	uint32_t pdev_id;
+	uint32_t therm_throt_levels;
+	struct thermal_throt_level_stats level_info[WMI_THERMAL_STATS_TEMP_THRESH_LEVEL_MAX];
+};
+
 /**
  * struct wlan_fwol_callbacks - fw offload callbacks
  * @get_elna_bypass_callback: callback for get eLNA bypass
  * @get_elna_bypass_context: context for get eLNA bypass
+ * @get_thermal_stats_callback: callback for get thermal stats
+ * @get_thermal_stats_context: context for get thermal stats
  */
 struct wlan_fwol_callbacks {
 #ifdef WLAN_FEATURE_ELNA
@@ -69,18 +88,11 @@ struct wlan_fwol_callbacks {
 				     struct get_elna_bypass_response *response);
 	void *get_elna_bypass_context;
 #endif
-};
-
-/**
- * struct thermal_throttle_info - thermal throttle info from Target
- * @temperature: current temperature in c Degree
- * @level: target thermal level info
- * @pdev_id: pdev id
- */
-struct thermal_throttle_info {
-	uint32_t temperature;
-	enum thermal_throttle_level level;
-	uint32_t pdev_id;
+#ifdef THERMAL_STATS_SUPPORT
+	void (*get_thermal_stats_callback)(void *context,
+				     struct thermal_throttle_info *response);
+	void *get_thermal_stats_context;
+#endif
 };
 
 #ifdef WLAN_FEATURE_MDNS_OFFLOAD
@@ -125,6 +137,7 @@ struct mdns_config_info {
  * @unreg_evt_handler: unregister event handler
  * @send_dscp_up_map_to_fw: send dscp-to-up map values to FW
  * @set_mdns_config: set mdns config info
+ * @get_thermal_stats: send get_thermal_stats cmd to FW
  */
 struct wlan_fwol_tx_ops {
 #ifdef WLAN_FEATURE_ELNA
@@ -146,6 +159,11 @@ struct wlan_fwol_tx_ops {
 	QDF_STATUS (*set_mdns_config)(struct wlan_objmgr_psoc *psoc,
 				      struct mdns_config_info *mdns_info);
 #endif
+#ifdef THERMAL_STATS_SUPPORT
+	QDF_STATUS (*get_thermal_stats)(struct wlan_objmgr_psoc *psoc,
+				      enum thermal_stats_request_type req_type,
+				      uint8_t therm_stats_offset);
+#endif
 };
 
 /**
@@ -153,6 +171,7 @@ struct wlan_fwol_tx_ops {
  * @get_elna_bypass_resp: get eLNA bypass response
  * @notify_thermal_throttle_handler: thermal stats indication callback to fwol
  *  core from target if layer
+ * @get_thermal_stats_resp: thermal stats cmd response callback to fwol
  */
 struct wlan_fwol_rx_ops {
 #ifdef WLAN_FEATURE_ELNA
@@ -164,6 +183,10 @@ struct wlan_fwol_rx_ops {
 				struct wlan_objmgr_psoc *psoc,
 				struct thermal_throttle_info *info);
 #endif
+#ifdef THERMAL_STATS_SUPPORT
+	QDF_STATUS (*get_thermal_stats_resp)(struct wlan_objmgr_psoc *psoc,
+					    struct thermal_throttle_info *resp);
+#endif
 };
 
 /**

components/fw_offload/dispatcher/inc/wlan_fwol_ucfg_api.h

@@ -669,6 +669,26 @@ QDF_STATUS ucfg_fwol_set_mdns_config(struct wlan_objmgr_psoc *psoc,
 				     struct mdns_config_info *mdns_info);
 #endif /* WLAN_FEATURE_MDNS_OFFLOAD */
 
+/**
+ * ucfg_fwol_update_fw_cap_info - API to update fwol capability info
+ * @psoc: pointer to psoc object
+ * @caps: pointer to wlan_fwol_capability_info struct
+ *
+ * Used to update fwol capability info.
+ *
+ * Return: void
+ */
+void ucfg_fwol_update_fw_cap_info(struct wlan_objmgr_psoc *psoc,
+				  struct wlan_fwol_capability_info *caps);
+
+#ifdef THERMAL_STATS_SUPPORT
+QDF_STATUS ucfg_fwol_send_get_thermal_stats_cmd(struct wlan_objmgr_psoc *psoc,
+				      enum thermal_stats_request_type req_type,
+				      void (*callback)(void *context,
+				      struct thermal_throttle_info *response),
+				      void *context);
+#endif /* THERMAL_STATS_SUPPORT */
+
 /**
  * ucfg_fwol_configure_global_params - API to configure global params
  * @psoc: pointer to psoc object

components/fw_offload/dispatcher/src/wlan_fwol_tgt_api.c

@@ -196,8 +196,8 @@ notify_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_INVAL;
 	}
 	thermal_cbs = &fwol_obj->thermal_cbs;
-	fwol_nofl_debug("thermal evt: pdev %d lvl %d", info->pdev_id,
-			info->level);
+	fwol_nofl_debug("thermal evt: pdev %d lvl %d",
+			info->pdev_id, info->level);
 	if (info->pdev_id <= fwol_obj->thermal_throttle.pdev_id ||
 	    fwol_obj->thermal_throttle.pdev_id == WLAN_INVALID_PDEV_ID) {
 		fwol_obj->thermal_throttle.level = info->level;
@@ -212,18 +212,82 @@ notify_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc,
 
 	return status;
 }
+#endif
 
-static void tgt_fwol_register_thermal_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
+#ifdef THERMAL_STATS_SUPPORT
+static QDF_STATUS
+tgt_fwol_get_thermal_stats_resp(struct wlan_objmgr_psoc *psoc,
+				struct thermal_throttle_info *resp)
+{
+	QDF_STATUS status;
+	struct scheduler_msg msg = {0};
+	struct wlan_fwol_rx_event *event;
+
+	event = qdf_mem_malloc(sizeof(*event));
+	if (!event)
+		return QDF_STATUS_E_NOMEM;
+
+	status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_FWOL_SB_ID);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		fwol_err("Failed to get psoc ref");
+		fwol_release_rx_event(event);
+		return status;
+	}
+
+	event->psoc = psoc;
+	event->event_id = WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE;
+	event->get_thermal_stats_response = *resp;
+	msg.type = WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE;
+	msg.bodyptr = event;
+	msg.callback = fwol_process_event;
+	msg.flush_callback = fwol_flush_callback;
+	status = scheduler_post_message(QDF_MODULE_ID_FWOL,
+					QDF_MODULE_ID_FWOL,
+					QDF_MODULE_ID_TARGET_IF, &msg);
+
+	if (QDF_IS_STATUS_SUCCESS(status))
+		return QDF_STATUS_SUCCESS;
+
+	fwol_err("failed to send WLAN_FWOL_EVT_GET_THERMAL_STATS_RESPONSE msg");
+	fwol_flush_callback(&msg);
+
+	return status;
+
+}
+#endif
+
+#ifdef THERMAL_STATS_SUPPORT
+static void
+tgt_fwol_register_thermal_stats_resp(struct wlan_fwol_rx_ops *rx_ops)
+{
+	rx_ops->get_thermal_stats_resp = tgt_fwol_get_thermal_stats_resp;
+}
+#else
+static void
+tgt_fwol_register_thermal_stats_resp(struct wlan_fwol_rx_ops *rx_ops)
+{
+}
+#endif
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+static void
+tgt_fwol_register_notify_thermal_throttle_evt(struct wlan_fwol_rx_ops *rx_ops)
 {
 	rx_ops->notify_thermal_throttle_handler =
 					notify_thermal_throttle_handler;
 }
 #else
-static void tgt_fwol_register_thermal_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
+static void
+tgt_fwol_register_notify_thermal_throttle_evt(struct wlan_fwol_rx_ops *rx_ops)
 {
 }
 #endif
 
+static void tgt_fwol_register_thermal_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
+{
+	tgt_fwol_register_notify_thermal_throttle_evt(rx_ops);
+	tgt_fwol_register_thermal_stats_resp(rx_ops);
+}
+
 QDF_STATUS tgt_fwol_register_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
 {
 	tgt_fwol_register_elna_rx_ops(rx_ops);

components/fw_offload/dispatcher/src/wlan_fwol_ucfg_api.c

@@ -1072,6 +1072,96 @@ QDF_STATUS ucfg_fwol_set_mdns_config(struct wlan_objmgr_psoc *psoc,
 }
 #endif /* WLAN_FEATURE_MDNS_OFFLOAD */
 
+void ucfg_fwol_update_fw_cap_info(struct wlan_objmgr_psoc *psoc,
+				  struct wlan_fwol_capability_info *caps)
+{
+	struct wlan_fwol_psoc_obj *fwol_obj;
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		fwol_err("Failed to get fwol obj");
+		return;
+	}
+
+	qdf_mem_copy(&fwol_obj->capability_info, caps,
+		     sizeof(fwol_obj->capability_info));
+}
+
+#ifdef THERMAL_STATS_SUPPORT
+static QDF_STATUS
+ucfg_fwol_get_cap(struct wlan_objmgr_psoc *psoc,
+		  struct wlan_fwol_capability_info *cap_info)
+{
+	struct wlan_fwol_psoc_obj *fwol_obj;
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		fwol_err("Failed to get fwol obj");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (!cap_info) {
+		fwol_err("Failed to get fwol obj");
+		return QDF_STATUS_E_FAILURE;
+	}
+	*cap_info = fwol_obj->capability_info;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS ucfg_fwol_send_get_thermal_stats_cmd(struct wlan_objmgr_psoc *psoc,
+				       enum thermal_stats_request_type req_type,
+				       void (*callback)(void *context,
+				       struct thermal_throttle_info *response),
+				       void *context)
+{
+	QDF_STATUS status;
+	struct wlan_fwol_psoc_obj *fwol_obj;
+	struct wlan_fwol_tx_ops *tx_ops;
+	struct wlan_fwol_thermal_temp thermal_temp = {0};
+	struct wlan_fwol_capability_info cap_info;
+	struct wlan_fwol_callbacks *cbs;
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		fwol_err("Failed to get FWOL Obj");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = ucfg_fwol_get_thermal_temp(psoc, &thermal_temp);
+	if (QDF_IS_STATUS_ERROR(status))
+		return QDF_STATUS_E_INVAL;
+
+	status = ucfg_fwol_get_cap(psoc, &cap_info);
+	if (QDF_IS_STATUS_ERROR(status))
+		return QDF_STATUS_E_INVAL;
+
+	if (!thermal_temp.therm_stats_offset ||
+	    !cap_info.fw_thermal_stats_cap) {
+		fwol_err("Command Disabled in Ini gThermalStatsTempOffset %d or not enabled in FW %d",
+			 thermal_temp.therm_stats_offset,
+			 cap_info.fw_thermal_stats_cap);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	/* Registering Callback for the Request command */
+	if (callback && context) {
+		cbs = &fwol_obj->cbs;
+		cbs->get_thermal_stats_callback = callback;
+		cbs->get_thermal_stats_context = context;
+	}
+
+	tx_ops = &fwol_obj->tx_ops;
+	if (tx_ops && tx_ops->get_thermal_stats)
+		status = tx_ops->get_thermal_stats(psoc, req_type,
+					thermal_temp.therm_stats_offset);
+	else
+		status = QDF_STATUS_E_INVAL;
+
+	return status;
+}
+#endif /* THERMAL_STATS_SUPPORT */
+
 QDF_STATUS ucfg_fwol_configure_global_params(struct wlan_objmgr_psoc *psoc,
 					     struct wlan_objmgr_pdev *pdev)
 {

components/target_if/fw_offload/src/target_if_fwol.c

@@ -240,7 +240,86 @@ target_if_fwol_register_dscp_up_tx_ops(struct wlan_fwol_tx_ops *tx_ops)
 }
 #endif
 
+#ifdef THERMAL_STATS_SUPPORT
+/**
+ * target_if_fwol_get_thermal_stats() - send get thermal stats request to FW
+ * @psoc: pointer to PSOC object
+ * @req_type: get thermal stats request type
+ * @therm_stats_offset: thermal temp stats offset for each temp range
+ *
+ * Return: QDF_STATUS_SUCCESS on success
+ */
+static QDF_STATUS
+target_if_fwol_get_thermal_stats(struct wlan_objmgr_psoc *psoc,
+				 enum thermal_stats_request_type req_type,
+				 uint8_t therm_stats_offset)
+{
+	QDF_STATUS status;
+	wmi_unified_t wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
+
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi_handle");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_send_get_thermal_stats_cmd(wmi_handle, req_type,
+							therm_stats_offset);
+	if (status)
+		target_if_err("Failed to send get thermal stats cmd %d",
+			      status);
+
+	return status;
+}
+
+static void
+target_if_fwol_register_thermal_stats_tx_ops(struct wlan_fwol_tx_ops *tx_ops)
+{
+	tx_ops->get_thermal_stats = target_if_fwol_get_thermal_stats;
+}
+
+static QDF_STATUS
+target_if_fwol_handle_thermal_lvl_stats_evt(struct wlan_objmgr_psoc *psoc,
+					    struct wlan_fwol_rx_ops *rx_ops,
+					    struct thermal_throttle_info *info)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	if (rx_ops->get_thermal_stats_resp && info->therm_throt_levels)
+		status = rx_ops->get_thermal_stats_resp(psoc, info);
+
+	return status;
+}
+
+static bool
+target_if_fwol_is_thermal_stats_enable(struct wlan_fwol_psoc_obj *fwol_obj)
+{
+	return (fwol_obj->capability_info.fw_thermal_stats_cap &&
+		fwol_obj->cfg.thermal_temp_cfg.therm_stats_offset);
+}
+#else
+static void
+target_if_fwol_register_thermal_stats_tx_ops(struct wlan_fwol_tx_ops *tx_ops)
+{
+}
+
 #ifdef FW_THERMAL_THROTTLE_SUPPORT
+static QDF_STATUS
+target_if_fwol_handle_thermal_lvl_stats_evt(struct wlan_objmgr_psoc *psoc,
+					    struct wlan_fwol_rx_ops *rx_ops,
+					    struct thermal_throttle_info *info)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+
+static bool
+target_if_fwol_is_thermal_stats_enable(struct wlan_fwol_psoc_obj *fwol_obj)
+{
+	return false;
+}
+#endif
+#endif
+
+#if defined FW_THERMAL_THROTTLE_SUPPORT || defined THERMAL_STATS_SUPPORT
 /**
  * target_if_fwol_thermal_throttle_event_handler() - handler for thermal
  *  throttle event
@@ -254,7 +333,7 @@ static int
 target_if_fwol_thermal_throttle_event_handler(ol_scn_t scn, uint8_t *event_buf,
 					      uint32_t len)
 {
-	QDF_STATUS status;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	struct thermal_throttle_info info = {0};
 	struct wlan_objmgr_psoc *psoc;
 	wmi_unified_t wmi_handle;
@@ -285,16 +364,32 @@ target_if_fwol_thermal_throttle_event_handler(ol_scn_t scn, uint8_t *event_buf,
 		return -EINVAL;
 	}
 
+	status = wmi_extract_thermal_stats(wmi_handle,
+					   event_buf,
+					   &info.temperature,
+					   &info.level,
+					   &info.therm_throt_levels,
+					   info.level_info,
+					   &info.pdev_id);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		target_if_debug("Failed to convert thermal target level");
+		return -EINVAL;
+	}
 	rx_ops = &fwol_obj->rx_ops;
-	if (rx_ops->notify_thermal_throttle_handler) {
-		status = wmi_extract_thermal_stats(wmi_handle,
-						   event_buf,
-						   &info.temperature,
-						   &info.level,
-						   &info.pdev_id);
-		if (QDF_IS_STATUS_ERROR(status) ||
-		    info.level == THERMAL_UNKNOWN) {
-			target_if_debug("Failed to convert thermal target level");
+	if (!rx_ops) {
+		target_if_debug("rx_ops Null");
+		return -EINVAL;
+	}
+
+	status = target_if_fwol_handle_thermal_lvl_stats_evt(psoc, rx_ops,
+							     &info);
+	if (QDF_IS_STATUS_ERROR(status))
+		target_if_debug("thermal stats level response failed.");
+
+	if (rx_ops->notify_thermal_throttle_handler)
+	{
+		if (info.level == THERMAL_UNKNOWN) {
+			target_if_debug("Failed to convert thermal target lvl");
 			return -EINVAL;
 		}
 		status = rx_ops->notify_thermal_throttle_handler(psoc, &info);
@@ -306,9 +401,8 @@ target_if_fwol_thermal_throttle_event_handler(ol_scn_t scn, uint8_t *event_buf,
 		target_if_debug("No notify thermal_throttle callback");
 		return -EINVAL;
 	}
-
 	return 0;
-};
+}
 
 /**
  * target_if_fwol_register_thermal_throttle_handler() - Register handler for
@@ -328,8 +422,9 @@ target_if_fwol_register_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc)
 		target_if_err("Failed to get FWOL Obj");
 		return;
 	}
-	if (!fwol_obj->cfg.thermal_temp_cfg.thermal_mitigation_enable) {
-		target_if_debug("thermal mitigation offload not enabled");
+	if (!fwol_obj->cfg.thermal_temp_cfg.thermal_mitigation_enable &&
+	    !target_if_fwol_is_thermal_stats_enable(fwol_obj)) {
+		target_if_debug("thermal mitigation or stats offload not enabled");
 		return;
 	}
 	status = wmi_unified_register_event_handler(
@@ -360,6 +455,7 @@ target_if_fwol_unregister_thermal_throttle_handler(
 	if (QDF_IS_STATUS_ERROR(status))
 		target_if_debug("Failed to unregister thermal stats event cb");
 }
+
 #else
 static void
 target_if_fwol_register_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc)
@@ -438,6 +534,7 @@ QDF_STATUS target_if_fwol_register_tx_ops(struct wlan_fwol_tx_ops *tx_ops)
 	target_if_fwol_register_elna_tx_ops(tx_ops);
 	target_if_fwol_register_dscp_up_tx_ops(tx_ops);
 	target_if_fwol_register_mdns_tx_ops(tx_ops);
+	target_if_fwol_register_thermal_stats_tx_ops(tx_ops);
 
 	tx_ops->reg_evt_handler = target_if_fwol_register_event_handler;
 	tx_ops->unreg_evt_handler = target_if_fwol_unregister_event_handler;

configs/default_defconfig

@@ -279,6 +279,8 @@ CONFIG_QCOM_TDLS := y
 
 CONFIG_WLAN_SYSFS := y
 
+CONFIG_THERMAL_STATS_SUPPORT := y
+
 ifeq ($(CONFIG_WLAN_SYSFS), y)
 	CONFIG_WLAN_SYSFS_STA_INFO := y
 	CONFIG_WLAN_SYSFS_CHANNEL := y

core/hdd/inc/wlan_hdd_main.h

@@ -1878,7 +1878,6 @@ struct hdd_context {
 	qdf_spinlock_t hdd_adapter_lock;
 	qdf_list_t hdd_adapters; /* List of adapters */
 	bool is_therm_cmd_supp;
-
 	/** Pointer for firmware image data */
 	const struct firmware *fw;
 
@@ -2230,6 +2229,9 @@ struct hdd_context {
 #ifdef WLAN_FEATURE_11BE_MLO
 	struct hdd_mld_mac_info mld_mac_info;
 #endif
+#ifdef THERMAL_STATS_SUPPORT
+	bool is_therm_stats_in_progress;
+#endif
 };
 
 /**

core/hdd/src/wlan_hdd_main.c

@@ -13558,6 +13558,17 @@ static int hdd_init_mws_coex(struct hdd_context *hdd_ctx)
 }
 #endif
 
+#ifdef THERMAL_STATS_SUPPORT
+static void hdd_thermal_stats_cmd_init(struct hdd_context *hdd_ctx)
+{
+	hdd_send_get_thermal_stats_cmd(hdd_ctx, thermal_stats_init, NULL, NULL);
+}
+#else
+static void hdd_thermal_stats_cmd_init(struct hdd_context *hdd_ctx)
+{
+}
+#endif
+
 /**
  * hdd_features_init() - Init features
  * @hdd_ctx:	HDD context
@@ -13673,6 +13684,7 @@ static int hdd_features_init(struct hdd_context *hdd_ctx)
 		wlan_cm_set_6ghz_key_mgmt_mask(hdd_ctx->psoc,
 					       ALLOWED_KEYMGMT_6G_MASK);
 	}
+	hdd_thermal_stats_cmd_init(hdd_ctx);
 
 	hdd_exit();
 	return 0;

core/hdd/src/wlan_hdd_thermal.c

@@ -37,8 +37,12 @@
 #include "wlan_fwol_ucfg_api.h"
 #include <pld_common.h>
 #include "wlan_hdd_stats.h"
+#include "os_if_fwol.h"
+#include "wlan_osif_request_manager.h"
+#include "wlan_fwol_public_structs.h"
 
 #define DC_OFF_PERCENT_WPPS 50
+#define WLAN_WAIT_TIME_GET_THERM_LVL 1000
 
 const struct nla_policy
 	wlan_hdd_thermal_mitigation_policy
@@ -245,6 +249,223 @@ hdd_get_curr_thermal_temperature_val(struct hdd_context *hdd_ctx,
 	return wlan_cfg80211_vendor_cmd_reply(reply_skb);
 }
 
+#ifdef THERMAL_STATS_SUPPORT
+QDF_STATUS
+hdd_send_get_thermal_stats_cmd(struct hdd_context *hdd_ctx,
+			       enum thermal_stats_request_type request_type,
+			       void (*callback)(void *context,
+			       struct thermal_throttle_info *response),
+			       void *context)
+{
+	int ret;
+
+	if (!hdd_ctx->psoc) {
+		hdd_err_rl("NULL pointer for psoc");
+		return QDF_STATUS_E_INVAL;
+	}
+
+
+	/* Send Get Thermal Stats cmd to FW */
+	ret = os_if_fwol_get_thermal_stats_req(hdd_ctx->psoc, request_type,
+					       callback, context);
+	if (ret)
+		return QDF_STATUS_E_FAILURE;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * hdd_get_thermal_stats_cb() - Get thermal stats callback
+ * @context: Call context
+ * @response: Pointer to response structure
+ *
+ * Return: void
+ */
+static void
+hdd_get_thermal_stats_cb(void *context,
+			 struct thermal_throttle_info *response)
+{
+	struct osif_request *request;
+	struct thermal_throttle_info *priv;
+
+	request = osif_request_get(context);
+	if (!request) {
+		osif_err("Obsolete request");
+		return;
+	}
+
+	priv = osif_request_priv(request);
+	qdf_mem_copy(priv, response, sizeof(struct thermal_throttle_info));
+
+	osif_request_complete(request);
+	osif_request_put(request);
+}
+
+#define THERMAL_MIN_TEMP QCA_WLAN_VENDOR_ATTR_THERMAL_STATS_MIN_TEMPERATURE
+#define THERMAL_MAX_TEMP QCA_WLAN_VENDOR_ATTR_THERMAL_STATS_MAX_TEMPERATURE
+#define THERMAL_DWELL_TIME QCA_WLAN_VENDOR_ATTR_THERMAL_STATS_DWELL_TIME
+#define THERMAL_LVL_COUNT QCA_WLAN_VENDOR_ATTR_THERMAL_STATS_TEMP_LEVEL_COUNTER
+
+/**
+ * hdd_get_curr_thermal_stats_val() - Indicate thermal stats
+ *  to upper layer when query vendor command
+ * @wiphy: Pointer to wireless phy
+ * @hdd_ctx: hdd context
+ *
+ * Return: 0 for success
+ */
+static int
+hdd_get_curr_thermal_stats_val(struct wiphy *wiphy,
+			       struct hdd_context *hdd_ctx)
+{
+	int ret = 0;
+	uint8_t i = 0;
+	struct osif_request *request = NULL;
+	int skb_len = 0;
+	struct thermal_throttle_info *priv;
+	struct thermal_throttle_info *get_tt_stats = NULL;
+	struct sk_buff *skb = NULL;
+	void *cookie;
+	struct nlattr *therm_attr;
+	struct nlattr *tt_levels;
+	static const struct osif_request_params params = {
+		.priv_size = sizeof(*priv),
+		.timeout_ms = WLAN_WAIT_TIME_GET_THERM_LVL,
+		.dealloc = NULL,
+	};
+
+	if (hdd_ctx->is_therm_stats_in_progress) {
+		hdd_err("request already in progress");
+		return -EINVAL;
+	}
+
+	request = osif_request_alloc(&params);
+	if (!request) {
+		hdd_err("request allocation failure");
+		return -ENOMEM;
+	}
+	cookie = osif_request_cookie(request);
+	hdd_ctx->is_therm_stats_in_progress = true;
+	ret = hdd_send_get_thermal_stats_cmd(hdd_ctx, thermal_stats_req,
+					     hdd_get_thermal_stats_cb,
+					     cookie);
+	if (QDF_IS_STATUS_ERROR(ret)) {
+		hdd_err("Failure while sending command to fw");
+		ret = -EAGAIN;
+		goto completed;
+	}
+
+	ret = osif_request_wait_for_response(request);
+	if (ret) {
+		hdd_err("Timed out while retrieving thermal stats");
+		ret = -EAGAIN;
+		goto completed;
+	}
+
+	get_tt_stats = osif_request_priv(request);
+	if (!get_tt_stats) {
+		hdd_err("invalid get_tt_stats");
+		ret = -EINVAL;
+		goto completed;
+	}
+
+	skb_len = NLMSG_HDRLEN + (get_tt_stats->therm_throt_levels) *
+		  (NLA_HDRLEN + (NLA_HDRLEN +
+		     sizeof(get_tt_stats->level_info[i].start_temp_level) +
+		     NLA_HDRLEN +
+		     sizeof(get_tt_stats->level_info[i].end_temp_level) +
+		     NLA_HDRLEN +
+		     sizeof(get_tt_stats->level_info[i].total_time_ms_lo) +
+		     NLA_HDRLEN +
+		     sizeof(get_tt_stats->level_info[i].num_entry)));
+
+	skb = wlan_cfg80211_vendor_cmd_alloc_reply_skb(wiphy,
+						       skb_len);
+	if (!skb) {
+		hdd_err_rl("cfg80211_vendor_cmd_alloc_reply_skb failed");
+		ret = -ENOMEM;
+		goto completed;
+	}
+
+	therm_attr = nla_nest_start(skb, QCA_WLAN_VENDOR_ATTR_THERMAL_STATS);
+	if (!therm_attr) {
+		hdd_err_rl("nla_nest_start failed for attr failed");
+		ret = -EINVAL;
+		goto completed;
+	}
+
+	for (i = 0; i < get_tt_stats->therm_throt_levels; i++) {
+		tt_levels = nla_nest_start(skb, i);
+		if (!tt_levels) {
+			hdd_err_rl("nla_nest_start failed for thermal level %d",
+				   i);
+			ret = -EINVAL;
+			goto completed;
+		}
+
+		hdd_debug("level %d, Temp Range: %d - %d, Dwell time %d, Counter %d",
+			  i, get_tt_stats->level_info[i].start_temp_level,
+			  get_tt_stats->level_info[i].end_temp_level,
+			  get_tt_stats->level_info[i].total_time_ms_lo,
+			  get_tt_stats->level_info[i].num_entry);
+
+		if (nla_put_u32(skb, THERMAL_MIN_TEMP,
+				get_tt_stats->level_info[i].start_temp_level) ||
+		    nla_put_u32(skb, THERMAL_MAX_TEMP,
+				get_tt_stats->level_info[i].end_temp_level) ||
+		    nla_put_u32(skb, THERMAL_DWELL_TIME,
+				(get_tt_stats->level_info[i].total_time_ms_lo)) ||
+		    nla_put_u32(skb, THERMAL_LVL_COUNT,
+				get_tt_stats->level_info[i].num_entry)) {
+			hdd_err("nla put failure");
+			kfree_skb(skb);
+			ret =  -EINVAL;
+			hdd_ctx->is_therm_stats_in_progress = false;
+			break;
+		}
+		nla_nest_end(skb, tt_levels);
+	}
+	nla_nest_end(skb, therm_attr);
+	wlan_cfg80211_vendor_cmd_reply(skb);
+
+completed:
+	hdd_ctx->is_therm_stats_in_progress = false;
+	osif_request_put(request);
+
+	return ret;
+}
+
+#undef THERMAL_MIN_TEMP
+#undef THERMAL_MAX_TEMP
+#undef THERMAL_DWELL_TIME
+#undef THERMAL_LVL_COUNT
+
+static QDF_STATUS
+hdd_send_thermal_stats_clear_cmd(struct hdd_context *hdd_ctx)
+{
+	QDF_STATUS status;
+
+	status = hdd_send_get_thermal_stats_cmd(hdd_ctx,
+					     thermal_stats_clear, NULL,
+					     NULL);
+
+	return status;
+}
+#else
+static int
+hdd_get_curr_thermal_stats_val(struct wiphy *wiphy,
+			       struct hdd_context *hdd_ctx)
+{
+	return -EINVAL;
+}
+
+static QDF_STATUS
+hdd_send_thermal_stats_clear_cmd(struct hdd_context *hdd_ctx)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+#endif /* THERMAL_STATS_SUPPORT */
+
 /**
  * __wlan_hdd_cfg80211_set_thermal_mitigation_policy() - Set the thermal policy
  * @wiphy: Pointer to wireless phy
@@ -313,6 +534,16 @@ __wlan_hdd_cfg80211_set_thermal_mitigation_policy(struct wiphy *wiphy,
 	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_GET_TEMPERATURE:
 		ret = hdd_get_curr_thermal_temperature_val(hdd_ctx, adapter);
 		break;
+	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_GET_THERMAL_STATS:
+		ret = hdd_get_curr_thermal_stats_val(wiphy, hdd_ctx);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_CLEAR_THERMAL_STATS:
+		status = hdd_send_thermal_stats_clear_cmd(hdd_ctx);
+		if (QDF_IS_STATUS_ERROR(status)) {
+			hdd_err("Failure while sending command to fw");
+			ret = -EINVAL;
+		}
+		break;
 	default:
 		ret = -EINVAL;
 	}

core/hdd/src/wlan_hdd_thermal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-2021 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
@@ -232,4 +232,13 @@ hdd_thermal_unregister_callbacks(struct hdd_context *hdd_ctx)
 {
 }
 #endif /* FEATURE_THERMAL_VENDOR_COMMANDS */
+
+#ifdef THERMAL_STATS_SUPPORT
+QDF_STATUS
+hdd_send_get_thermal_stats_cmd(struct hdd_context *hdd_ctx,
+			       enum thermal_stats_request_type request_type,
+			       void (*callback)(void *context,
+			       struct thermal_throttle_info *response),
+			       void *context);
+#endif /* THERMAL_STATS_SUPPORT */
 #endif /* __HDD_THERMAL_H */

core/wma/src/wma_main.c

@@ -116,6 +116,7 @@
 
 #include "wlan_pkt_capture_ucfg_api.h"
 #include "target_if_cm_roam_event.h"
+#include "wlan_fwol_ucfg_api.h"
 
 #define WMA_LOG_COMPLETION_TIMER 3000 /* 3 seconds */
 #define WMI_TLV_HEADROOM 128
@@ -5843,11 +5844,52 @@ static void wma_set_mc_cp_caps(struct wlan_objmgr_psoc *psoc)
 		ucfg_mc_cp_set_big_data_fw_support(psoc, false);
 }
 
+#ifdef THERMAL_STATS_SUPPORT
+static void wma_set_thermal_stats_fw_cap(tp_wma_handle wma,
+					 struct wlan_fwol_capability_info *cap)
+{
+	cap->fw_thermal_stats_cap = wmi_service_enabled(wma->wmi_handle,
+				wmi_service_thermal_stats_temp_range_supported);
+}
+#else
+static void wma_set_thermal_stats_fw_cap(tp_wma_handle wma,
+					 struct wlan_fwol_capability_info *cap)
+{
+}
+#endif
+
+/**
+ * wma_set_fwol_caps() - Populate fwol component related capabilities
+ *			 to the fwol component
+ *
+ * @psoc: Pointer to psoc object
+ *
+ * Return: None
+ */
+static void wma_set_fwol_caps(struct wlan_objmgr_psoc *psoc)
+{
+	tp_wma_handle wma;
+	struct wlan_fwol_capability_info cap_info;
+	wma = cds_get_context(QDF_MODULE_ID_WMA);
+
+	if (!wma) {
+		wma_err_rl("wma Null");
+		return;
+	}
+	if (!psoc) {
+		wma_err_rl("psoc Null");
+		return;
+	}
+
+	wma_set_thermal_stats_fw_cap(wma, &cap_info);
+	ucfg_fwol_update_fw_cap_info(psoc, &cap_info);
+}
 static void wma_set_component_caps(struct wlan_objmgr_psoc *psoc)
 {
 	wma_set_pmo_caps(psoc);
 	wma_set_mlme_caps(psoc);
 	wma_set_mc_cp_caps(psoc);
+	wma_set_fwol_caps(psoc);
 }
 
 #if defined(WLAN_FEATURE_GTK_OFFLOAD) && defined(WLAN_POWER_MANAGEMENT_OFFLOAD)

os_if/fw_offload/inc/os_if_fwol.h

@@ -116,4 +116,12 @@ static inline int os_if_fwol_disable_mdns_offload(struct wlan_objmgr_psoc *psoc)
 }
 #endif /* WLAN_FEATURE_MDNS_OFFLOAD */
 
+#ifdef THERMAL_STATS_SUPPORT
+int os_if_fwol_get_thermal_stats_req(struct wlan_objmgr_psoc *psoc,
+				     enum thermal_stats_request_type req,
+				     void (*callback)(void *context,
+				     struct thermal_throttle_info *response),
+				     void *context);
+#endif /* THERMAL_STATS_SUPPORT */
+
 #endif /* __OS_IF_FWOL_H__ */

os_if/fw_offload/src/os_if_fwol.c

@@ -198,3 +198,23 @@ out:
 	return ret;
 }
 #endif /* WLAN_FEATURE_MDNS_OFFLOAD */
+
+#ifdef THERMAL_STATS_SUPPORT
+int os_if_fwol_get_thermal_stats_req(struct wlan_objmgr_psoc *psoc,
+				     enum thermal_stats_request_type req,
+				     void (*callback)(void *context,
+				     struct thermal_throttle_info *response),
+				     void *context)
+{
+	QDF_STATUS status;
+
+
+	status = ucfg_fwol_send_get_thermal_stats_cmd(psoc, req, callback,
+						      context);
+	if (!QDF_IS_STATUS_SUCCESS(status))
+		osif_err("Failed to send get thermal stats cmd to FW, %d",
+			 status);
+
+	return qdf_status_to_os_return(status);
+}
+#endif