qcacld-3.0: Handle thermal stats event from target

Handle firmware thermal stats event and populate the thermal
information to upper layer with vendor command event.

Change-Id: I83286367ab542c08a205a7636f3d03189b0500e5
CRs-Fixed: 2786623

Kbuild

@@ -1196,7 +1196,8 @@ FWOL_OS_IF_SRC := os_if/fw_offload/src
 FWOL_INC := -I$(WLAN_ROOT)/$(FWOL_CORE_INC) \
 	    -I$(WLAN_ROOT)/$(FWOL_DISPATCHER_INC) \
 	    -I$(WLAN_ROOT)/$(FWOL_TARGET_IF_INC) \
-	    -I$(WLAN_ROOT)/$(FWOL_OS_IF_INC)
+	    -I$(WLAN_ROOT)/$(FWOL_OS_IF_INC) \
+	    -I$(WLAN_COMMON_INC)/umac/thermal/dispatcher/inc
 
 FWOL_OBJS :=	$(FWOL_CORE_SRC)/wlan_fw_offload_main.o \
 		$(FWOL_DISPATCHER_SRC)/wlan_fwol_ucfg_api.o \

components/fw_offload/core/inc/wlan_fw_offload_main.h

@@ -266,18 +266,32 @@ struct wlan_fwol_cfg {
 	bool enable_ilp;
 };
 
+/**
+ * struct wlan_fwol_thermal_throttle_info - FW offload thermal throttle info
+ * @level: thermal throttle level
+ */
+struct wlan_fwol_thermal_throttle_info {
+	enum thermal_throttle_level level;
+};
+
 /**
  * struct wlan_fwol_psoc_obj - FW offload psoc priv object
  * @cfg:     cfg items
  * @cbs:     callback functions
  * @tx_ops: tx operations for target interface
  * @rx_ops: rx operations for target interface
+ * @thermal_throttle: cached target thermal stats information
+ * @thermal_cbs: thermal notification callbacks to hdd layer
  */
 struct wlan_fwol_psoc_obj {
 	struct wlan_fwol_cfg cfg;
 	struct wlan_fwol_callbacks cbs;
 	struct wlan_fwol_tx_ops tx_ops;
 	struct wlan_fwol_rx_ops rx_ops;
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+	struct wlan_fwol_thermal_throttle_info thermal_throttle;
+	struct fwol_thermal_callbacks thermal_cbs;
+#endif
 };
 
 /**

components/fw_offload/dispatcher/inc/wlan_fwol_public_structs.h

@@ -24,6 +24,7 @@
 #define _WLAN_FWOL_PUBLIC_STRUCTS_H_
 
 #include "wlan_objmgr_psoc_obj.h"
+#include "wlan_thermal_public_struct.h"
 
 #ifdef WLAN_FEATURE_ELNA
 /**
@@ -70,6 +71,18 @@ struct wlan_fwol_callbacks {
 #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;
+};
+
 /**
  * struct wlan_fwol_tx_ops - structure of tx func pointers
  * @set_elna_bypass: set eLNA bypass
@@ -99,13 +112,29 @@ struct wlan_fwol_tx_ops {
 /**
  * struct wlan_fwol_rx_ops - structure of rx func pointers
  * @get_elna_bypass_resp: get eLNA bypass response
+ * @notify_thermal_throttle_handler: thermal stats indication callback to fwol
+ *  core from target if layer
  */
 struct wlan_fwol_rx_ops {
 #ifdef WLAN_FEATURE_ELNA
 	QDF_STATUS (*get_elna_bypass_resp)(struct wlan_objmgr_psoc *psoc,
 					 struct get_elna_bypass_response *resp);
 #endif
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+	QDF_STATUS (*notify_thermal_throttle_handler)(
+				struct wlan_objmgr_psoc *psoc,
+				struct thermal_throttle_info *info);
+#endif
 };
 
