qcacld-3.0: Auto Detect SoC Power Collapse Failure changes

Add host support for detecting SOC power collapse failures in FW and
communicating the same to framework.

Change-Id: Icee39c896802c4d7136e0b8ef442a33feeb4799c
CRs-Fixed: 1112979

21 files changed, 585 insertions, 63 deletions

diff --git a/core/cds/inc/cds_config.h b/core/cds/inc/cds_config.h
index 0286171c0808..5dd0b53fcecc 100644
--- a/core/cds/inc/cds_config.h
+++ b/core/cds/inc/cds_config.h
@@ -174,5 +174,6 @@ struct cds_config_info {
 	bool force_target_assert_enabled;
 	enum active_bpf_mode active_bpf_mode;
 	bool rps_enabled;
+	bool auto_power_save_fail_mode;
 };
 #endif /* !defined( __CDS_CONFIG_H ) */
diff --git a/core/hdd/inc/wlan_hdd_cfg.h b/core/hdd/inc/wlan_hdd_cfg.h
index 397b82b720d2..2efcf62ef478 100644
--- a/core/hdd/inc/wlan_hdd_cfg.h
+++ b/core/hdd/inc/wlan_hdd_cfg.h
@@ -10472,6 +10472,24 @@ enum dot11p_mode {
 #define CFG_SAP_CH_SWITCH_BEACON_CNT_MAX     (5)
 #define CFG_SAP_CH_SWITCH_BEACON_CNT_DEFAULT (5)
 
+/*
+ * <ini>
+ * g_auto_detect_power_failure_mode - auto detect power save failure mode
+ * @Min: 0 : Recovery
+ * @Max: 1 : WMI
+ * @Default: 0
+ *
+ * This ini specifies the behavior of FW in case of
+ * CHIP_POWER_SAVE_FAIL_DETECTED event
+ *
+ * Usage: External
+ *
+ * </ini>
+ */
+#define CFG_AUTO_DETECT_POWER_FAIL_MODE_NAME "g_auto_detect_power_failure_mode"
+#define CFG_AUTO_DETECT_POWER_FAIL_MODE_MIN             (0)
+#define CFG_AUTO_DETECT_POWER_FAIL_MODE_MAX             (1)
+#define CFG_AUTO_DETECT_POWER_FAIL_MODE_DEFAULT         (0)
 
 struct hdd_config {
 	/* Bitmap to track what is explicitly configured */
@@ -11200,6 +11218,7 @@ struct hdd_config {
 	uint8_t                     rssi_penalize_factor_5g;
 	uint8_t                     max_rssi_penalize_5g;
 
+	uint8_t                     auto_pwr_save_fail_mode;
 	uint8_t packet_filters_bitmap;
 	uint32_t                    arp_ac_category;
 
diff --git a/core/hdd/inc/wlan_hdd_main.h b/core/hdd/inc/wlan_hdd_main.h
index 3bcd3420d87a..fdd468fd7cfe 100644
--- a/core/hdd/inc/wlan_hdd_main.h
+++ b/core/hdd/inc/wlan_hdd_main.h
@@ -2337,4 +2337,22 @@ void hdd_start_complete(int ret);
  *
  */
 void hdd_unregister_notifiers(hdd_context_t *hdd_ctx);
+
+/**
+ * hdd_chip_pwr_save_fail_detected_cb() - chip power save failure detected
+ * callback
+ * @hdd_ctx: HDD context
+ * @data: chip power save failure detected data
+ *
+ * This function reads the chip power save failure detected data and fill in
+ * the skb with NL attributes and send up the NL event.
+ * This callback execute in atomic context and must not invoke any
+ * blocking calls.
+ *
+ * Return: none
+ */
+void hdd_chip_pwr_save_fail_detected_cb(void *hdd_ctx,
+				struct chip_pwr_save_fail_detected_params
+				*data);
+
 #endif /* end #if !defined(WLAN_HDD_MAIN_H) */
diff --git a/core/hdd/src/wlan_hdd_cfg.c b/core/hdd/src/wlan_hdd_cfg.c
index 12e653d8f657..a06e43386a99 100644
--- a/core/hdd/src/wlan_hdd_cfg.c
+++ b/core/hdd/src/wlan_hdd_cfg.c
@@ -4500,6 +4500,13 @@ struct reg_table_entry g_registry_table[] = {
 		CFG_DROPPED_PKT_DISCONNECT_TH_DEFAULT,
 		CFG_DROPPED_PKT_DISCONNECT_TH_MIN,
 		CFG_DROPPED_PKT_DISCONNECT_TH_MAX),
+
+	REG_VARIABLE(CFG_AUTO_DETECT_POWER_FAIL_MODE_NAME, WLAN_PARAM_Integer,
+		struct hdd_config, auto_pwr_save_fail_mode,
+		VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+		CFG_AUTO_DETECT_POWER_FAIL_MODE_DEFAULT,
+		CFG_AUTO_DETECT_POWER_FAIL_MODE_MIN,
+		CFG_AUTO_DETECT_POWER_FAIL_MODE_MAX),
 };
 
 /**
@@ -5979,6 +5986,9 @@ void hdd_cfg_print(hdd_context_t *pHddCtx)
 	hdd_debug("Name = [%s] Value = [%u]",
 		CFG_HW_BC_FILTER_NAME,
 		pHddCtx->config->hw_broadcast_filter);
+	hdd_err("Name = [%s] Value = [%u]",
+		CFG_AUTO_DETECT_POWER_FAIL_MODE_NAME,
+		pHddCtx->config->auto_pwr_save_fail_mode);
 	hdd_per_roam_print_ini_config(pHddCtx);
 	hdd_debug("Name = [%s] Value = [%d]",
 		CFG_SAP_INTERNAL_RESTART_NAME,
diff --git a/core/hdd/src/wlan_hdd_cfg80211.c b/core/hdd/src/wlan_hdd_cfg80211.c
index 32d379ae49d5..2889262e7193 100644
--- a/core/hdd/src/wlan_hdd_cfg80211.c
+++ b/core/hdd/src/wlan_hdd_cfg80211.c
@@ -1087,6 +1087,11 @@ static const struct nl80211_vendor_cmd_info wlan_hdd_cfg80211_vendor_events[] =
 		.vendor_id = QCA_NL80211_VENDOR_ID,
 		.subcmd = QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_GET,
 	},
+
+	[QCA_NL80211_VENDOR_SUBCMD_PWR_SAVE_FAIL_DETECTED_INDEX] = {
+		.vendor_id = QCA_NL80211_VENDOR_ID,
+		.subcmd = QCA_NL80211_VENDOR_SUBCMD_CHIP_PWRSAVE_FAILURE
+	}
 };
 
 /**
@@ -5321,6 +5326,67 @@ fail:
 	return;
 }
 
+#define PWR_SAVE_FAIL_CMD_INDEX \
+	QCA_NL80211_VENDOR_SUBCMD_PWR_SAVE_FAIL_DETECTED_INDEX
+/**
+ * hdd_chip_pwr_save_fail_detected_cb() - chip power save failure detected
+ * callback
+ * @hdd_ctx: HDD context
+ * @data: chip power save failure detected data
+ *
+ * This function reads the chip power save failure detected data and fill in
+ * the skb with NL attributes and send up the NL event.
+ * This callback execute in atomic context and must not invoke any
+ * blocking calls.
+ *
+ * Return: none
+ */
+void hdd_chip_pwr_save_fail_detected_cb(void *ctx,
+			struct chip_pwr_save_fail_detected_params
+			*data)
+{
+	hdd_context_t *hdd_ctx = ctx;
+	struct sk_buff *skb;
+	int flags = cds_get_gfp_flags();
+
+	ENTER();
+
+	if (wlan_hdd_validate_context(hdd_ctx))
+		return;
+
+	if (!data) {
+		hdd_notice("data is null");
+		return;
+	}
+
+	skb = cfg80211_vendor_event_alloc(hdd_ctx->wiphy,
+			  NULL, NLMSG_HDRLEN +
+			  sizeof(data->failure_reason_code) +
+			  NLMSG_HDRLEN, PWR_SAVE_FAIL_CMD_INDEX,
+			  flags);
+
+	if (!skb) {
+		hdd_notice("cfg80211_vendor_event_alloc failed");
+		return;
+	}
+
+	hdd_info(FL("failure reason code: %u"),
+		data->failure_reason_code);
+
+	if (nla_put_u32(skb,
+		QCA_ATTR_CHIP_POWER_SAVE_FAILURE_REASON,
+		data->failure_reason_code))
+		goto fail;
+
+	cfg80211_vendor_event(skb, flags);
+	EXIT();
+	return;
+
+fail:
+	kfree_skb(skb);
+}
+#undef PWR_SAVE_FAIL_CMD_INDEX
+
 static const struct nla_policy
 ns_offload_set_policy[QCA_WLAN_VENDOR_ATTR_ND_OFFLOAD_MAX + 1] = {
 	[QCA_WLAN_VENDOR_ATTR_ND_OFFLOAD_FLAG] = {.type = NLA_U8},
diff --git a/core/hdd/src/wlan_hdd_cfg80211.h b/core/hdd/src/wlan_hdd_cfg80211.h
index 3cfd8b773ac8..ec16039e2afe 100644
--- a/core/hdd/src/wlan_hdd_cfg80211.h
+++ b/core/hdd/src/wlan_hdd_cfg80211.h
@@ -488,6 +488,7 @@ enum qca_nl80211_vendor_subcmds {
 
 	/* Set Specific Absorption Rate(SAR) Power Limits */
 	QCA_NL80211_VENDOR_SUBCMD_SET_SAR_LIMITS = 146,
+	QCA_NL80211_VENDOR_SUBCMD_CHIP_PWRSAVE_FAILURE = 148,
 	QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_SET = 149,
 	QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_GET = 150,
 
@@ -774,6 +775,7 @@ enum qca_nl80211_vendor_subcmds_index {
 	QCA_NL80211_VENDOR_SUBCMD_P2P_LO_EVENT_INDEX,
 	QCA_NL80211_VENDOR_SUBCMD_SAP_CONDITIONAL_CHAN_SWITCH_INDEX,
 	QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_GET_INDEX,
+	QCA_NL80211_VENDOR_SUBCMD_PWR_SAVE_FAIL_DETECTED_INDEX,
 };
 
 /**
@@ -885,6 +887,39 @@ enum qca_wlan_vendor_attr_tdls_disable {
 };
 
 /**
+ * qca_chip_power_save_failure_reason: Power save failure reason
+ * @QCA_CHIP_POWER_SAVE_FAILURE_REASON_PROTOCOL: Indicates power save failure
+ * due to protocol/module.
+ * @QCA_CHIP_POWER_SAVE_FAILURE_REASON_HARDWARE: power save failure
+ * due to hardware
+ */
+enum qca_chip_power_save_failure_reason {
+	QCA_CHIP_POWER_SAVE_FAILURE_REASON_PROTOCOL = 0,
+	QCA_CHIP_POWER_SAVE_FAILURE_REASON_HARDWARE = 1,
+};
+
+/**
+ * qca_attr_chip_power_save_failure: attributes to vendor subcmd
+ * @QCA_NL80211_VENDOR_SUBCMD_CHIP_PWRSAVE_FAILURE. This carry the requisite
+ * information leading to the power save failure.
+ * @QCA_ATTR_CHIP_POWER_SAVE_FAILURE_INVALID : invalid
+ * @QCA_ATTR_CHIP_POWER_SAVE_FAILURE_REASON : power save failure reason
+ * represented by enum qca_chip_power_save_failure_reason
+ * @QCA_ATTR_CHIP_POWER_SAVE_FAILURE_LAST : Last
+ * @QCA_ATTR_CHIP_POWER_SAVE_FAILURE_MAX : Max value
+ */
+enum qca_attr_chip_power_save_failure {
+	QCA_ATTR_CHIP_POWER_SAVE_FAILURE_INVALID = 0,
+
+	QCA_ATTR_CHIP_POWER_SAVE_FAILURE_REASON = 1,
+
+	/* keep last */
+	QCA_ATTR_CHIP_POWER_SAVE_FAILURE_LAST,
+	QCA_ATTR_CHIP_POWER_SAVE_FAILURE_MAX =
+		QCA_ATTR_CHIP_POWER_SAVE_FAILURE_LAST - 1,
+};
+
+/**
  * enum qca_wlan_vendor_attr_tdls_get_status - tdls get status attribute
  *
  * @QCA_WLAN_VENDOR_ATTR_TDLS_GET_STATUS_INVALID: Invalid initial value
diff --git a/core/hdd/src/wlan_hdd_ipa.c b/core/hdd/src/wlan_hdd_ipa.c
index aed8f2f86c6d..0325e63d6946 100644
--- a/core/hdd/src/wlan_hdd_ipa.c
+++ b/core/hdd/src/wlan_hdd_ipa.c
@@ -5622,7 +5622,6 @@ static int __hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 					msg_ex->name);
 			return 0;
 		}
-
 		qdf_mutex_acquire(&hdd_ipa->event_lock);
 		if (!hdd_ipa_uc_find_add_assoc_sta(hdd_ipa, false, sta_id)) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
diff --git a/core/hdd/src/wlan_hdd_main.c b/core/hdd/src/wlan_hdd_main.c
index b83ff2b18d62..97e01bf424d0 100644
--- a/core/hdd/src/wlan_hdd_main.c
+++ b/core/hdd/src/wlan_hdd_main.c
@@ -7463,6 +7463,8 @@ static int hdd_update_cds_config(hdd_context_t *hdd_ctx)
 	cds_cfg->self_recovery_enabled = hdd_ctx->config->enableSelfRecovery;
 	cds_cfg->fw_timeout_crash = hdd_ctx->config->fw_timeout_crash;
 	cds_cfg->active_bpf_mode = hdd_ctx->config->active_bpf_mode;
+	cds_cfg->auto_power_save_fail_mode =
+		hdd_ctx->config->auto_pwr_save_fail_mode;
 
 	hdd_ra_populate_cds_config(cds_cfg, hdd_ctx);
 	hdd_txrx_populate_cds_config(cds_cfg, hdd_ctx);
@@ -8833,6 +8835,10 @@ int hdd_wlan_startup(struct device *dev)
 					    set_value, PDEV_CMD);
 	}
 
+	/* set chip power save failure detected callback */
+	sme_set_chip_pwr_save_fail_cb(hdd_ctx->hHal,
+				      hdd_chip_pwr_save_fail_detected_cb);
+
 	qdf_mc_timer_start(&hdd_ctx->iface_change_timer,
 			   hdd_ctx->config->iface_change_wait_time);
 
diff --git a/core/hdd/src/wlan_hdd_power.c b/core/hdd/src/wlan_hdd_power.c
index 477ce3ff2cde..c4fd26d70947 100644
--- a/core/hdd/src/wlan_hdd_power.c
+++ b/core/hdd/src/wlan_hdd_power.c
@@ -1654,6 +1654,9 @@ QDF_STATUS hdd_wlan_re_init(void)
 	}
 
 	hdd_lpass_notify_start(pHddCtx);
+	/* set chip power save failure detected callback */
+	sme_set_chip_pwr_save_fail_cb(pHddCtx->hHal,
+				      hdd_chip_pwr_save_fail_detected_cb);
 
 	hdd_info("WLAN host driver reinitiation completed!");
 	goto success;
diff --git a/core/mac/inc/sir_api.h b/core/mac/inc/sir_api.h
index 07af4e5097c7..7892d8a125bc 100644
--- a/core/mac/inc/sir_api.h
+++ b/core/mac/inc/sir_api.h
@@ -5651,6 +5651,17 @@ struct rssi_breach_event {
 	struct qdf_mac_addr  curr_bssid;
 };
 
+/**
+ * struct chip_pwr_save_fail_detected_params - chip power save failure detected
+ * event params
+ * @failure_reason_code:failure reason code
+ * @wake_lock_bitmap:bitmap for modules voting against sleep for long duration.
+ */
+struct chip_pwr_save_fail_detected_params {
+	uint32_t     failure_reason_code;
+	uint32_t     wake_lock_bitmap[4];
+};
+
 #define MAX_NUM_FW_SEGMENTS 4
 
 /**
@@ -6369,6 +6380,7 @@ struct sir_wake_lock_stats {
  * @pno_complete: pno complete wakeup count
  * @pno_match: pno match wakeup count
  * @oem_response: oem response wakeup count
+ * @pwr_save_fail_detected: pwr save fail detected wakeup count
  */
 struct sir_vdev_wow_stats {
 	uint32_t ucast;
@@ -6386,6 +6398,7 @@ struct sir_vdev_wow_stats {
 	uint32_t pno_complete;
 	uint32_t pno_match;
 	uint32_t oem_response;
+	uint32_t pwr_save_fail_detected;
 };
 
 /**
diff --git a/core/sme/inc/sme_api.h b/core/sme/inc/sme_api.h
index 631efbc093ed..8c2263b08186 100644
--- a/core/sme/inc/sme_api.h
+++ b/core/sme/inc/sme_api.h
@@ -1587,4 +1587,16 @@ QDF_STATUS sme_set_random_mac(tHalHandle hal,
 QDF_STATUS sme_clear_random_mac(tHalHandle hal, uint32_t session_id,
 				uint8_t *random_mac, uint32_t freq);
 
+/**
+ * sme_set_chip_pwr_save_fail_cb() - set chip power save failure callback
+ * @hal: global hal handle
+ * @cb: callback function pointer
+ *
+ * This function stores the chip power save failure callback function.
+ *
+ * Return: QDF_STATUS enumeration.
+ */
+QDF_STATUS sme_set_chip_pwr_save_fail_cb(tHalHandle hal, void (*cb)(void *,
+				 struct chip_pwr_save_fail_detected_params *));
+
 #endif /* #if !defined( __SME_API_H ) */
diff --git a/core/sme/inc/sme_internal.h b/core/sme/inc/sme_internal.h
index e149b55f56ba..477326d42ac1 100644
--- a/core/sme/inc/sme_internal.h
+++ b/core/sme/inc/sme_internal.h
@@ -261,6 +261,8 @@ typedef struct tagSmeStruct {
 			 struct rso_cmd_status *rso_status);
 	void (*get_arp_stats_cb)(void *, struct rsp_stats *);
 	void (*bt_activity_info_cb)(void *context, uint32_t bt_activity);
+	void (*chip_power_save_fail_cb)(void *,
+			struct chip_pwr_save_fail_detected_params *);
 } tSmeStruct, *tpSmeStruct;
 
 #endif /* #if !defined( __SMEINTERNAL_H ) */
diff --git a/core/sme/src/common/sme_api.c b/core/sme/src/common/sme_api.c
index 5f4816456aaa..2c0dd6f748db 100644
--- a/core/sme/src/common/sme_api.c
+++ b/core/sme/src/common/sme_api.c
@@ -15235,6 +15235,26 @@ bool sme_is_any_session_in_connected_state(tHalHandle h_hal)
 	return ret;
 }
 
+QDF_STATUS sme_set_chip_pwr_save_fail_cb(tHalHandle hal,
+		 void (*cb)(void *,
+		 struct chip_pwr_save_fail_detected_params *))
+{
+
+	QDF_STATUS status  = QDF_STATUS_SUCCESS;
+	tpAniSirGlobal mac = PMAC_STRUCT(hal);
+
+	status = sme_acquire_global_lock(&mac->sme);
+	if (status != QDF_STATUS_SUCCESS) {
+		sme_err("sme_AcquireGlobalLock failed!(status=%d)",
+			status);
+		return status;
+	}
+	mac->sme.chip_power_save_fail_cb = cb;
+	sme_release_global_lock(&mac->sme);
+
+	return status;
+}
+
 /**
  * sme_set_rssi_monitoring() - set rssi monitoring
  * @hal: global hal handle
diff --git a/core/wma/inc/wma.h b/core/wma/inc/wma.h
index d2faf3d6ce77..58d18235a55c 100644
--- a/core/wma/inc/wma.h
+++ b/core/wma/inc/wma.h
@@ -1022,6 +1022,7 @@ typedef struct {
  * @wow_stats: stat counters for WoW related events
  * @rcpi_req: rcpi request
  * It stores parameters per vdev in wma.
+ * @in_bmps : Whether bmps for this interface has been enabled
  */
 struct wma_txrx_node {
 	uint8_t addr[IEEE80211_ADDR_LEN];
@@ -1102,6 +1103,7 @@ struct wma_txrx_node {
 	struct sir_vdev_wow_stats wow_stats;
 	struct sme_rcpi_req *rcpi_req;
 	struct action_frame_random_filter *action_frame_filter;
+	bool in_bmps;
 };
 
 #if defined(QCA_WIFI_FTM)
@@ -1655,6 +1657,8 @@ typedef struct {
 	bool fw_mem_dump_enabled;
 	tSirAddonPsReq ps_setting;
 	struct peer_debug_info *peer_dbg;
+	bool auto_power_save_enabled;
+	uint8_t in_imps;
 } t_wma_handle, *tp_wma_handle;
 
 /**
@@ -2367,7 +2371,7 @@ void wma_remove_peer(tp_wma_handle wma, u_int8_t *bssid,
 
 QDF_STATUS wma_add_wow_wakeup_event(tp_wma_handle wma,
 					uint32_t vdev_id,
-					uint32_t bitmap,
+					uint32_t *bitmap,
 					bool enable);
 QDF_STATUS wma_create_peer(tp_wma_handle wma, ol_txrx_pdev_handle pdev,
 			   ol_txrx_vdev_handle vdev, u8 peer_addr[6],
@@ -2394,4 +2398,58 @@ void wma_update_sta_inactivity_timeout(tp_wma_handle wma,
 
 QDF_STATUS wma_send_udp_resp_offload_cmd(tp_wma_handle wma_handle,
 					struct udp_resp_offload *udp_response);
+
+/**
+ * wma_chip_power_save_failure_detected_handler() - chip pwr save fail detected
+ * event handler
+ * @handle: wma handle
+ * @cmd_param_info: event handler data
+ * @len: length of @cmd_param_info
+ *
+ * Return: QDF_STATUS_SUCCESS on success; error code otherwise
+ */
+int wma_chip_power_save_failure_detected_handler(void *handle,
+						 uint8_t *cmd_param_info,
+						 uint32_t len);
+
+/**
+ * wma_set_event_wow_bitmap() - set wow bitmask given WOW event
+ * @event: wow event
+ * @wow_bitmap_size: WOW bitmap size
+ * @bitmask: pointer to actual bitmask
+ *
+ * Return: none
+ */
+void wma_set_wow_event_bitmap(WOW_WAKE_EVENT_TYPE event,
+			      uint32_t wow_bitmap_size,
+			      uint32_t *bitmask);
+
+/**
+ * wma_set_sta_wow_bitmask() - set predefined bitmask for STA WOW events
+ * @bitmask: pointer to actual bitmask
+ * @wow_bitmap_size: WOW bitmap size
+ *
+ * Return: none
+ */
+void wma_set_sta_wow_bitmask(uint32_t *bitmask, uint32_t wow_bitmask_size);
+
+/**
+ * wma_set_sap_wow_bitmask() - set predefined bitmask for SAP WOW events
+ * @bitmask: pointer to actual bitmask
+ * @wow_bitmap_size: WOW bitmap size
+ *
+ * Return: none
+ */
+void wma_set_sap_wow_bitmask(uint32_t *bitmask, uint32_t wow_bitmask_size);
+
+/**
+ * wma_is_wow_bitmask_zero() - check if given wow bitmask is zero
+ * @bitmask: pointer to actual bitmask
+ * @wow_bitmap_size: WOW bitmap size
+ *
+ * Return: true if zero, false otherwise
+ */
+bool wma_is_wow_bitmask_zero(uint32_t *bitmask,
+			     uint32_t wow_bitmask_size);
+
 #endif
diff --git a/core/wma/inc/wma_api.h b/core/wma/inc/wma_api.h
index f4b5ca6cafe0..9813d251edf7 100644
--- a/core/wma/inc/wma_api.h
+++ b/core/wma/inc/wma_api.h
@@ -208,7 +208,7 @@ tSirRetStatus wma_post_ctrl_msg(tpAniSirGlobal pMac, tSirMsgQ *pMsg);
 
 void wma_enable_disable_wakeup_event(WMA_HANDLE handle,
 				uint32_t vdev_id,
-				uint32_t bitmap,
+				uint32_t *bitmap,
 				bool enable);
 void wma_register_wow_wakeup_events(WMA_HANDLE handle, uint8_t vdev_id,
 					uint8_t vdev_type, uint8_t sub_type);
diff --git a/core/wma/src/wma_dev_if.c b/core/wma/src/wma_dev_if.c
index bb97d3f11484..7faf085a9e29 100644
--- a/core/wma/src/wma_dev_if.c
+++ b/core/wma/src/wma_dev_if.c
@@ -3040,6 +3040,7 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 	QDF_STATUS status;
 	int8_t maxTxPower;
 	struct sir_hw_mode_params hw_mode = {0};
+	uint32_t wow_mask[WMI_WOW_MAX_EVENT_BM_LEN] = {0};
 
 	pdev = cds_get_context(QDF_MODULE_ID_TXRX);
 
@@ -3055,9 +3056,14 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 
 		goto send_fail_resp;
 	}
-	if (SAP_WPS_DISABLED == add_bss->wps_state)
+	if (SAP_WPS_DISABLED == add_bss->wps_state) {
+		wma_set_wow_event_bitmap(WOW_PROBE_REQ_WPS_IE_EVENT,
+					 WMI_WOW_MAX_EVENT_BM_LEN,
+					 wow_mask);
+
 		wma_enable_disable_wakeup_event(wma, vdev_id,
-			(1 << WOW_PROBE_REQ_WPS_IE_EVENT), false);
+			wow_mask, false);
+	}
 	wma_set_bss_rate_flags(&wma->interfaces[vdev_id], add_bss);
 	status = wma_create_peer(wma, pdev, vdev, add_bss->bssId,
 				 WMI_PEER_TYPE_DEFAULT, vdev_id, false);
diff --git a/core/wma/src/wma_features.c b/core/wma/src/wma_features.c
index ad0260f08348..d27f8cc6e123 100644
--- a/core/wma/src/wma_features.c
+++ b/core/wma/src/wma_features.c
@@ -77,30 +77,6 @@
 #define ARRAY_LENGTH(a)         (sizeof(a) / sizeof((a)[0]))
 #endif
 
-#define WMA_WOW_STA_WAKE_UP_EVENTS ((1 << WOW_CSA_IE_EVENT) |\
-				(1 << WOW_CLIENT_KICKOUT_EVENT) |\
-				(1 << WOW_PATTERN_MATCH_EVENT) |\
-				(1 << WOW_MAGIC_PKT_RECVD_EVENT) |\
-				(1 << WOW_DEAUTH_RECVD_EVENT) |\
-				(1 << WOW_DISASSOC_RECVD_EVENT) |\
-				(1 << WOW_BMISS_EVENT) |\
-				(1 << WOW_GTK_ERR_EVENT) |\
-				(1 << WOW_BETTER_AP_EVENT) |\
-				(1 << WOW_HTT_EVENT) |\
-				(1 << WOW_RA_MATCH_EVENT) |\
-				(1 << WOW_NLO_DETECTED_EVENT) |\
-				(1 << WOW_EXTSCAN_EVENT)) |\
-				(1 << WOW_OEM_RESPONSE_EVENT)|\
-				(1 << WOW_TDLS_CONN_TRACKER_EVENT)\
-
-#define WMA_WOW_SAP_WAKE_UP_EVENTS ((1 << WOW_PROBE_REQ_WPS_IE_EVENT) |\
-				(1 << WOW_PATTERN_MATCH_EVENT) |\
-				(1 << WOW_AUTH_REQ_EVENT) |\
-				(1 << WOW_ASSOC_REQ_EVENT) |\
-				(1 << WOW_DEAUTH_RECVD_EVENT) |\
-				(1 << WOW_DISASSOC_RECVD_EVENT) |\
-				(1 << WOW_HTT_EVENT))\
-
 /**
  * WMA_SET_VDEV_IE_SOURCE_HOST - Flag to identify the source of VDEV SET IE
  * command. The value is 0x0 for the VDEV SET IE WMI commands from mobile
@@ -2243,7 +2219,6 @@ void wma_register_dfs_event_handler(tp_wma_handle wma_handle)
 	return;
 }
 
-
 /**
  * wma_unified_dfs_phyerr_filter_offload_enable() - enable dfs phyerr filter
  * @wma_handle: wma handle
@@ -2435,6 +2410,8 @@ static const u8 *wma_wow_wake_reason_str(A_INT32 wake_reason)
 		return "NAN_EVENT_WAKE_HOST";
 	case WOW_REASON_DEBUG_TEST:
 		return "DEBUG_TEST";
+	case WOW_REASON_CHIP_POWER_FAILURE_DETECT:
+		return "CHIP_POWER_FAILURE_DETECT";
 	default:
 		return "unknown";
 	}
@@ -2593,6 +2570,10 @@ static void wma_inc_wow_stats(struct sir_vdev_wow_stats *stats, uint8_t *data,
 		stats->oem_response++;
 		break;
 
+	case WOW_REASON_CHIP_POWER_FAILURE_DETECT:
+		stats->pwr_save_fail_detected++;
+		break;
+
 	default:
 		WMA_LOGI("Stats for WoW reason %s are not tracked",
 			 wma_wow_wake_reason_str(reason));
@@ -3543,6 +3524,10 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event,
 			WMA_LOGD("No wow_packet_buffer present");
 		break;
 #endif
+	case WOW_REASON_CHIP_POWER_FAILURE_DETECT:
+		/* Just update stats and exit */
+		WMA_LOGD("Host woken up because of chip power save failure");
+		break;
 	default:
 		break;
 	}