+/**
+ * struct fwol_thermal_callbacks - structure of rx callback to hdd layer
+ * @notify_thermal_throttle_handler: thermal throttle event callback
+ */
+struct fwol_thermal_callbacks {
+	QDF_STATUS (*notify_thermal_throttle_handler)(
+					struct wlan_objmgr_psoc *psoc,
+					struct thermal_throttle_info *info);
+};
 #endif /* _WLAN_FWOL_PUBLIC_STRUCTS_H_ */
 

components/fw_offload/dispatcher/inc/wlan_fwol_ucfg_api.h

@@ -49,6 +49,22 @@ QDF_STATUS ucfg_fwol_psoc_open(struct wlan_objmgr_psoc *psoc);
  */
 void ucfg_fwol_psoc_close(struct wlan_objmgr_psoc *psoc);
 
+/**
+ * ucfg_fwol_psoc_enable() - FWOL component enable
+ * @psoc: pointer to psoc object
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS ucfg_fwol_psoc_enable(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * ucfg_fwol_psoc_close() - FWOL component disable
+ * @psoc: pointer to psoc object
+ *
+ * Return: None
+ */
+void ucfg_fwol_psoc_disable(struct wlan_objmgr_psoc *psoc);
+
 /**
  * ucfg_fwol_init() - initialize fwol_ctx context.
  *
@@ -67,6 +83,66 @@ QDF_STATUS ucfg_fwol_init(void);
  */
 void ucfg_fwol_deinit(void);
 
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+/**
+ * ucfg_fwol_thermal_register_callbacks() - Register thermal callbacks
+ * to be called by fwol thermal
+ * @psoc: psoc object
+ * @cb: callback functions
+ *
+ * Currently only one callback notify_thermal_throttle_handler can be
+ * registered to fwol thermal core. The client will be notified by the callback
+ * when new thermal throttle level is changed in target.
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS ucfg_fwol_thermal_register_callbacks(
+				struct wlan_objmgr_psoc *psoc,
+				struct fwol_thermal_callbacks *cb);
+
+/**
+ * ucfg_fwol_thermal_unregister_callbacks() - unregister thermal callbacks
+ * @psoc: psoc object
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS ucfg_fwol_thermal_unregister_callbacks(
+				struct wlan_objmgr_psoc *psoc);
+
+/**
+ * ucfg_fwol_thermal_get_target_level() - get thermal level based on cached
+ *  target thermal throttle level
+ * @psoc: psoc object
+ * @level: target thermal throttle level info
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+ucfg_fwol_thermal_get_target_level(struct wlan_objmgr_psoc *psoc,
+				   enum thermal_throttle_level *level);
+#else
+static inline QDF_STATUS ucfg_fwol_thermal_register_callbacks(
+				struct wlan_objmgr_psoc *psoc,
+				struct fwol_thermal_callbacks *cb)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS ucfg_fwol_thermal_unregister_callbacks(
+				struct wlan_objmgr_psoc *psoc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS
+ucfg_fwol_thermal_get_target_level(struct wlan_objmgr_psoc *psoc,
+				   enum thermal_throttle_level *level)
+
+{
+	return QDF_STATUS_E_FAILURE;
+}
+#endif
+
 /**
  * ucfg_fwol_get_coex_config_params() - Get coex config params
  * @psoc: Pointer to psoc object
@@ -614,6 +690,15 @@ static inline void ucfg_fwol_psoc_close(struct wlan_objmgr_psoc *psoc)
 {
 }
 
+static inline QDF_STATUS ucfg_fwol_psoc_enable(struct wlan_objmgr_psoc *psoc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline void ucfg_fwol_psoc_disable(struct wlan_objmgr_psoc *psoc)
+{
+}
+
 static inline QDF_STATUS ucfg_fwol_init(void)
 {
 	return QDF_STATUS_SUCCESS;
@@ -623,6 +708,26 @@ static inline void ucfg_fwol_deinit(void)
 {
 }
 
+static inline QDF_STATUS ucfg_fwol_thermal_register_callbacks(
+				struct wlan_objmgr_psoc *psoc,
+				struct fwol_thermal_callbacks *cb)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS ucfg_fwol_thermal_unregister_callbacks(
+				struct wlan_objmgr_psoc *psoc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS
+ucfg_fwol_thermal_get_target_level(struct wlan_objmgr_psoc *psoc,
+				   enum thermal_throttle_level *level)
+{
+	return QDF_STATUS_E_FAILURE;
+}
+
 static inline QDF_STATUS
 ucfg_fwol_get_coex_config_params(struct wlan_objmgr_psoc *psoc,
 				 struct wlan_fwol_coex_config *coex_config)

components/fw_offload/dispatcher/src/wlan_fwol_tgt_api.c

@@ -166,9 +166,61 @@ static void tgt_fwol_register_elna_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
 }
 #endif /* WLAN_FEATURE_ELNA */
 
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+/**
+ * notify_thermal_throttle_handler() - Thermal throttle stats event handler
+ * @psoc: psoc object
+ * @info: thermal throttle stats info from target if layer
+ *
+ * The handle will be registered to target if layer. Target if layer
+ * will notify the new level from firmware thermal stats event.
+ *
+ * Return: QDF_STATUS_SUCCESS for success
+ */
+static QDF_STATUS
+notify_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc,
+				struct thermal_throttle_info *info)
+{
+	struct wlan_fwol_psoc_obj *fwol_obj;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct fwol_thermal_callbacks *thermal_cbs;
+
+	if (!psoc) {
+		fwol_err("NULL psoc handle");
+		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;
+	}
+	thermal_cbs = &fwol_obj->thermal_cbs;
+	fwol_obj->thermal_throttle.level = info->level;
+	if (thermal_cbs->notify_thermal_throttle_handler)
+		status = thermal_cbs->notify_thermal_throttle_handler(psoc,
+								      info);
+	else
+		fwol_debug("no thermal throttle handler");
+
+	return status;
+}
+
+static void tgt_fwol_register_thermal_rx_ops(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)
+{
+}
+#endif
+
 QDF_STATUS tgt_fwol_register_rx_ops(struct wlan_fwol_rx_ops *rx_ops)
 {
 	tgt_fwol_register_elna_rx_ops(rx_ops);
+	tgt_fwol_register_thermal_rx_ops(rx_ops);
 
 	return QDF_STATUS_SUCCESS;
 }