@@ -3616,7 +3601,7 @@ static inline void wma_set_wow_bus_suspend(tp_wma_handle wma, int val)
  */
 QDF_STATUS wma_add_wow_wakeup_event(tp_wma_handle wma,
 					uint32_t vdev_id,
-					uint32_t bitmap,
+					uint32_t *bitmap,
 					bool enable)
 {
 	int ret;
@@ -3981,6 +3966,7 @@ void wma_register_wow_default_patterns(WMA_HANDLE handle, uint8_t vdev_id)
 	return;
 }
 
+
 /**
  * wma_register_wow_wakeup_events() - register vdev specific wake events with fw
  * @handle: Pointer to wma handle
@@ -4001,7 +3987,7 @@ void wma_register_wow_wakeup_events(WMA_HANDLE handle,
 				uint8_t vdev_subtype)
 {
 	tp_wma_handle wma = handle;
-	uint32_t event_bitmap;
+	uint32_t event_bitmap[WMI_WOW_MAX_EVENT_BM_LEN] = {0};
 
 	WMA_LOGD("vdev_type %d vdev_subtype %d vdev_id %d", vdev_type,
 			vdev_subtype, vdev_id);
@@ -4010,20 +3996,28 @@ void wma_register_wow_wakeup_events(WMA_HANDLE handle,
 		((WMI_VDEV_TYPE_AP == vdev_type) &&
 		 (WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE == vdev_subtype))) {
 		/* Configure STA/P2P CLI mode specific default wake up events */