components/fw_offload/dispatcher/src/wlan_fwol_ucfg_api.c

@@ -34,15 +34,23 @@ QDF_STATUS ucfg_fwol_psoc_open(struct wlan_objmgr_psoc *psoc)
 	if (QDF_IS_STATUS_ERROR(status))
 		fwol_err("Failed to initialize FWOL CFG");
 
-	tgt_fwol_register_ev_handler(psoc);
-
 	return status;
 }
 
 void ucfg_fwol_psoc_close(struct wlan_objmgr_psoc *psoc)
 {
 	/* Clear the FWOL CFG Structure */
+}
 
+QDF_STATUS ucfg_fwol_psoc_enable(struct wlan_objmgr_psoc *psoc)
+{
+	tgt_fwol_register_ev_handler(psoc);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+void ucfg_fwol_psoc_disable(struct wlan_objmgr_psoc *psoc)
+{
 	tgt_fwol_unregister_ev_handler(psoc);
 }
 
@@ -160,6 +168,55 @@ void ucfg_fwol_deinit(void)
 		fwol_err("unable to unregister psoc create handle");
 }
 
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+QDF_STATUS ucfg_fwol_thermal_register_callbacks(
+				struct wlan_objmgr_psoc *psoc,
+				struct fwol_thermal_callbacks *cb)
+{
+	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;
+	}
+	fwol_obj->thermal_cbs = *cb;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS ucfg_fwol_thermal_unregister_callbacks(
+				struct wlan_objmgr_psoc *psoc)
+{
+	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;
+	}
+	qdf_mem_zero(&fwol_obj->thermal_cbs, sizeof(fwol_obj->thermal_cbs));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+ucfg_fwol_thermal_get_target_level(struct wlan_objmgr_psoc *psoc,
+				   enum thermal_throttle_level *level)
+{
+	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;
+	}
+	*level = fwol_obj->thermal_throttle.level;
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
 QDF_STATUS
 ucfg_fwol_get_coex_config_params(struct wlan_objmgr_psoc *psoc,
 				 struct wlan_fwol_coex_config *coex_config)

components/target_if/fw_offload/src/target_if_fwol.c

@@ -240,10 +240,143 @@ target_if_fwol_register_dscp_up_tx_ops(struct wlan_fwol_tx_ops *tx_ops)
 }
 #endif
 
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+/**
+ * target_if_fwol_thermal_throttle_event_handler() - handler for thermal
+ *  throttle event
+ * @scn: scn handle
+ * @event_buf: pointer to the event buffer
+ * @len: length of the buffer
+ *
+ * Return: 0 on success
+ */
+static int
+target_if_fwol_thermal_throttle_event_handler(ol_scn_t scn, uint8_t *event_buf,
+					      uint32_t len)
+{
+	QDF_STATUS status;
+	struct thermal_throttle_info info = {0};
+	struct wlan_objmgr_psoc *psoc;
+	wmi_unified_t wmi_handle;
+	struct wlan_fwol_psoc_obj *fwol_obj;
+	struct wlan_fwol_rx_ops *rx_ops;
+
+	target_if_debug("scn:%pK, data:%pK, datalen:%d", scn, event_buf, len);
+	if (!scn || !event_buf) {
+		target_if_err("scn: 0x%pK, data: 0x%pK", scn, event_buf);
+		return -EINVAL;
+	}
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("null psoc");
+		return -EINVAL;
+	}
+
+	wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
+	if (!wmi_handle) {
+		target_if_err("Invalid wmi_handle");
+		return -EINVAL;
+	}
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		target_if_err("Failed to get FWOL Obj");
+		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");
+			return -EINVAL;
+		}
+		status = rx_ops->notify_thermal_throttle_handler(psoc, &info);
+		if (QDF_IS_STATUS_ERROR(status)) {
+			target_if_debug("notify thermal_throttle failed.");
+			return -EINVAL;
+		}
+	} else {
+		target_if_debug("No notify thermal_throttle callback");
+		return -EINVAL;
+	}
+
+	return 0;
+};
+
+/**
+ * target_if_fwol_register_thermal_throttle_handler() - Register handler for
+ * thermal throttle stats firmware event
+ * @psoc: psoc object
+ *
+ * Return: void
+ */
+static void
+target_if_fwol_register_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc)
+{
+	QDF_STATUS status;
+	struct wlan_fwol_psoc_obj *fwol_obj;
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		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");
+		return;
+	}
+	status = wmi_unified_register_event(
+				get_wmi_unified_hdl_from_psoc(psoc),
+				wmi_tt_stats_event_id,
+				target_if_fwol_thermal_throttle_event_handler);
+	if (QDF_IS_STATUS_ERROR(status))
+		target_if_debug("Failed to register thermal stats event cb");
+}
+
+/**
+ * target_if_fwol_unregister_thermal_stats_handler() - Register handler for
+ * thermal throttle stats firmware event
+ * @psoc: psoc object
+ *
+ * Return: void
+ */
+static void
+target_if_fwol_unregister_thermal_throttle_handler(
+					struct wlan_objmgr_psoc *psoc)
+{
+	QDF_STATUS status;
+
+	status = wmi_unified_unregister_event_handler(
+				get_wmi_unified_hdl_from_psoc(psoc),
+				wmi_tt_stats_event_id);
+	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)
+{
+}
+
+static void
+target_if_fwol_unregister_thermal_throttle_handler(
+					struct wlan_objmgr_psoc *psoc)
+{
+}
+#endif
+
 QDF_STATUS target_if_fwol_register_event_handler(struct wlan_objmgr_psoc *psoc,
 						 void *arg)
 {
 	target_if_fwol_register_elna_event_handler(psoc, arg);
+	target_if_fwol_register_thermal_throttle_handler(psoc);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -252,6 +385,7 @@ QDF_STATUS
 target_if_fwol_unregister_event_handler(struct wlan_objmgr_psoc *psoc,
 					void *arg)
 {
+	target_if_fwol_unregister_thermal_throttle_handler(psoc);
 	target_if_fwol_unregister_elna_event_handler(psoc, arg);
 
 	return QDF_STATUS_SUCCESS;

core/hdd/src/wlan_hdd_cfg80211.c

@@ -1669,7 +1669,8 @@ static const struct nl80211_vendor_cmd_info wlan_hdd_cfg80211_vendor_events[] =
 	[QCA_NL80211_VENDOR_SUBCMD_UPDATE_STA_INFO_INDEX] = {
 		.vendor_id = QCA_NL80211_VENDOR_ID,
 		.subcmd = QCA_NL80211_VENDOR_SUBCMD_UPDATE_STA_INFO,
-	}
+	},
+	FEATURE_THERMAL_VENDOR_EVENTS
 };
 
 /**

core/hdd/src/wlan_hdd_main.c

@@ -195,6 +195,7 @@
 #include "wlan_cm_roam_ucfg_api.h"
 #include <cdp_txrx_ctrl.h>
 #include "qdf_lock.h"
+#include "wlan_hdd_thermal.h"
 
 #ifdef MODULE
 #define WLAN_MODULE_NAME  module_name(THIS_MODULE)
@@ -15034,6 +15035,7 @@ int hdd_register_cb(struct hdd_context *hdd_ctx)
 	wlan_hdd_register_cp_stats_cb(hdd_ctx);
 	hdd_dcs_register_cb(hdd_ctx);
 
+	hdd_thermal_register_callbacks(hdd_ctx);
 	/* print error and not block the startup process */
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("set lost link info callback failed");
@@ -15122,7 +15124,7 @@ void hdd_deregister_cb(struct hdd_context *hdd_ctx)
 	ret = hdd_deregister_data_stall_detect_cb();
 	if (ret)
 		hdd_err("Failed to de-register data stall detect event callback");