-		event_bitmap = WMA_WOW_STA_WAKE_UP_EVENTS;
-		WMA_LOGD("STA specific default wake up event 0x%x vdev id %d",
-			event_bitmap, vdev_id);
+		wma_set_sta_wow_bitmask(event_bitmap,
+					WMI_WOW_MAX_EVENT_BM_LEN);
+
+		if ((wma->interfaces[vdev_id].in_bmps == true ||
+		     wma->in_imps == true) &&
+		     wma->auto_power_save_enabled)
+			wma_set_wow_event_bitmap(
+					 WOW_CHIP_POWER_FAILURE_DETECT_EVENT,
+					 WMI_WOW_MAX_EVENT_BM_LEN,
+					 event_bitmap);
+
 	} else if (WMI_VDEV_TYPE_IBSS == vdev_type) {
 		/* Configure IBSS mode specific default wake up events */
-		event_bitmap = (WMA_WOW_STA_WAKE_UP_EVENTS |
-				(1 << WOW_BEACON_EVENT));
-		WMA_LOGD("IBSS specific default wake up event 0x%x vdev id %d",
-			event_bitmap, vdev_id);
+		wma_set_sta_wow_bitmask(event_bitmap,
+					WMI_WOW_MAX_EVENT_BM_LEN);
+		wma_set_wow_event_bitmap(WOW_BEACON_EVENT,
+					 WMI_WOW_MAX_EVENT_BM_LEN,
+					 event_bitmap);
 	} else if (WMI_VDEV_TYPE_AP == vdev_type) {
 		/* Configure SAP/GO mode specific default wake up events */
-		event_bitmap = WMA_WOW_SAP_WAKE_UP_EVENTS;
-		WMA_LOGD("SAP specific default wake up event 0x%x vdev id %d",
-			event_bitmap, vdev_id);
+		wma_set_sap_wow_bitmask(event_bitmap,
+					WMI_WOW_MAX_EVENT_BM_LEN);
 	} else if (WMI_VDEV_TYPE_NDI == vdev_type) {
 		/*
 		 * Configure NAN data path specific default wake up events.
@@ -4052,14 +4046,18 @@ void wma_register_wow_wakeup_events(WMA_HANDLE handle,
  */
 void wma_enable_disable_wakeup_event(WMA_HANDLE handle,
 				uint32_t vdev_id,
-				uint32_t bitmap,
+				uint32_t *bitmap,
 				bool enable)
 {
 	tp_wma_handle wma = handle;
+	uint32_t event_bitmap[WMI_WOW_MAX_EVENT_BM_LEN] = {0};
 
-	WMA_LOGI("vdev_id %d wake up event 0x%x enable %d",
-		vdev_id, bitmap, enable);
-	wma_add_wow_wakeup_event(wma, vdev_id, bitmap, enable);
+	qdf_mem_copy(event_bitmap, bitmap, sizeof(uint32_t) *
+		     WMI_WOW_MAX_EVENT_BM_LEN);
+
+	WMA_LOGI("vdev_id %d wake up event 0x%x%x%x%x enable %d",
+		vdev_id, bitmap[0], bitmap[1], bitmap[2], bitmap[3], enable);
+	wma_add_wow_wakeup_event(wma, vdev_id, event_bitmap, enable);
 }
 
 /**
@@ -4694,6 +4692,10 @@ static bool wma_is_wow_applicable(tp_wma_handle wma)
 	return false;
 }
 
+/* Define for conciseness */
+#define BM_LEN WMI_WOW_MAX_EVENT_BM_LEN
+#define EV_NLO WOW_NLO_SCAN_COMPLETE_EVENT
+#define EV_PWR WOW_CHIP_POWER_FAILURE_DETECT_EVENT
 /**
  * wma_configure_dynamic_wake_events(): configure dyanmic wake events
  * @wma: wma handle
@@ -4704,31 +4706,68 @@ static bool wma_is_wow_applicable(tp_wma_handle wma)
  */
 static void wma_configure_dynamic_wake_events(tp_wma_handle wma)
 {
+
 	int vdev_id;
-	int enable_mask;
-	int disable_mask;
+	uint32_t enable_mask[BM_LEN] = {0};
+	uint32_t disable_mask[BM_LEN] = {0};
+	bool enable_configured = false;
+	bool disable_configured = false;
+	ol_txrx_vdev_handle vdev;
 
 	for (vdev_id = 0; vdev_id < wma->max_bssid; vdev_id++) {
-		enable_mask = 0;
-		disable_mask = 0;
 
-		if (wma_is_pnoscan_in_progress(wma, vdev_id)) {
-			if (wma_is_pnoscan_match_found(wma, vdev_id))
-				enable_mask |=
-					(1 << WOW_NLO_SCAN_COMPLETE_EVENT);
-			else
-				disable_mask |=
-					(1 << WOW_NLO_SCAN_COMPLETE_EVENT);
+		qdf_mem_set(enable_mask,  sizeof(uint32_t) * BM_LEN, 0);
+		qdf_mem_set(disable_mask, sizeof(uint32_t) * BM_LEN, 0);
+		vdev = wma_find_vdev_by_id(wma, vdev_id);
+		if (NULL == vdev) {
+			WMA_LOGP("%s: Couldn't find vdev for vdev_id: %d",
+				 __func__, vdev_id);
+			continue;
 		}
 
-		if (enable_mask != 0)
+		if (wma_is_pnoscan_in_progress(wma, vdev_id)) {
+			if (wma_is_pnoscan_match_found(wma, vdev_id)) {
+				wma_set_wow_event_bitmap(EV_NLO,
+							 BM_LEN,
+							 enable_mask);
+				enable_configured = true;
+			} else
+				wma_set_wow_event_bitmap(EV_NLO,
+							 BM_LEN,
+							 disable_mask);
+				disable_configured = true;
+		}
+		if ((wma->interfaces[vdev_id].in_bmps == true ||
+		     wma->in_imps == true) &&
+		     (wma->interfaces[vdev_id].type == WMI_VDEV_TYPE_STA ||
+		     (wma->interfaces[vdev_id].type == WMI_VDEV_TYPE_AP &&
+		     (wma->interfaces[vdev_id].sub_type ==
+		      WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE ||
+		      wma->interfaces[vdev_id].sub_type ==
+		      WMI_UNIFIED_VDEV_SUBTYPE_P2P_CLIENT))) &&
+		     wma->auto_power_save_enabled) {
+			wma_set_wow_event_bitmap(EV_PWR,
+						 BM_LEN,
+						 enable_mask);
+			enable_configured = true;
+		}
+		if (enable_configured) {
 			wma_enable_disable_wakeup_event(wma, vdev_id,
 					enable_mask, true);
-		if (disable_mask != 0)
+		}
+
+		if (disable_configured) {
 			wma_enable_disable_wakeup_event(wma, vdev_id,
 					disable_mask, false);
+		}
+
+		enable_configured = false;
+		disable_configured = false;
 	}
 }
+#undef BM_LEN
+#undef EV_NLO
+#undef EV_PWR
 
 #ifdef FEATURE_WLAN_LPHB
 /**
diff --git a/core/wma/src/wma_main.c b/core/wma/src/wma_main.c
index 435b6b2e738f..78390377d8a7 100644
--- a/core/wma/src/wma_main.c
+++ b/core/wma/src/wma_main.c
@@ -2565,6 +2565,17 @@ QDF_STATUS wma_open(void *cds_context,
 			wma_action_frame_filter_mac_event_handler,
 			WMA_RX_SERIALIZER_CTX);
 
+	wma_handle->auto_power_save_enabled =
+		cds_cfg->auto_power_save_fail_mode;
+	/* Register PWR_SAVE_FAIL event only in case of recovery(1) */
+	if (wma_handle->auto_power_save_enabled) {
+		wmi_unified_register_event_handler(wma_handle->wmi_handle,
+			WMI_PDEV_CHIP_POWER_SAVE_FAILURE_DETECTED_EVENTID,
+			wma_chip_power_save_failure_detected_handler,
+			WMA_RX_SERIALIZER_CTX);
+	}
+
+
 	wma_ndp_register_all_event_handlers(wma_handle);
 	wma_register_debug_callback();
 
diff --git a/core/wma/src/wma_nan_datapath.c b/core/wma/src/wma_nan_datapath.c
index 08c4ef843c9e..028dc3ba73d2 100644
--- a/core/wma/src/wma_nan_datapath.c
+++ b/core/wma/src/wma_nan_datapath.c
@@ -909,10 +909,12 @@ void wma_ndp_unregister_all_event_handlers(tp_wma_handle wma_handle)
 void wma_ndp_add_wow_wakeup_event(tp_wma_handle wma_handle,
 					uint8_t vdev_id)
 {
-	uint32_t event_bitmap;
-	event_bitmap = (1 << WOW_NAN_DATA_EVENT);
+	uint32_t event_bitmap[WMI_WOW_MAX_EVENT_BM_LEN] = {0};
+
+	wma_set_wow_event_bitmap(WOW_NAN_DATA_EVENT, WMI_WOW_MAX_EVENT_BM_LEN,
+				 event_bitmap);
 	WMA_LOGI("NDI specific default wake up event 0x%x vdev id %d",
-		event_bitmap, vdev_id);
+		 event_bitmap[0], vdev_id);
 	wma_add_wow_wakeup_event(wma_handle, vdev_id, event_bitmap, true);
 }
 
diff --git a/core/wma/src/wma_power.c b/core/wma/src/wma_power.c
index eb052d199acf..5a194c599e94 100644
--- a/core/wma/src/wma_power.c
+++ b/core/wma/src/wma_power.c
@@ -826,6 +826,8 @@ void wma_enable_sta_ps_mode(tp_wma_handle wma, tpEnablePsParams ps_req)
 			return;
 		}
 	}