-
+	hdd_thermal_unregister_callbacks(hdd_ctx);
 	sme_deregister_oem_data_rsp_callback(mac_handle);
 
 	hdd_exit();
@@ -16284,10 +16286,12 @@ void hdd_component_psoc_enable(struct wlan_objmgr_psoc *psoc)
 	ucfg_interop_issues_ap_psoc_enable(psoc);
 	policy_mgr_psoc_enable(psoc);
 	ucfg_tdls_psoc_enable(psoc);
+	ucfg_fwol_psoc_enable(psoc);
 }
 
 void hdd_component_psoc_disable(struct wlan_objmgr_psoc *psoc)
 {
+	ucfg_fwol_psoc_disable(psoc);
 	ucfg_tdls_psoc_disable(psoc);
 	policy_mgr_psoc_disable(psoc);
 	ucfg_interop_issues_ap_psoc_disable(psoc);

core/hdd/src/wlan_hdd_thermal.c

@@ -36,6 +36,7 @@
 #include <qca_vendor.h>
 #include "wlan_fwol_ucfg_api.h"
 #include <pld_common.h>
+#include "wlan_hdd_stats.h"
 
 #define DC_OFF_PERCENT_WPPS 50
 
@@ -143,6 +144,105 @@ hdd_send_thermal_mitigation_val(struct hdd_context *hdd_ctx, uint32_t level,
 	return QDF_STATUS_SUCCESS;
 }
 
+/**
+ * convert_level_to_vendor_thermal_level() - convert internal thermal level
+ *  to vendor command attribute enum qca_wlan_vendor_thermal_level
+ * @level: driver internal thermal level
+ *
+ * Return: vendor thermal level
+ */
+static enum qca_wlan_vendor_thermal_level
+convert_level_to_vendor_thermal_level(enum thermal_throttle_level level)
+{
+	if (level == THERMAL_FULLPERF)
+		return QCA_WLAN_VENDOR_THERMAL_LEVEL_NONE;
+	else if (level == THERMAL_MITIGATION)
+		return QCA_WLAN_VENDOR_THERMAL_LEVEL_MODERATE;
+	else
+		return QCA_WLAN_VENDOR_THERMAL_LEVEL_EMERGENCY;
+}
+
+/**
+ * hdd_get_curr_thermal_throttle_level_val() - Indicate current target
+ *  thermal throttle level to upper layer upon query level
+ * @hdd_ctx: hdd context
+ *
+ * Return: 0 for success
+ */
+static int
+hdd_get_curr_thermal_throttle_level_val(struct hdd_context *hdd_ctx)
+{
+	struct sk_buff *reply_skb;
+	uint32_t data_len;
+	enum thermal_throttle_level level = THERMAL_FULLPERF;
+	enum qca_wlan_vendor_thermal_level vendor_level;
+	QDF_STATUS status;
+
+	status = ucfg_fwol_thermal_get_target_level(hdd_ctx->psoc, &level);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		hdd_err("get_thermal level: fail get target level");
+		return -EINVAL;
+	}
+	vendor_level = convert_level_to_vendor_thermal_level(level);
+	data_len = NLMSG_HDRLEN + nla_total_size(sizeof(uint32_t));
+	reply_skb = wlan_cfg80211_vendor_cmd_alloc_reply_skb(hdd_ctx->wiphy,
+							     data_len);
+	if (!reply_skb) {
+		hdd_err("get_thermal level: buffer alloc fail");
+		return -ENOMEM;
+	}
+	if (nla_put_u32(reply_skb, QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL,
+			vendor_level)) {
+		hdd_err("get_thermal level: nla put fail");
+		wlan_cfg80211_vendor_free_skb(reply_skb);
+		return -EINVAL;
+	}
+	hdd_debug("get_thermal level: %d vendor level %d", level,
+		  vendor_level);
+
+	return wlan_cfg80211_vendor_cmd_reply(reply_skb);
+}
+
+/**
+ * hdd_get_curr_thermal_temperature_val() - Indicate current target
+ *  thermal temperature to upper layer when handing temperature
+ *  query vendor command
+ * @hdd_ctx: hdd context
+ * @adapter: adapter context
+ *
+ * Return: 0 for success
+ */
+static int
+hdd_get_curr_thermal_temperature_val(struct hdd_context *hdd_ctx,
+				     struct hdd_adapter *adapter)
+{
+	struct sk_buff *reply_skb;
+	int ret;
+	uint32_t data_len;
+	int temperature = 0;
+
+	ret = wlan_hdd_get_temperature(adapter, &temperature);
+	if (ret)
+		return ret;
+	data_len = NLMSG_HDRLEN + nla_total_size(sizeof(uint32_t));
+	reply_skb = wlan_cfg80211_vendor_cmd_alloc_reply_skb(hdd_ctx->wiphy,
+							     data_len);
+	if (!reply_skb) {
+		hdd_err("get_thermal temperature: buffer alloc fail");
+		return -ENOMEM;
+	}
+	if (nla_put_u32(reply_skb,
+			QCA_WLAN_VENDOR_ATTR_THERMAL_GET_TEMPERATURE_DATA,
+			temperature)) {
+		hdd_err("get_thermal temperature: nla put fail");
+		wlan_cfg80211_vendor_free_skb(reply_skb);
+		return -EINVAL;
+	}
+	hdd_debug("get_thermal temperature: %d", temperature);
+
+	return wlan_cfg80211_vendor_cmd_reply(reply_skb);
+}
+
 /**
  * __wlan_hdd_cfg80211_set_thermal_mitigation_policy() - Set the thermal policy
  * @wiphy: Pointer to wireless phy
@@ -159,12 +259,19 @@ __wlan_hdd_cfg80211_set_thermal_mitigation_policy(struct wiphy *wiphy,
 						  int data_len)
 {
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
+	struct net_device *dev = wdev->netdev;
+	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_MAX + 1];
 	uint32_t level, cmd_type;
 	QDF_STATUS status;
+	int ret;
 
 	hdd_enter();
 
+	ret = wlan_hdd_validate_context(hdd_ctx);
+	if (ret)
+		return -EINVAL;
+
 	if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
 		hdd_err_rl("Command not allowed in FTM mode");
 		return -EPERM;
@@ -184,23 +291,32 @@ __wlan_hdd_cfg80211_set_thermal_mitigation_policy(struct wiphy *wiphy,
 	}
 
 	cmd_type = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_VALUE]);
-	if (cmd_type != QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_SET_LEVEL) {
-		hdd_err_rl("invalid thermal cmd value");
-		return -EINVAL;
-	}
-
-	if (!tb[QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL]) {
-		hdd_err_rl("attr thermal throttle set failed");
-		return -EINVAL;
+	switch (cmd_type) {
+	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_SET_LEVEL:
+		if (!tb[QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL]) {
+			hdd_err_rl("attr thermal throttle set failed");
+			return -EINVAL;
+		}
+		level =
+		    nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL]);
+
+		hdd_debug("thermal mitigation level from userspace %d", level);
+		status = hdd_send_thermal_mitigation_val(hdd_ctx, level,
+							 THERMAL_MONITOR_APPS);
+		ret = qdf_status_to_os_return(status);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_GET_LEVEL:
+		ret = hdd_get_curr_thermal_throttle_level_val(hdd_ctx);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_GET_TEMPERATURE:
+		ret = hdd_get_curr_thermal_temperature_val(hdd_ctx, adapter);
+		break;
+	default:
+		ret = -EINVAL;
 	}
-	level =
-	    nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL]);
 
-	hdd_debug("thermal mitigation level from userspace %d", level);
-	status = hdd_send_thermal_mitigation_val(hdd_ctx, level,
-						 THERMAL_MONITOR_APPS);
 	hdd_exit();
-	return qdf_status_to_os_return(status);
+	return ret;
 }
 
 /**
@@ -342,3 +458,63 @@ void hdd_thermal_mitigation_unregister(struct hdd_context *hdd_ctx,
 	hdd_thermal_mitigation_unregister_wpps(hdd_ctx, dev);
 	pld_thermal_unregister(dev, THERMAL_MONITOR_APPS);
 }
+
+#ifdef FW_THERMAL_THROTTLE_SUPPORT
+/**
+ * hdd_notify_thermal_throttle_handler() - Thermal throttle event handler
+ * @psoc: psoc object
+ * @info: thermal throttle information from target
+ *
+ * Retrun: QDF_STATUS_SUCCESS for success.
+ */
+static QDF_STATUS
+hdd_notify_thermal_throttle_handler(struct wlan_objmgr_psoc *psoc,
+				    struct thermal_throttle_info *info)
+{
+	uint32_t data_len;
+	struct sk_buff *vendor_event;
+	struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	int ret;
+	enum qca_wlan_vendor_thermal_level level;
+
+	ret = wlan_hdd_validate_context(hdd_ctx);
+	if (ret)
+		return QDF_STATUS_E_FAILURE;
+
+	data_len = NLMSG_HDRLEN + nla_total_size(sizeof(uint32_t));
+	vendor_event = wlan_cfg80211_vendor_event_alloc(
+				hdd_ctx->wiphy, NULL, data_len,
+				QCA_NL80211_VENDOR_SUBCMD_THERMAL_INDEX,
+				GFP_KERNEL);
+	if (!vendor_event) {
+		hdd_err("cfg80211_vendor_event_alloc failed");
+		return QDF_STATUS_E_NOMEM;
+	}
+	level = convert_level_to_vendor_thermal_level(info->level);
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_THERMAL_EVENT_LEVEL,
+			level)) {
+		wlan_cfg80211_vendor_free_skb(vendor_event);
+		return QDF_STATUS_E_INVAL;
+	}
+	hdd_debug("thermal_throttle:level %d vendor level %d", info->level,
+		  level);
+	wlan_cfg80211_vendor_event(vendor_event, GFP_KERNEL);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+void hdd_thermal_register_callbacks(struct hdd_context *hdd_ctx)
+{
+	struct fwol_thermal_callbacks cb_obj = {0};
+
+	cb_obj.notify_thermal_throttle_handler =
+		hdd_notify_thermal_throttle_handler;
+	ucfg_fwol_thermal_register_callbacks(hdd_ctx->psoc, &cb_obj);
+}
+
+void hdd_thermal_unregister_callbacks(struct hdd_context *hdd_ctx)
+{
+	ucfg_fwol_thermal_unregister_callbacks(hdd_ctx->psoc);
+}
+#endif