+	/* power save request succeeded */
+	iface->in_bmps = true;
 }
 
 /**
@@ -839,6 +841,7 @@ void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req)
 {
 	QDF_STATUS ret;
 	uint32_t vdev_id = ps_req->sessionid;
+	struct wma_txrx_node *iface = &wma->interfaces[vdev_id];
 
 	WMA_LOGD("Disable Sta Mode Ps vdevId %d", vdev_id);
 
@@ -848,7 +851,7 @@ void wma_disable_sta_ps_mode(tp_wma_handle wma, tpDisablePsParams ps_req)
 		WMA_LOGE("Disable Sta Mode Ps Failed vdevId %d", vdev_id);
 		return;
 	}
-
+	iface->in_bmps = false;
 	/* Disable UAPSD incase if additional Req came */
 	if (eSIR_ADDON_DISABLE_UAPSD == ps_req->psSetting) {
 		WMA_LOGD("Disable Uapsd vdevId %d", vdev_id);
@@ -1724,6 +1727,7 @@ QDF_STATUS wma_set_idle_ps_config(void *wma_ptr, uint32_t idle_ps)
 		WMA_LOGE("Fail to Set Idle Ps Config %d", idle_ps);
 		return QDF_STATUS_E_FAILURE;
 	}
+	 wma->in_imps = idle_ps;
 
 	WMA_LOGD("Successfully Set Idle Ps Config %d", idle_ps);
 	return QDF_STATUS_SUCCESS;
diff --git a/core/wma/src/wma_utils.c b/core/wma/src/wma_utils.c
index 3564219f8b5b..49da5565fef8 100644
--- a/core/wma/src/wma_utils.c
+++ b/core/wma/src/wma_utils.c
@@ -4451,3 +4451,201 @@ tSirWifiPeerType wmi_to_sir_peer_type(enum wmi_peer_type type)
 		return WIFI_PEER_INVALID;
 	}
 }
+
+int wma_chip_power_save_failure_detected_handler(void *handle,
+						 uint8_t  *cmd_param_info,
+						 uint32_t len)
+{
+	tp_wma_handle wma = (tp_wma_handle)handle;
+	WMI_PDEV_CHIP_POWER_SAVE_FAILURE_DETECTED_EVENTID_param_tlvs *param_buf;
+	wmi_chip_power_save_failure_detected_fixed_param  *event;
+	struct chip_pwr_save_fail_detected_params  pwr_save_fail_params;
+	tpAniSirGlobal mac = (tpAniSirGlobal)cds_get_context(
+						QDF_MODULE_ID_PE);
+	if (NULL == wma) {
+		WMA_LOGE("%s: wma_handle is NULL", __func__);
+		return -EINVAL;
+	}
+	if (!mac) {
+		WMA_LOGE("%s: Invalid mac context", __func__);
+		return -EINVAL;
+	}
+	if (!mac->sme.chip_power_save_fail_cb) {
+		WMA_LOGE("%s: Callback not registered", __func__);
+		return -EINVAL;
+	}
+
+	param_buf =
+	(WMI_PDEV_CHIP_POWER_SAVE_FAILURE_DETECTED_EVENTID_param_tlvs *)
+	cmd_param_info;
+	if (!param_buf) {
+		WMA_LOGE("%s: Invalid pwr_save_fail_params breached event",
+			 __func__);
+		return -EINVAL;
+	}
+	event = param_buf->fixed_param;
+	pwr_save_fail_params.failure_reason_code =
+				event->power_save_failure_reason_code;
+	pwr_save_fail_params.wake_lock_bitmap[0] =
+				event->protocol_wake_lock_bitmap[0];
+	pwr_save_fail_params.wake_lock_bitmap[1] =
+				event->protocol_wake_lock_bitmap[1];
+	pwr_save_fail_params.wake_lock_bitmap[2] =
+				event->protocol_wake_lock_bitmap[2];
+	pwr_save_fail_params.wake_lock_bitmap[3] =
+				event->protocol_wake_lock_bitmap[3];
+	mac->sme.chip_power_save_fail_cb(mac->hHdd,
+				&pwr_save_fail_params);
+
+	WMA_LOGD("%s: Invoke HDD pwr_save_fail callback", __func__);
+	return 0;
+}
+/**
+ * wma_get_event_bitmap_idx() - get indices for extended wow bitmaps
+ * @event: wow event
+ * @wow_bitmap_size: WOW bitmap size
+ * @bit_idx: bit index
+ * @idx: byte index
+ *
+ * Return: none
+ */
+static inline void wma_get_event_bitmap_idx(WOW_WAKE_EVENT_TYPE event,
+			      uint32_t wow_bitmap_size,
+			      uint32_t *bit_idx,
+			      uint32_t *idx)
+{
+
+	if (!bit_idx || !idx || wow_bitmap_size == 0)
+		return;
+	if (event == 0)
+		*idx = *bit_idx = 0;
+	else {
+		*idx = event / (wow_bitmap_size * 8);
+		*bit_idx = event % (wow_bitmap_size * 8);
+	}
+}
+
+void wma_set_wow_event_bitmap(WOW_WAKE_EVENT_TYPE event,
+			      uint32_t wow_bitmap_size,
+			      uint32_t *bitmask)
+{
+	uint32_t bit_idx = 0, idx = 0;
+
+	if (!bitmask || wow_bitmap_size < WMI_WOW_MAX_EVENT_BM_LEN) {
+		WMA_LOGE("%s: wow bitmask length shorter than %d",
+			 __func__, WMI_WOW_MAX_EVENT_BM_LEN);
+		return;
+	}
+	wma_get_event_bitmap_idx(event, wow_bitmap_size, &bit_idx, &idx);
+	bitmask[idx] |= 1 << bit_idx;
+
+	WMA_LOGI("%s: bitmask updated %x%x%x%x",
+		 __func__, bitmask[0], bitmask[1], bitmask[2], bitmask[3]);
+}
+
+inline bool wma_is_wow_bitmask_zero(uint32_t *bitmask,
+				    uint32_t wow_bitmap_size)
+{
+	int i = 0;
+
+	if (!bitmask || wow_bitmap_size < WMI_WOW_MAX_EVENT_BM_LEN)
+		WMA_LOGE("%s: wow bitmask length shorter than %d",
+			 __func__, WMI_WOW_MAX_EVENT_BM_LEN);
+	else {
+		for (; i < WMI_WOW_MAX_EVENT_BM_LEN; i++) {
+			if (bitmask[i] != 0)
+				return false;
+		}
+	}
+	return true;
+}
+
+void wma_set_sta_wow_bitmask(uint32_t *bitmask, uint32_t wow_bitmap_size)
+{
+
+	if (!bitmask || wow_bitmap_size < WMI_WOW_MAX_EVENT_BM_LEN) {
+		WMA_LOGE("%s: wow bitmask length shorter than %d",
+			 __func__, WMI_WOW_MAX_EVENT_BM_LEN);
+		return;
+	}
+	wma_set_wow_event_bitmap(WOW_CSA_IE_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_CLIENT_KICKOUT_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_PATTERN_MATCH_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_MAGIC_PKT_RECVD_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_DEAUTH_RECVD_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_DISASSOC_RECVD_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_BMISS_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_GTK_ERR_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_BETTER_AP_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_HTT_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_RA_MATCH_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_NLO_DETECTED_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_EXTSCAN_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_OEM_RESPONSE_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_TDLS_CONN_TRACKER_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	/* Add further STA wakeup events above this line. */
+}
+
+void wma_set_sap_wow_bitmask(uint32_t *bitmask, uint32_t wow_bitmap_size)
+{
+
+	if (!bitmask || wow_bitmap_size < WMI_WOW_MAX_EVENT_BM_LEN) {
+		WMA_LOGE("%s: wow bitmask length shorter than %d",
+			 __func__, WMI_WOW_MAX_EVENT_BM_LEN);
+		return;
+	}
+
+	wma_set_wow_event_bitmap(WOW_PROBE_REQ_WPS_IE_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_PATTERN_MATCH_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_AUTH_REQ_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_ASSOC_REQ_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_DEAUTH_RECVD_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_DISASSOC_RECVD_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+	wma_set_wow_event_bitmap(WOW_HTT_EVENT,
+			     WMI_WOW_MAX_EVENT_BM_LEN,
+			     bitmask);
+
+	/* Add further SAP wakeup events above this line. */
+}