core/hdd/src/wlan_hdd_thermal.h

@@ -100,6 +100,12 @@ extern const struct nla_policy
 			      QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_MAX) \
 },
 
+#define FEATURE_THERMAL_VENDOR_EVENTS                               \
+[QCA_NL80211_VENDOR_SUBCMD_THERMAL_INDEX] = {                       \
+	.vendor_id = QCA_NL80211_VENDOR_ID,                         \
+	.subcmd = QCA_NL80211_VENDOR_SUBCMD_THERMAL_EVENT,          \
+},
+
 /**
  * hdd_thermal_mitigation_register() - Register for platform specific thermal
  *                                     mitigation support
@@ -161,8 +167,30 @@ hdd_thermal_fill_clientid_priority(uint8_t mon_id, uint8_t priority_apps,
 {
 }
 #endif
+
+/**
+ * hdd_thermal_register_callbacks() - register thermal event callback
+ *  to be called by fwol thermal layer
+ * @hdd_ctx: hdd context
+ *
+ * The callback will be invoked by fwol thermal layer when the target
+ * indicate thermal throttle level changed. Host will report the new
+ * level to upper layer by vendor command event.
+ *
+ * Return: none
+ */
+void hdd_thermal_register_callbacks(struct hdd_context *hdd_ctx);
+
+/**
+ * hdd_thermal_unregister_callbacks() - unregister thermal event callback
+ * @hdd_ctx: hdd context
+ *
+ * Return: none
+ */
+void hdd_thermal_unregister_callbacks(struct hdd_context *hdd_ctx);
 #else
 #define FEATURE_THERMAL_VENDOR_COMMANDS
+#define FEATURE_THERMAL_VENDOR_EVENTS
 
 static inline bool wlan_hdd_thermal_config_support(void)
 {
@@ -194,5 +222,14 @@ int wlan_hdd_pld_set_thermal_mitigation(struct device *dev,
 	return 0;
 }
 
+static inline void
+hdd_thermal_register_callbacks(struct hdd_context *hdd_ctx)
+{
+}
+
+static inline void
+hdd_thermal_unregister_callbacks(struct hdd_context *hdd_ctx)
+{
+}
 #endif /* FEATURE_THERMAL_VENDOR_COMMANDS */
 #endif /* __HDD_THERMAL_H */