Release 1.0.0.178 QCACLD WLAN Driver.

Merge remote-tracking branch 'origin/caf/caf-wlan/master' into HEAD

* origin/caf/caf-wlan/master:
  Cafstaging Release 1.0.0.178
  wlan: qcacld: Channel Info in Roam Synch Indication
  qcacld/HIF: Implement EXTWOW Partial Offload(4/4)
  qcacld/WMA: Implement EXTWOW Partial Offload(3/4)
  qcacld/SME: Implement EXTWOW Partial Offload(2/4)
  qcacld/HDD: Implement EXTWOW Partial Offload(1/4)
  qcacld: sdio HIF: enable 4-bit ASYNC interrupt on Tufello
  wlan: qca_cld: Support for rx to tx forwarding with rx reorder offload
  Wlan:LFR3:Send Synch cnf to firmware
  wlan: qcacld: Null Ptr Check for pRoamInfo
  qcacld: Fix for null pointer dereference.
  qcacld: CL 1070363 - Add wmi_channel info
  qcacld: Fix roam offload disabling condition at HDD

Change-Id: I85fb5a04bd52efa1562350fc182382e5667d1900

35 files changed, 1346 insertions, 68 deletions

diff --git a/CORE/CLD_TXRX/HTT/htt_rx.c b/CORE/CLD_TXRX/HTT/htt_rx.c
index be47242c349b..c7dfc98f7019 100644
--- a/CORE/CLD_TXRX/HTT/htt_rx.c
+++ b/CORE/CLD_TXRX/HTT/htt_rx.c
@@ -1273,6 +1273,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(
     u_int32_t *msg_word;
     unsigned int msdu_count = 0;
     u_int8_t offload_ind;
+    struct htt_host_rx_desc_base *rx_desc;
 
     HTT_ASSERT1(htt_rx_in_order_ring_elems(pdev) != 0);
 
@@ -1312,6 +1313,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(
 
         /* cache consistency has been taken care of by the adf_nbuf_unmap */
 
+        rx_desc = htt_rx_desc(msdu);
         /*
          * Make the netbuf's data pointer point to the payload rather
          * than the descriptor.
@@ -1322,6 +1324,9 @@ htt_rx_amsdu_rx_in_order_pop_ll(
            msdu, HTT_RX_BUF_SIZE - (RX_STD_DESC_SIZE +
                               HTT_RX_IN_ORD_PADDR_IND_MSDU_LEN_GET(*(msg_word + 1))));
 
+        *((u_int8_t *) &rx_desc->fw_desc.u.val) =
+             HTT_RX_IN_ORD_PADDR_IND_FW_DESC_GET(*(msg_word + 1));
+
         msdu_count--;
 
         /* check if this is the last msdu */
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c b/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
index 4f8c70462fb3..a55035c64217 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx_fwd.c
@@ -233,6 +233,10 @@ ol_rx_fwd_check(
     }
     if (deliver_list_head) {
         adf_nbuf_set_next(deliver_list_tail, NULL); /* add NULL terminator */
-        ol_rx_deliver(vdev, peer, tid, deliver_list_head);
+        if (ol_cfg_is_full_reorder_offload(pdev->ctrl_pdev)) {
+            ol_rx_in_order_deliver(vdev, peer, tid, deliver_list_head);
+        } else {
+            ol_rx_deliver(vdev, peer, tid, deliver_list_head);
+        }
     }
 }
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx.c b/CORE/CLD_TXRX/TXRX/ol_txrx.c
index f3f3ac511d29..dbee37aec677 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx.c
@@ -474,7 +474,11 @@ ol_txrx_pdev_attach(
      */
     if (ol_cfg_is_full_reorder_offload(pdev->ctrl_pdev)) {
         /* PN check, rx-tx forwarding and rx reorder is done by the target */
-        pdev->rx_opt_proc = ol_rx_in_order_deliver;
+        if (ol_cfg_rx_fwd_disabled(pdev->ctrl_pdev)) {
+            pdev->rx_opt_proc = ol_rx_in_order_deliver;
+        } else {
+            pdev->rx_opt_proc = ol_rx_fwd_check;
+        }
     } else {
         if (ol_cfg_rx_pn_check(pdev->ctrl_pdev)) {
             if (ol_cfg_rx_fwd_disabled(pdev->ctrl_pdev)) {
diff --git a/CORE/HDD/inc/wlan_hdd_cfg.h b/CORE/HDD/inc/wlan_hdd_cfg.h
index 87e0f76b3382..bb340d0aabf8 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg.h
@@ -2713,6 +2713,64 @@ This feature requires the dependent cfg.ini "gRoamPrefer5GHz" set to 1 */
 #define CFG_ENABLE_SAP_SUSPEND_MAX                 ( 1 )
 #define CFG_ENABLE_SAP_SUSPEND_DEFAULT             ( 1 )
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+#define CFG_EXTWOW_GO_TO_SUSPEND                   "gExtWoWgotoSuspend"
+#define CFG_EXTWOW_GO_TO_SUSPEND_MIN               ( 0 )
+#define CFG_EXTWOW_GO_TO_SUSPEND_MAX               ( 1 )
+#define CFG_EXTWOW_GO_TO_SUSPEND_DEFAULT           ( 1 )
+
+#define CFG_EXTWOW_APP1_WAKE_PIN_NUMBER            "gExtWowApp1WakeupPinNumber"
+#define CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_MIN        ( 0 )
+#define CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_MAX        ( 255 )
+#define CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_DEFAULT    ( 12 )
+
+#define CFG_EXTWOW_APP2_WAKE_PIN_NUMBER            "gExtWowApp2WakeupPinNumber"
+#define CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_MIN        ( 0 )
+#define CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_MAX        ( 255 )
+#define CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_DEFAULT    ( 16 )
+
+#define CFG_EXTWOW_KA_INIT_PING_INTERVAL           "gExtWoWApp2KAInitPingInterval"
+#define CFG_EXTWOW_KA_INIT_PING_INTERVAL_MIN       ( 0 )
+#define CFG_EXTWOW_KA_INIT_PING_INTERVAL_MAX       ( 0xffffffff )
+#define CFG_EXTWOW_KA_INIT_PING_INTERVAL_DEFAULT   ( 240 )
+
+#define CFG_EXTWOW_KA_MIN_PING_INTERVAL            "gExtWoWApp2KAMinPingInterval"
+#define CFG_EXTWOW_KA_MIN_PING_INTERVAL_MIN        ( 0 )
+#define CFG_EXTWOW_KA_MIN_PING_INTERVAL_MAX        ( 0xffffffff )
+#define CFG_EXTWOW_KA_MIN_PING_INTERVAL_DEFAULT    ( 240 )
+
+#define CFG_EXTWOW_KA_MAX_PING_INTERVAL            "gExtWoWApp2KAMaxPingInterval"
+#define CFG_EXTWOW_KA_MAX_PING_INTERVAL_MIN        ( 0 )
+#define CFG_EXTWOW_KA_MAX_PING_INTERVAL_MAX        ( 0xffffffff )
+#define CFG_EXTWOW_KA_MAX_PING_INTERVAL_DEFAULT    ( 1280 )
+
+#define CFG_EXTWOW_KA_INC_PING_INTERVAL            "gExtWoWApp2KAIncPingInterval"
+#define CFG_EXTWOW_KA_INC_PING_INTERVAL_MIN        ( 0 )
+#define CFG_EXTWOW_KA_INC_PING_INTERVAL_MAX        ( 0xffffffff )
+#define CFG_EXTWOW_KA_INC_PING_INTERVAL_DEFAULT    ( 4 )
+
+#define CFG_EXTWOW_TCP_SRC_PORT                    "gExtWoWApp2TcpSrcPort"
+#define CFG_EXTWOW_TCP_SRC_PORT_MIN                ( 0 )
+#define CFG_EXTWOW_TCP_SRC_PORT_MAX                ( 65535 )
+#define CFG_EXTWOW_TCP_SRC_PORT_DEFAULT            ( 5000 )
+
+#define CFG_EXTWOW_TCP_DST_PORT                    "gExtWoWApp2TcpDstPort"
+#define CFG_EXTWOW_TCP_DST_PORT_MIN                ( 0 )
+#define CFG_EXTWOW_TCP_DST_PORT_MAX                ( 65535 )
+#define CFG_EXTWOW_TCP_DST_PORT_DEFAULT            ( 5001 )
+
+#define CFG_EXTWOW_TCP_TX_TIMEOUT                  "gExtWoWApp2TcpTxTimeout"
+#define CFG_EXTWOW_TCP_TX_TIMEOUT_MIN              ( 0 )
+#define CFG_EXTWOW_TCP_TX_TIMEOUT_MAX              ( 0xffffffff )
+#define CFG_EXTWOW_TCP_TX_TIMEOUT_DEFAULT          ( 200 )
+
+#define CFG_EXTWOW_TCP_RX_TIMEOUT                  "gExtWoWApp2TcpRxTimeout"
+#define CFG_EXTWOW_TCP_RX_TIMEOUT_MIN              ( 0 )
+#define CFG_EXTWOW_TCP_RX_TIMEOUT_MAX              ( 0xffffffff )
+#define CFG_EXTWOW_TCP_RX_TIMEOUT_DEFAULT          ( 200 )
+#endif
+
+
 /*---------------------------------------------------------------------------
   Type declarations
   -------------------------------------------------------------------------*/
@@ -3301,6 +3359,20 @@ typedef struct
 #endif /* FEATURE_WLAN_FORCE_SAP_SCC */
 
    v_BOOL_t                    enableSapSuspend;
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+   v_U8_t                      extWowGotoSuspend;
+   v_U8_t                      extWowApp1WakeupPinNumber;
+   v_U8_t                      extWowApp2WakeupPinNumber;
+   v_U32_t                     extWowApp2KAInitPingInterval;
+   v_U32_t                     extWowApp2KAMinPingInterval;
+   v_U32_t                     extWowApp2KAMaxPingInterval;
+   v_U32_t                     extWowApp2KAIncPingInterval;
+   v_U16_t                     extWowApp2TcpSrcPort;
+   v_U16_t                     extWowApp2TcpDstPort;
+   v_U32_t                     extWowApp2TcpTxTimeout;
+   v_U32_t                     extWowApp2TcpRxTimeout;
+#endif
 } hdd_config_t;
 
 #ifdef WLAN_FEATURE_MBSSID
diff --git a/CORE/HDD/inc/wlan_hdd_cfg80211.h b/CORE/HDD/inc/wlan_hdd_cfg80211.h
index 2aaa860dc3ef..93a69b7e53ee 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg80211.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg80211.h
@@ -839,4 +839,7 @@ void wlan_hdd_cfg80211_extscan_callback(void *ctx,
 struct cfg80211_bss* wlan_hdd_cfg80211_update_bss_list(
    hdd_adapter_t *pAdapter, tCsrRoamInfo *pRoamInfo);
 
+int wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
+                                   struct cfg80211_wowlan *wow);
+
 #endif
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index d8c6cb906e4a..cb740ee986ad 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -1487,6 +1487,13 @@ struct hdd_context_s
 
     vos_wake_lock_t sap_dfs_wakelock;
     atomic_t sap_dfs_ref_cnt;
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+    v_BOOL_t is_extwow_app_type1_param_set;
+    v_BOOL_t is_extwow_app_type2_param_set;
+    v_BOOL_t ext_wow_should_suspend;
+    struct completion ready_to_extwow;
+#endif
 };
 
 /*---------------------------------------------------------------------------
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index a9f7a22b37b9..c32a6f70561d 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -3258,7 +3258,8 @@ hdd_smeRoamCallback(void *pContext, tCsrRoamInfo *pRoamInfo, tANI_U32 roamId,
                     pHddStaCtx->hdd_ReassocScenario = VOS_FALSE;
             }
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
-            pRoamInfo->roamSynchInProgress = VOS_FALSE;
+            if (pRoamInfo != NULL)
+                pRoamInfo->roamSynchInProgress = VOS_FALSE;
 #endif
             break;
 #ifdef WLAN_FEATURE_VOWIFI_11R
diff --git a/CORE/HDD/src/wlan_hdd_cfg.c b/CORE/HDD/src/wlan_hdd_cfg.c
index 94992b63f38c..a725de691942 100644
--- a/CORE/HDD/src/wlan_hdd_cfg.c
+++ b/CORE/HDD/src/wlan_hdd_cfg.c
@@ -3786,6 +3786,85 @@ REG_TABLE_ENTRY g_registry_table[] =
                CFG_ENABLE_SAP_SUSPEND_DEFAULT,
                CFG_ENABLE_SAP_SUSPEND_MIN,
                CFG_ENABLE_SAP_SUSPEND_MAX ),
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+   REG_VARIABLE( CFG_EXTWOW_GO_TO_SUSPEND, WLAN_PARAM_Integer,
+              hdd_config_t, extWowGotoSuspend,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_GO_TO_SUSPEND_DEFAULT,
+              CFG_EXTWOW_GO_TO_SUSPEND_MIN,
+              CFG_EXTWOW_GO_TO_SUSPEND_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_APP1_WAKE_PIN_NUMBER, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp1WakeupPinNumber,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_DEFAULT,
+              CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_MIN,
+              CFG_EXTWOW_APP1_WAKE_PIN_NUMBER_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_APP2_WAKE_PIN_NUMBER, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2WakeupPinNumber,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_DEFAULT,
+              CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_MIN,
+              CFG_EXTWOW_APP2_WAKE_PIN_NUMBER_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_KA_INIT_PING_INTERVAL, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2KAInitPingInterval,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_KA_INIT_PING_INTERVAL_DEFAULT,
+              CFG_EXTWOW_KA_INIT_PING_INTERVAL_MIN,
+              CFG_EXTWOW_KA_INIT_PING_INTERVAL_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_KA_MIN_PING_INTERVAL, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2KAMinPingInterval,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_KA_MIN_PING_INTERVAL_DEFAULT,
+              CFG_EXTWOW_KA_MIN_PING_INTERVAL_MIN,
+              CFG_EXTWOW_KA_MIN_PING_INTERVAL_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_KA_MAX_PING_INTERVAL, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2KAMaxPingInterval,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_KA_MAX_PING_INTERVAL_DEFAULT,
+              CFG_EXTWOW_KA_MAX_PING_INTERVAL_MIN,
+              CFG_EXTWOW_KA_MAX_PING_INTERVAL_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_KA_INC_PING_INTERVAL, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2KAIncPingInterval,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_KA_INC_PING_INTERVAL_DEFAULT,
+              CFG_EXTWOW_KA_INC_PING_INTERVAL_MIN,
+              CFG_EXTWOW_KA_INC_PING_INTERVAL_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_TCP_SRC_PORT, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2TcpSrcPort,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_TCP_SRC_PORT_DEFAULT,
+              CFG_EXTWOW_TCP_SRC_PORT_MIN,
+              CFG_EXTWOW_TCP_SRC_PORT_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_TCP_DST_PORT, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2TcpDstPort,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_TCP_DST_PORT_DEFAULT,
+              CFG_EXTWOW_TCP_DST_PORT_MIN,
+              CFG_EXTWOW_TCP_DST_PORT_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_TCP_TX_TIMEOUT, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2TcpTxTimeout,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_TCP_TX_TIMEOUT_DEFAULT,
+              CFG_EXTWOW_TCP_TX_TIMEOUT_MIN,
+              CFG_EXTWOW_TCP_TX_TIMEOUT_MAX ),
+
+   REG_VARIABLE( CFG_EXTWOW_TCP_RX_TIMEOUT, WLAN_PARAM_Integer,
+              hdd_config_t, extWowApp2TcpRxTimeout,
+              VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+              CFG_EXTWOW_TCP_RX_TIMEOUT_DEFAULT,
+              CFG_EXTWOW_TCP_RX_TIMEOUT_MIN,
+              CFG_EXTWOW_TCP_RX_TIMEOUT_MAX ),
+#endif
 };
 
 #ifdef WLAN_FEATURE_MBSSID
@@ -4331,6 +4410,53 @@ void print_hdd_cfg(hdd_context_t *pHddCtx)
   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
             "Name = [gEnableSapSuspend] Value = [%u]",
             pHddCtx->cfg_ini->enableSapSuspend);
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWgotoSuspend] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowGotoSuspend);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWowApp1WakeupPinNumber] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp1WakeupPinNumber);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWowApp2WakeupPinNumber] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2WakeupPinNumber);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2KAInitPingInterval] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2KAInitPingInterval);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2KAMinPingInterval] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2KAMinPingInterval);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2KAMaxPingInterval] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2KAMaxPingInterval);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2KAIncPingInterval] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2KAIncPingInterval);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2TcpSrcPort] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2TcpSrcPort);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2TcpDstPort] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2TcpDstPort);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2TcpTxTimeout] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2TcpTxTimeout);
+
+  VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
+           "Name = [gExtWoWApp2TcpRxTimeout] Value = [%u]",
+                   pHddCtx->cfg_ini->extWowApp2TcpRxTimeout);
+#endif
+
 }
 
 #define CFG_VALUE_MAX_LEN 256
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 9ebb55e93bc9..7a2b4ff664ed 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -9548,7 +9548,6 @@ static int __wlan_hdd_cfg80211_connect( struct wiphy *wiphy,
         return status;
     }
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
-#define KEY_MGMT_OFFLOAD_BITMASK 0x4
     /* Supplicant indicate its decision to offload key management
      * by setting the third bit in flags in case of Secure connection
      * so if the supplicant does not support this then LFR3.0 shall
@@ -9559,26 +9558,29 @@ static int __wlan_hdd_cfg80211_connect( struct wiphy *wiphy,
      * enabled in INI and FW also has the capability to handle
      * key management offload as part of LFR3.0
      */
-    VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_DEBUG,
-            "%s: LFR3:Supplicant key mgmt offload capability flags %x",
-                                                  __func__,req->flags);
-    if (!(req->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) ||
-        (req->auth_type == NL80211_AUTHTYPE_FT)) {
-        if (!(req->flags & KEY_MGMT_OFFLOAD_BITMASK)) {
-            hddLog(VOS_TRACE_LEVEL_DEBUG,
-            FL("Supplicant does not support key mgmt offload for this AP"));
-            pHddCtx->cfg_ini->isRoamOffloadEnabled = 0;
-            status =    sme_UpdateRoamOffloadEnabled(pHddCtx->hHal, FALSE);
-        } else {
-            pHddCtx->cfg_ini->isRoamOffloadEnabled = 1;
-            status =    sme_UpdateRoamOffloadEnabled(pHddCtx->hHal, TRUE);
-        }
-        if (0 != status) {
-            VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-                   "%s: Could not update the RoamOffload enable", __func__);
-            return status;
-        }
+
+#ifdef NL80211_KEY_LEN_PMK /* if kernel supports key mgmt offload */
+    VOS_TRACE( VOS_MODULE_ID_HDD,
+               VOS_TRACE_LEVEL_ERROR,
+               "%s: LFR3:Supplicant association request flags %x",
+               __func__, req->flags);
+    if (!(req->flags & ASSOC_REQ_OFFLOAD_KEY_MGMT)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+        FL("Supplicant does not support key mgmt offload for this AP"));
+        sme_UpdateRoamKeyMgmtOffloadEnabled(pHddCtx->hHal,
+                                            pAdapter->sessionId,
+                                            FALSE);
+    } else {
+        sme_UpdateRoamKeyMgmtOffloadEnabled(pHddCtx->hHal,
+                                            pAdapter->sessionId,
+                                            TRUE);
     }
+#else
+    hddLog(VOS_TRACE_LEVEL_ERROR,
+        FL("Kernel does not support key mgmt offload"));
+    sme_UpdateRoamKeyMgmtOffloadEnabled(pHddCtx->hHal, pAdapter->sessionId, FALSE);
+#endif /* #ifdef NL80211_KEY_LEN_PMK */
+
 #endif
     if (vos_max_concurrent_connections_reached()) {
         hddLog(VOS_TRACE_LEVEL_ERROR, FL("Reached max concurrent connections"));
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 4c6e2aa50f72..2f2c7158378a 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -244,6 +244,11 @@ struct android_wifi_af_params {
    unsigned char data[ANDROID_WIFI_ACTION_FRAME_SIZE];
 } ;
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+#define WLAN_HDD_MAX_TCP_PORT            65535
+#define WLAN_WAIT_TIME_READY_TO_EXTWOW   2000
+#endif
+
 static vos_wake_lock_t wlan_wake_lock;
 /* set when SSR is needed after unload */
 static e_hdd_ssr_required isSsrRequired = HDD_SSR_NOT_REQUIRED;
@@ -3265,6 +3270,277 @@ eHalStatus hdd_parse_plm_cmd(tANI_U8 *pValue, tSirPlmReq *pPlmRequest)
      return eHAL_STATUS_SUCCESS;
 }
 #endif
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+static void wlan_hdd_ready_to_extwow(void *callbackContext,
+                                             boolean is_success)
+{
+    hdd_context_t *pHddCtx = (hdd_context_t *)callbackContext;
+    int rc;
+
+    rc = wlan_hdd_validate_context(pHddCtx);
+    if (0 != rc) {
+       hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid"));
+       return;
+    }
+    pHddCtx->ext_wow_should_suspend = is_success;
+    complete(&pHddCtx->ready_to_extwow);
+}
+
+static int hdd_enable_ext_wow(hdd_adapter_t *pAdapter,
+                               tpSirExtWoWParams arg_params)
+{
+    tSirExtWoWParams params;
+    eHalStatus halStatus = eHAL_STATUS_FAILURE;
+    hdd_context_t  *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
+    tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
+    int rc;
+
+    vos_mem_copy(&params, arg_params, sizeof(params));
+
+    INIT_COMPLETION(pHddCtx->ready_to_extwow);
+
+    halStatus = sme_ConfigureExtWoW(hHal, &params,
+                &wlan_hdd_ready_to_extwow, pHddCtx);
+    if (eHAL_STATUS_SUCCESS != halStatus) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               FL("sme_ConfigureExtWoW returned failure %d"), halStatus);
+        return -EPERM;
+    }
+
+    rc = wait_for_completion_timeout(&pHddCtx->ready_to_extwow,
+                             msecs_to_jiffies(WLAN_WAIT_TIME_READY_TO_EXTWOW));
+    if (!rc) {
+        VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                   "%s: Failed to get ready to extwow", __func__);
+        return -EPERM;
+    }
+
+    if (pHddCtx->ext_wow_should_suspend) {
+       if (pHddCtx->cfg_ini->extWowGotoSuspend) {
+          VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
+              "%s: Received ready to ExtWoW. Going to suspend", __func__);
+
+          wlan_hdd_cfg80211_suspend_wlan(pHddCtx->wiphy, NULL);
+          wlan_hif_pci_suspend();
+       }
+    } else {
+        VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+              "%s: Received ready to ExtWoW failure", __func__);
+        return -EPERM;
+    }
+
+    return 0;
+}
+
+static int hdd_enable_ext_wow_parser(hdd_adapter_t *pAdapter, int vdev_id,
+                                                                  int value)
+{
+   tSirExtWoWParams params;
+   hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
+   int rc;
+
+   rc = wlan_hdd_validate_context(pHddCtx);
+   if (0 != rc) {
+       hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid"));
+       return -EINVAL;
+   }
+
+   if (value < EXT_WOW_TYPE_APP_TYPE1 || value > EXT_WOW_TYPE_APP_TYPE1_2 ) {
+       hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid type"));
+       return -EINVAL;
+   }
+
+   if (value == EXT_WOW_TYPE_APP_TYPE1 &&
+        pHddCtx->is_extwow_app_type1_param_set)
+        params.type = value;
+   else if (value == EXT_WOW_TYPE_APP_TYPE2 &&
+        pHddCtx->is_extwow_app_type2_param_set)
+        params.type = value;
+   else if (value == EXT_WOW_TYPE_APP_TYPE1_2 &&
+        pHddCtx->is_extwow_app_type1_param_set &&
+        pHddCtx->is_extwow_app_type2_param_set)
+        params.type = value;
+   else {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+           FL("Set app params before enable it value %d"),value);
+        return -EINVAL;
+   }
+
+   params.vdev_id = vdev_id;
+   params.wakeup_pin_num = pHddCtx->cfg_ini->extWowApp1WakeupPinNumber |
+                      (pHddCtx->cfg_ini->extWowApp2WakeupPinNumber << 8);
+
+   return hdd_enable_ext_wow(pAdapter, &params);
+}
+
+static int hdd_set_app_type1_params(tHalHandle hHal,
+                         tpSirAppType1Params arg_params)
+{
+    tSirAppType1Params params;
+    eHalStatus halStatus = eHAL_STATUS_FAILURE;
+
+    vos_mem_copy(&params, arg_params, sizeof(params));
+
+    halStatus = sme_ConfigureAppType1Params(hHal, &params);
+    if (eHAL_STATUS_SUCCESS != halStatus) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+             FL("sme_ConfigureAppType1Params returned failure %d"), halStatus);
+        return -EPERM;
+    }
+
+    return 0;
+}
+
+static int hdd_set_app_type1_parser(hdd_adapter_t *pAdapter,
+                                             char *arg, int len)
+{
+    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
+    tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
+    char id[20], password[20];
+    tSirAppType1Params params;
+    int rc, i;
+
+    rc = wlan_hdd_validate_context(pHddCtx);
+    if (0 != rc) {
+       hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid"));
+       return -EINVAL;
+    }
+
+    if (2 != sscanf(arg, "%8s %16s", id, password)) {
+       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                 FL("Invalid Number of arguments"));
+       return -EINVAL;
+    }
+
+    memset(&params, 0, sizeof(tSirAppType1Params));
+    params.vdev_id = pAdapter->sessionId;
+    for (i = 0; i < ETHER_ADDR_LEN; i++)
+        params.wakee_mac_addr[i] = pAdapter->macAddressCurrent.bytes[i];
+
+    params.id_length = strlen(id);
+    vos_mem_copy(params.identification_id, id, params.id_length);
+    params.pass_length = strlen(password);
+    vos_mem_copy(params.password, password, params.pass_length);
+
+    VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
+        "%s: %d %pM %.8s %u %.16s %u",
+        __func__, params.vdev_id, params.wakee_mac_addr,
+        params.identification_id, params.id_length,
+        params.password, params.pass_length );
+
+    return hdd_set_app_type1_params(hHal, &params);
+}
+
+static int hdd_set_app_type2_params(tHalHandle hHal,
+                          tpSirAppType2Params arg_params)
+{
+    tSirAppType2Params params;
+    eHalStatus halStatus = eHAL_STATUS_FAILURE;
+
+    vos_mem_copy(&params, arg_params, sizeof(params));
+
+    halStatus = sme_ConfigureAppType2Params(hHal, &params);
+    if (eHAL_STATUS_SUCCESS != halStatus)
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+             FL("sme_ConfigureAppType2Params returned failure %d"), halStatus);
+        return -EPERM;
+    }
+
+    return 0;
+}
+
+static int hdd_set_app_type2_parser(hdd_adapter_t *pAdapter,
+                            char *arg, int len)
+{
+    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
+    tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
+    char mac_addr[20], rc4_key[20];
+    unsigned int gateway_mac[6], i;
+    tSirAppType2Params params;
+    int ret;
+
+    ret = wlan_hdd_validate_context(pHddCtx);
+    if (0 != ret) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid"));
+        return -EINVAL;
+    }
+
+    memset(&params, 0, sizeof(tSirAppType2Params));
+
+    ret = sscanf(arg, "%17s %16s %x %x %x %u %u %u %u %u %u %u %u %u %u",
+        mac_addr, rc4_key, (unsigned int *)&params.ip_id,
+        (unsigned int*)&params.ip_device_ip,
+        (unsigned int*)&params.ip_server_ip,
+        (unsigned int*)&params.tcp_seq, (unsigned int*)&params.tcp_ack_seq,
+        (unsigned int*)&params.tcp_src_port,
+        (unsigned int*)&params.tcp_dst_port,
+        (unsigned int*)&params.keepalive_init,
+        (unsigned int*)&params.keepalive_min,
+        (unsigned int*)&params.keepalive_max,
+        (unsigned int*)&params.keepalive_inc,
+        (unsigned int*)&params.tcp_tx_timeout_val,
+        (unsigned int*)&params.tcp_rx_timeout_val);
+
+
+    if (ret != 15 && ret != 7) {
+        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                 "Invalid Number of arguments");
+        return -EINVAL;
+    }
+
+    if (6 != sscanf(mac_addr, "%02x:%02x:%02x:%02x:%02x:%02x", &gateway_mac[0],
+             &gateway_mac[1], &gateway_mac[2], &gateway_mac[3],
+             &gateway_mac[4], &gateway_mac[5])) {
+        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+               "Invalid MacAddress Input %s", mac_addr);
+        return -EINVAL;
+    }
+
+    if (params.tcp_src_port > WLAN_HDD_MAX_TCP_PORT ||
+           params.tcp_dst_port > WLAN_HDD_MAX_TCP_PORT) {
+        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+             "Invalid TCP Port Number");
+        return -EINVAL;
+    }
+
+    for (i = 0; i < ETHER_ADDR_LEN; i++)
+        params.gateway_mac[i] = (uint8_t) gateway_mac[i];
+
+    params.rc4_key_len = strlen(rc4_key);
+    vos_mem_copy(params.rc4_key, rc4_key, params.rc4_key_len);
+
+    params.vdev_id = pAdapter->sessionId;
+    params.tcp_src_port = (params.tcp_src_port != 0)?
+        params.tcp_src_port : pHddCtx->cfg_ini->extWowApp2TcpSrcPort;
+    params.tcp_dst_port = (params.tcp_dst_port != 0)?
+        params.tcp_dst_port : pHddCtx->cfg_ini->extWowApp2TcpDstPort;
+    params.keepalive_init = (params.keepalive_init != 0)?
+        params.keepalive_init : pHddCtx->cfg_ini->extWowApp2KAInitPingInterval;
+    params.keepalive_min = (params.keepalive_min != 0)?
+        params.keepalive_min : pHddCtx->cfg_ini->extWowApp2KAMinPingInterval;
+    params.keepalive_max = (params.keepalive_max != 0)?
+        params.keepalive_max : pHddCtx->cfg_ini->extWowApp2KAMaxPingInterval;
+    params.keepalive_inc = (params.keepalive_inc != 0)?
+        params.keepalive_inc : pHddCtx->cfg_ini->extWowApp2KAIncPingInterval;
+    params.tcp_tx_timeout_val = (params.tcp_tx_timeout_val != 0)?
+        params.tcp_tx_timeout_val : pHddCtx->cfg_ini->extWowApp2TcpTxTimeout;
+    params.tcp_rx_timeout_val = (params.tcp_rx_timeout_val != 0)?
+        params.tcp_rx_timeout_val : pHddCtx->cfg_ini->extWowApp2TcpRxTimeout;
+
+    VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
+        "%s: %pM %.16s %u %u %u %u %u %u %u %u %u %u %u %u %u",
+        __func__, gateway_mac, rc4_key, params.ip_id, params.ip_device_ip,
+        params.ip_server_ip, params.tcp_seq, params.tcp_ack_seq,
+        params.tcp_src_port, params.tcp_dst_port, params.keepalive_init,
+        params.keepalive_min, params.keepalive_max,
+        params.keepalive_inc, params.tcp_tx_timeout_val,
+        params.tcp_rx_timeout_val);
+
+    return hdd_set_app_type2_params(hHal, &params);
+}
+
+#endif
 
 int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate)
 {
@@ -5643,6 +5919,39 @@ static int hdd_driver_command(hdd_adapter_t *pAdapter,
                goto exit;
            }
        }
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+       else if (strncmp(command, "ENABLEEXTWOW", 12) == 0) {
+
+           tANI_U8 *value = command;
+           int set_value;
+
+           /* Move pointer to ahead of ENABLEEXTWOW*/
+           value += 12;
+           sscanf(value, "%d", &set_value);
+           ret = hdd_enable_ext_wow_parser(pAdapter,
+                               pAdapter->sessionId, set_value);
+
+       } else if (strncmp(command, "SETAPP1PARAMS", 13) == 0) {
+           tANI_U8 *value = command;
+
+           /* Move pointer to ahead of SETAPP1PARAMS*/
+           value += 13;
+           ret = hdd_set_app_type1_parser(pAdapter,
+                                         value, strlen(value));
+           if (ret >= 0)
+               pHddCtx->is_extwow_app_type1_param_set = TRUE;
+
+       } else if (strncmp(command, "SETAPP2PARAMS", 13) == 0) {
+           tANI_U8 *value = command;
+
+           /* Move pointer to ahead of SETAPP2PARAMS*/
+           value += 13;
+           ret = hdd_set_app_type2_parser(pAdapter,
+                                         value, strlen(value));
+           if (ret >= 0)
+               pHddCtx->is_extwow_app_type2_param_set = TRUE;
+       }
+#endif
        else {
            MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                             TRACE_CODE_HDD_UNSUPPORTED_IOCTL,
@@ -7767,6 +8076,10 @@ static hdd_adapter_t* hdd_alloc_station_adapter( hdd_context_t *pHddCtx, tSirMac
       init_completion(&pAdapter->ula_complete);
       init_completion(&pAdapter->change_country_code);
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+      init_completion(&pHddCtx->ready_to_extwow);
+#endif
+
 #ifdef FEATURE_WLAN_BATCH_SCAN
       init_completion(&pAdapter->hdd_set_batch_scan_req_var);
       init_completion(&pAdapter->hdd_get_batch_scan_req_var);
diff --git a/CORE/MAC/inc/aniGlobal.h b/CORE/MAC/inc/aniGlobal.h
index a1e686e2af2c..b69c46d58b9a 100644
--- a/CORE/MAC/inc/aniGlobal.h
+++ b/CORE/MAC/inc/aniGlobal.h
@@ -1079,6 +1079,10 @@ typedef struct sAniSirGlobal
     v_BOOL_t enable5gEBT;
     /* Miracast session 0-Disabled, 1-Source, 2-sink*/
     tANI_U8 fMiracastSessionPresent;
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+    csrReadyToExtWoWCallback readyToExtWoWCallback;
+    void *readyToExtWoWContext;
+#endif
 } tAniSirGlobal;
 
 typedef enum
diff --git a/CORE/MAC/inc/qwlan_version.h b/CORE/MAC/inc/qwlan_version.h
index c37e9a350462..b6d856d1d9ee 100644
--- a/CORE/MAC/inc/qwlan_version.h
+++ b/CORE/MAC/inc/qwlan_version.h
@@ -42,9 +42,9 @@ BRIEF DESCRIPTION:
 #define QWLAN_VERSION_MINOR            0
 #define QWLAN_VERSION_PATCH            0
 #define QWLAN_VERSION_EXTRA            ""
-#define QWLAN_VERSION_BUILD            177
+#define QWLAN_VERSION_BUILD            178
 
-#define QWLAN_VERSIONSTR               "1.0.0.177"
+#define QWLAN_VERSIONSTR               "1.0.0.178"
 
 
 #define AR6320_REV1_VERSION             0x5000000
diff --git a/CORE/MAC/inc/sirApi.h b/CORE/MAC/inc/sirApi.h
index 47a457e29967..c69e7bebaa22 100644
--- a/CORE/MAC/inc/sirApi.h
+++ b/CORE/MAC/inc/sirApi.h
@@ -3559,6 +3559,62 @@ typedef struct sSirWlanResumeParam
     tANI_U8 configuredMcstBcstFilterSetting;
 }tSirWlanResumeParam,*tpSirWlanResumeParam;
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+
+typedef enum ext_wow_type
+{
+    EXT_WOW_TYPE_APP_TYPE1, /* wow type: only enable wakeup for app type1 */
+    EXT_WOW_TYPE_APP_TYPE2, /* wow type: only enable wakeup for app type2 */
+    EXT_WOW_TYPE_APP_TYPE1_2, /* wow type: enable wakeup for app type1&2 */
+
+}EXT_WOW_TYPE;
+
+typedef struct
+{
+    tANI_U8 vdev_id;
+    EXT_WOW_TYPE type;
+    tANI_U32 wakeup_pin_num;
+} tSirExtWoWParams, *tpSirExtWoWParams;
+
+typedef struct
+{
+    tANI_U8 vdev_id;
+    tSirMacAddr wakee_mac_addr;
+    tANI_U8 identification_id[8];
+    tANI_U8 password[16];
+    tANI_U32 id_length;
+    tANI_U32 pass_length;
+} tSirAppType1Params, *tpSirAppType1Params;
+
+typedef struct
+{
+    tANI_U8 vdev_id;
+
+    tANI_U8 rc4_key[16];
+    tANI_U32 rc4_key_len;
+
+    /** ip header parameter */
+    tANI_U32 ip_id; /* NC id */
+    tANI_U32 ip_device_ip; /* NC IP address */
+    tANI_U32 ip_server_ip; /* Push server IP address */
+
+    /** tcp header parameter */
+    tANI_U16 tcp_src_port; /* NC TCP port */
+    tANI_U16 tcp_dst_port; /* Push server TCP port */
+    tANI_U32 tcp_seq;
+    tANI_U32 tcp_ack_seq;
+
+    tANI_U32 keepalive_init; /* Initial ping interval */
+    tANI_U32 keepalive_min; /* Minimum ping interval */
+    tANI_U32 keepalive_max; /* Maximum ping interval */
+    tANI_U32 keepalive_inc; /* Increment of ping interval */
+
+    tSirMacAddr gateway_mac;
+    tANI_U32 tcp_tx_timeout_val;
+    tANI_U32 tcp_rx_timeout_val;
+} tSirAppType2Params, *tpSirAppType2Params;
+#endif
+
 typedef struct sSirWlanSetRxpFilters
 {
     tANI_U8 configuredMcstBcstFilterSetting;
@@ -3756,6 +3812,7 @@ typedef struct sSirRoamOffloadScanReq
   tSirAcUapsd AcUapsd;
   tANI_U8   R0KH_ID[SIR_ROAM_R0KH_ID_MAX_LEN];
   tANI_U32  R0KH_ID_Length;
+  tANI_U8   RoamKeyMgmtOffloadEnabled;
 #endif
 } tSirRoamOffloadScanReq, *tpSirRoamOffloadScanReq;
 
@@ -4490,6 +4547,14 @@ typedef struct
     tANI_U16      mesgLen;
     tANI_BOOLEAN  suspended;
 }  tSirReadyToSuspendInd, *tpSirReadyToSuspendInd;
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+typedef struct
+{
+    tANI_U16      mesgType;
+    tANI_U16      mesgLen;
+    tANI_BOOLEAN  status;
+}  tSirReadyToExtWoWInd, *tpSirReadyToExtWoWInd;
+#endif
 typedef struct sSirRateUpdateInd
 {
     tANI_U8 nss; /* 0: 1x1, 1: 2x2 */
@@ -4746,6 +4811,7 @@ typedef struct sSirSmeRoamOffloadSynchInd
     tANI_U32    authStatus;
     tANI_U8     rssi;
     tANI_U8     roamReason;
+    tANI_U32    chan_freq;
 } tSirSmeRoamOffloadSynchInd, *tpSirSmeRoamOffloadSynchInd;
 
 typedef struct sSirSmeRoamOffloadSynchCnf
diff --git a/CORE/MAC/inc/wniApi.h b/CORE/MAC/inc/wniApi.h
index 02702f6bbeb4..282484ac141f 100644
--- a/CORE/MAC/inc/wniApi.h
+++ b/CORE/MAC/inc/wniApi.h
@@ -394,6 +394,9 @@ enum eWniMsgTypes
     eWNI_SME_NAN_EVENT,
 #endif
     eWNI_SME_LINK_STATUS_IND,
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+    eWNI_SME_READY_TO_EXTWOW_IND,
+#endif
     eWNI_SME_MSG_TYPES_END
 };
 
diff --git a/CORE/MAC/src/include/sirParams.h b/CORE/MAC/src/include/sirParams.h
index c4808ec75f1c..a5ea8654ad03 100644
--- a/CORE/MAC/src/include/sirParams.h
+++ b/CORE/MAC/src/include/sirParams.h
@@ -638,6 +638,13 @@ typedef struct sSirMbMsgP2p
 
 #define SIR_HAL_LINK_STATUS_GET_REQ        (SIR_HAL_ITC_MSG_TYPES_BEGIN + 285)
 #define SIR_HAL_GET_LINK_STATUS_RSP_IND    (SIR_HAL_ITC_MSG_TYPES_BEGIN + 286)
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+#define SIR_HAL_CONFIG_EXT_WOW             (SIR_HAL_ITC_MSG_TYPES_BEGIN + 287)
+#define SIR_HAL_CONFIG_APP_TYPE1_PARAMS    (SIR_HAL_ITC_MSG_TYPES_BEGIN + 288)
+#define SIR_HAL_CONFIG_APP_TYPE2_PARAMS    (SIR_HAL_ITC_MSG_TYPES_BEGIN + 289)
+#endif
+
 #define SIR_HAL_MSG_TYPES_END              (SIR_HAL_MSG_TYPES_BEGIN + 0x1FF)
 
 // CFG message types
diff --git a/CORE/MAC/src/pe/lim/limProcessAssocRspFrame.c b/CORE/MAC/src/pe/lim/limProcessAssocRspFrame.c
index 8dcd0e641e00..24048b71611c 100644
--- a/CORE/MAC/src/pe/lim/limProcessAssocRspFrame.c
+++ b/CORE/MAC/src/pe/lim/limProcessAssocRspFrame.c
@@ -337,6 +337,16 @@ limProcessAssocRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo, tANI_U8 sub
     mlmAssocCnf.resultCode = eSIR_SME_SUCCESS;
     /* Update PE session Id*/
     mlmAssocCnf.sessionId = psessionEntry->peSessionId;
+    if (pHdr == NULL) {
+        limLog(pMac, LOGE,
+               FL("LFR3: Reassoc response packet header is NULL"));
+        return;
+    } else if ( pHdr->sa == NULL) {
+        limLog(pMac, LOGE,
+               FL("LFR3: Reassoc response packet source address is NULL"));
+        return;
+    }
+
     limLog(pMac, LOG1,
               FL("received Re/Assoc(%d) resp on sessionid: %d with systemrole: %d "
               "and mlmstate: %d RSSI %d from "MAC_ADDRESS_STR),subType,
diff --git a/CORE/SERVICES/COMMON/wmi_tlv_defs.h b/CORE/SERVICES/COMMON/wmi_tlv_defs.h
index 4068b000795e..6a13d7d03447 100644
--- a/CORE/SERVICES/COMMON/wmi_tlv_defs.h
+++ b/CORE/SERVICES/COMMON/wmi_tlv_defs.h
@@ -2071,7 +2071,8 @@ WMITLV_CREATE_PARAM_STRUC(WMI_ROAM_EVENTID);
 #define WMITLV_TABLE_WMI_ROAM_SYNCH_EVENTID(id,op,buf,len)                                                      \
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_roam_synch_event_fixed_param, wmi_roam_synch_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, bcn_probe_rsp_frame, WMITLV_SIZE_VAR) \
-    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, reassoc_rsp_frame, WMITLV_SIZE_VAR)
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, reassoc_rsp_frame, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_channel, wmi_channel, chan, WMITLV_SIZE_FIX)
 WMITLV_CREATE_PARAM_STRUC(WMI_ROAM_SYNCH_EVENTID);
 
 /* WOW Wakeup Host Event */
diff --git a/CORE/SERVICES/COMMON/wmi_unified.h b/CORE/SERVICES/COMMON/wmi_unified.h
index 10777815896b..ff933d9981d7 100644
--- a/CORE/SERVICES/COMMON/wmi_unified.h
+++ b/CORE/SERVICES/COMMON/wmi_unified.h
@@ -7739,7 +7739,7 @@ typedef struct {
      * The TLV's are:
      *     A_UINT8 bcn_probe_rsp_frame[];  length identified by bcn_probe_rsp_len
      *     A_UINT8 reassoc_rsp_frame[];  length identified by reassoc_rsp_len
-     *
+     *      wmi_channel chan;
      **/
 } wmi_roam_synch_event_fixed_param;
 
diff --git a/CORE/SERVICES/HIF/PCIe/if_pci.c b/CORE/SERVICES/HIF/PCIe/if_pci.c
index aea5e505aa8e..55a24e8d1d8e 100644
--- a/CORE/SERVICES/HIF/PCIe/if_pci.c
+++ b/CORE/SERVICES/HIF/PCIe/if_pci.c
@@ -2205,3 +2205,18 @@ void hif_read_bar(struct hif_pci_softc *sc, u32 *bar_value)
 }
 #endif /* IPA_UC_OFFLOAD */
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+void wlan_hif_pci_suspend(void)
+{
+    void *vos_context = vos_get_global_context(VOS_MODULE_ID_HIF, NULL);
+    struct ol_softc *scn =  vos_get_context(VOS_MODULE_ID_HIF, vos_context);
+    pm_message_t state;
+
+    if (!scn || !scn->hif_sc) {
+        printk(KERN_ERR "%s: error: scn or scn->hif_sc is NULL!\n", __func__);
+        return;
+    }
+    state.event = PM_EVENT_SUSPEND;
+    hif_pci_suspend(scn->hif_sc->pdev, state);
+}
+#endif
diff --git a/CORE/SERVICES/HIF/PCIe/if_pci.h b/CORE/SERVICES/HIF/PCIe/if_pci.h
index 0cdb61d754f2..4fb6de1c3356 100644
--- a/CORE/SERVICES/HIF/PCIe/if_pci.h
+++ b/CORE/SERVICES/HIF/PCIe/if_pci.h
@@ -176,5 +176,7 @@ void hif_read_bar(struct hif_pci_softc *sc, u32 *bar_value);
 #define OL_ATH_TX_DRAIN_WAIT_CNT       10
 
 #define HIF_CE_DRAIN_WAIT_CNT          20
-
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+void wlan_hif_pci_suspend(void);
+#endif
 #endif /* __ATH_PCI_H__ */
diff --git a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
index 84c24db5ad21..60e8d0796d55 100644
--- a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
+++ b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
@@ -1594,7 +1594,8 @@ static A_STATUS hifEnableFunc(HIF_DEVICE *device, struct sdio_func *func)
             setAsyncIRQ = 1;
             ret = Func0_CMD52WriteByte(func->card, CCCR_SDIO_IRQ_MODE_REG_AR6003,
                     SDIO_IRQ_MODE_ASYNC_4BIT_IRQ_AR6003);
-        } else if (manufacturer_id == MANUFACTURER_ID_AR6320_BASE){
+        } else if (manufacturer_id == MANUFACTURER_ID_AR6320_BASE ||
+                   manufacturer_id == MANUFACTURER_ID_QCA9377_BASE) {
             unsigned char data = 0;
             setAsyncIRQ = 1;
             ret = Func0_CMD52ReadByte(func->card, CCCR_SDIO_IRQ_MODE_REG_AR6320, &data);
diff --git a/CORE/SERVICES/WMA/wma.c b/CORE/SERVICES/WMA/wma.c
index c848b92a2744..fe104e6a1819 100644
--- a/CORE/SERVICES/WMA/wma.c
+++ b/CORE/SERVICES/WMA/wma.c
@@ -1794,6 +1794,207 @@ free_req_msg:
 	return status;
 }
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+static void wma_send_status_of_ext_wow(tp_wma_handle wma, boolean status)
+{
+	tSirReadyToExtWoWInd *ready_to_extwow;
+	VOS_STATUS vstatus;
+	vos_msg_t vos_msg;
+	u_int8_t len;
+
+	WMA_LOGD("Posting ready to suspend indication to umac");
+
+	len = sizeof(tSirReadyToExtWoWInd);
+	ready_to_extwow = (tSirReadyToExtWoWInd *) vos_mem_malloc(len);
+
+	if (NULL == ready_to_extwow) {
+		WMA_LOGE("%s: Memory allocation failure", __func__);
+		return;
+	}
+
+	ready_to_extwow->mesgType = eWNI_SME_READY_TO_EXTWOW_IND;
+	ready_to_extwow->mesgLen = len;
+	ready_to_extwow->status= status;
+
+	vos_msg.type = eWNI_SME_READY_TO_EXTWOW_IND;
+	vos_msg.bodyptr = (void *) ready_to_extwow;
+	vos_msg.bodyval = 0;
+
+	vstatus = vos_mq_post_message(VOS_MQ_ID_SME, &vos_msg);
+	if (vstatus != VOS_STATUS_SUCCESS) {
+		WMA_LOGE("Failed to post ready to suspend");
+		vos_mem_free(ready_to_extwow);
+	}
+}
+
+static int wma_enable_ext_wow(tp_wma_handle wma,
+			 tpSirExtWoWParams params)
+{
+	wmi_extwow_enable_cmd_fixed_param *cmd;
+	wmi_buf_t buf;
+	int32_t len;
+	int ret;
+
+	len = sizeof(wmi_extwow_enable_cmd_fixed_param);
+	buf = wmi_buf_alloc(wma->wmi_handle, len);
+	if (!buf) {
+		WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
+		return VOS_STATUS_E_NOMEM;
+	}
+
+	cmd = (wmi_extwow_enable_cmd_fixed_param *) wmi_buf_data(buf);
+
+	WMITLV_SET_HDR(&cmd->tlv_header,
+		       WMITLV_TAG_STRUC_wmi_extwow_enable_cmd_fixed_param,
+		       WMITLV_GET_STRUCT_TLVLEN(
+				wmi_extwow_enable_cmd_fixed_param));
+
+	cmd->vdev_id = params->vdev_id;
+	cmd->type = params->type;
+	cmd->wakeup_pin_num = params->wakeup_pin_num;
+
+	WMA_LOGD("%s: vdev_id %d type %d Wakeup_pin_num %x",
+		 __func__, cmd->vdev_id,
+		 cmd->type, cmd->wakeup_pin_num);
+
+	ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
+				   WMI_EXTWOW_ENABLE_CMDID);
+	if (ret) {
+		WMA_LOGE("%s: Failed to set EXTWOW Enable", __func__);
+		wmi_buf_free(buf);
+		wma_send_status_of_ext_wow(wma, FALSE);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	wma_send_status_of_ext_wow(wma, TRUE);
+	return VOS_STATUS_SUCCESS;
+
+}
+
+static int wma_set_app_type1_params_in_fw(tp_wma_handle wma,
+			 tpSirAppType1Params appType1Params)
+{
+	wmi_extwow_set_app_type1_params_cmd_fixed_param *cmd;
+	wmi_buf_t buf;
+	int32_t len;
+	int ret;
+
+	len = sizeof(wmi_extwow_set_app_type1_params_cmd_fixed_param);
+	buf = wmi_buf_alloc(wma->wmi_handle, len);
+	if (!buf) {
+		WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
+		return VOS_STATUS_E_NOMEM;
+	}
+
+	cmd = (wmi_extwow_set_app_type1_params_cmd_fixed_param *)
+						    wmi_buf_data(buf);
+
+	WMITLV_SET_HDR(&cmd->tlv_header,
+	    WMITLV_TAG_STRUC_wmi_extwow_set_app_type1_params_cmd_fixed_param,
+	    WMITLV_GET_STRUCT_TLVLEN(
+			wmi_extwow_set_app_type1_params_cmd_fixed_param));
+
+	cmd->vdev_id = appType1Params->vdev_id;
+	WMI_CHAR_ARRAY_TO_MAC_ADDR(appType1Params->wakee_mac_addr,
+							 &cmd->wakee_mac);
+	vos_mem_copy(cmd->ident, appType1Params->identification_id, 8);
+	cmd->ident_len = appType1Params->id_length;
+	vos_mem_copy(cmd->passwd, appType1Params->password, 16);
+	cmd->passwd_len = appType1Params->pass_length;
+
+	WMA_LOGD("%s: vdev_id %d wakee_mac_addr %pM "
+			 "identification_id %.8s id_length %u "
+			 "password %.16s pass_length %u",
+		__func__, cmd->vdev_id, appType1Params->wakee_mac_addr,
+		cmd->ident, cmd->ident_len,
+		cmd->passwd, cmd->passwd_len);
+
+	ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
+				   WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
+	if (ret) {
+		WMA_LOGE("%s: Failed to set APP TYPE1 PARAMS", __func__);
+		wmi_buf_free(buf);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	return VOS_STATUS_SUCCESS;
+}
+
+static int wma_set_app_type2_params_in_fw(tp_wma_handle wma,
+			 tpSirAppType2Params appType2Params)
+{
+	wmi_extwow_set_app_type2_params_cmd_fixed_param *cmd;
+	wmi_buf_t buf;
+	int32_t len;
+	int ret;
+
+	len = sizeof(wmi_extwow_set_app_type2_params_cmd_fixed_param);
+	buf = wmi_buf_alloc(wma->wmi_handle, len);
+	if (!buf) {
+		WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
+		return VOS_STATUS_E_NOMEM;
+	}
+
+	cmd = (wmi_extwow_set_app_type2_params_cmd_fixed_param *)
+						    wmi_buf_data(buf);
+
+	WMITLV_SET_HDR(&cmd->tlv_header,
+             WMITLV_TAG_STRUC_wmi_extwow_set_app_type2_params_cmd_fixed_param,
+             WMITLV_GET_STRUCT_TLVLEN(
+			wmi_extwow_set_app_type2_params_cmd_fixed_param));
+
+	cmd->vdev_id = appType2Params->vdev_id;
+
+	vos_mem_copy(cmd->rc4_key, appType2Params->rc4_key, 16);
+	cmd->rc4_key_len = appType2Params->rc4_key_len;
+
+	cmd->ip_id = appType2Params->ip_id;
+	cmd->ip_device_ip = appType2Params->ip_device_ip;
+	cmd->ip_server_ip = appType2Params->ip_server_ip;
+
+	cmd->tcp_src_port = appType2Params->tcp_src_port;
+	cmd->tcp_dst_port = appType2Params->tcp_dst_port;
+	cmd->tcp_seq = appType2Params->tcp_seq;
+	cmd->tcp_ack_seq = appType2Params->tcp_ack_seq;
+
+	cmd->keepalive_init = appType2Params->keepalive_init;
+	cmd->keepalive_min = appType2Params->keepalive_min;
+	cmd->keepalive_max = appType2Params->keepalive_max;
+	cmd->keepalive_inc = appType2Params->keepalive_inc;
+
+	WMI_CHAR_ARRAY_TO_MAC_ADDR(appType2Params->gateway_mac,
+						&cmd->gateway_mac);
+	cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
+	cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
+
+	WMA_LOGD("%s: vdev_id %d gateway_mac %pM "
+			 "rc4_key %.16s rc4_key_len %u "
+			 "ip_id %x ip_device_ip %x ip_server_ip %x "
+			 "tcp_src_port %u tcp_dst_port %u tcp_seq %u "
+			 "tcp_ack_seq %u keepalive_init %u keepalive_min %u "
+			 "keepalive_max %u keepalive_inc %u "
+			 "tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
+		__func__, cmd->vdev_id, appType2Params->gateway_mac,
+		cmd->rc4_key, cmd->rc4_key_len,
+		cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
+		cmd->tcp_src_port, cmd->tcp_dst_port, cmd->tcp_seq,
+		cmd->tcp_ack_seq, cmd->keepalive_init, cmd->keepalive_min,
+		cmd->keepalive_max, cmd->keepalive_inc,
+		cmd->tcp_tx_timeout_val, cmd->tcp_rx_timeout_val);
+
+
+	ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
+				   WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID);
+	if (ret) {
+		WMA_LOGE("%s: Failed to set APP TYPE2 PARAMS", __func__);
+		wmi_buf_free(buf);
+		return VOS_STATUS_E_FAILURE;
+	}
+
+	return VOS_STATUS_SUCCESS;
+
+}
+#endif
 static void wma_update_pdev_stats(tp_wma_handle wma,
 					wmi_pdev_stats *pdev_stats)
 {
@@ -4480,6 +4681,7 @@ static int wma_roam_synch_event_handler(void *handle, u_int8_t *event, u_int32_t
         tp_wma_handle wma = (tp_wma_handle)handle;
 	VOS_STATUS status;
 	vos_msg_t vos_msg;
+	wmi_channel *chan = NULL;
 	int size=0;
 	tSirSmeRoamOffloadSynchInd *pRoamOffloadSynchInd;
 
@@ -4532,6 +4734,8 @@ static int wma_roam_synch_event_handler(void *handle, u_int8_t *event, u_int32_t
 	vos_mem_copy(reassoc_rsp_ptr,
 			param_buf->reassoc_rsp_frame,
 			pRoamOffloadSynchInd->reassocRespLength);
+	chan = (wmi_channel *) param_buf->chan;
+	pRoamOffloadSynchInd->chan_freq = chan->mhz;
 	vos_msg.type = eWNI_SME_ROAM_OFFLOAD_SYNCH_IND;
 	vos_msg.bodyptr = (void *) pRoamOffloadSynchInd;
 	vos_msg.bodyval = 0;
@@ -7465,7 +7669,15 @@ VOS_STATUS wma_roam_scan_offload_mode(tp_wma_handle wma_handle,
 				buf_ptr += WMI_TLV_HDR_SIZE;
 				roam_offload_11i =
 				(wmi_roam_11i_offload_tlv_param *) buf_ptr;
-				WMI_SET_ROAM_OFFLOAD_OKC_ENABLED(roam_offload_11i->flags);
+				if (roam_req->RoamKeyMgmtOffloadEnabled) {
+					WMI_SET_ROAM_OFFLOAD_OKC_ENABLED(
+						roam_offload_11i->flags);
+				} else {
+					WMI_SET_ROAM_OFFLOAD_OKC_DISABLED(
+						roam_offload_11i->flags);
+				}
+
+
 				vos_mem_copy (roam_offload_11i->pmk, roam_req->PSK_PMK,
                                              sizeof(roam_req->PSK_PMK));
 				roam_offload_11i->pmk_len = roam_req->pmk_len;
@@ -21731,6 +21943,23 @@ VOS_STATUS wma_mc_process_msg(v_VOID_t *vos_context, vos_msg_t *msg)
 					(tHalHiddenSsidVdevRestart *)msg->bodyptr);
 			vos_mem_free(msg->bodyptr);
 			break;
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+		case WDA_WLAN_EXT_WOW:
+			wma_enable_ext_wow(wma_handle,
+				(tSirExtWoWParams *)msg->bodyptr);
+			vos_mem_free(msg->bodyptr);
+			break;
+		case WDA_WLAN_SET_APP_TYPE1_PARAMS:
+			wma_set_app_type1_params_in_fw(wma_handle,
+				(tSirAppType1Params *)msg->bodyptr);
+			vos_mem_free(msg->bodyptr);
+			break;
+		case WDA_WLAN_SET_APP_TYPE2_PARAMS:
+			wma_set_app_type2_params_in_fw(wma_handle,
+				(tSirAppType2Params *)msg->bodyptr);
+			vos_mem_free(msg->bodyptr);
+			break;
+#endif
 		case WDA_VDEV_START_RSP_IND:
 			wma_vdev_start_rsp_ind(wma_handle, msg->bodyptr);
 			vos_mem_free(msg->bodyptr);
diff --git a/CORE/SME/inc/csrApi.h b/CORE/SME/inc/csrApi.h
index 044f25967bc1..dc63cc404d62 100644
--- a/CORE/SME/inc/csrApi.h
+++ b/CORE/SME/inc/csrApi.h
@@ -1737,6 +1737,11 @@ eHalStatus csrSetBand(tHalHandle hHal, tANI_U8 sessionId, eCsrBand eBand);
 eCsrBand csrGetCurrentBand (tHalHandle hHal);
 
 typedef void (*csrReadyToSuspendCallback)(void *pContext, boolean suspended);
+
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+typedef void (*csrReadyToExtWoWCallback)(void *pContext, boolean status);
+#endif
+
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 eHalStatus csrRoamIssueFTRoamOffloadSynch(tHalHandle hHal, tANI_U32 sessionId,
                                           tSirBssDescription *pBssDescription);
diff --git a/CORE/SME/inc/csrInternal.h b/CORE/SME/inc/csrInternal.h
index c9083fd99da2..2ddbbc01662d 100644
--- a/CORE/SME/inc/csrInternal.h
+++ b/CORE/SME/inc/csrInternal.h
@@ -980,6 +980,7 @@ typedef struct tagCsrRoamSession
     tCsrRoamOffloadSynchStruct roamOffloadSynchParams;
     tANI_U8 psk_pmk[SIR_ROAM_SCAN_PSK_SIZE];
     size_t  pmk_len;
+    tANI_U8 RoamKeyMgmtOffloadEnabled;
 #endif
 
     /* SME FT Context */
diff --git a/CORE/SME/inc/sme_Api.h b/CORE/SME/inc/sme_Api.h
index 4a5de1c9a67b..6aa83b82030f 100644
--- a/CORE/SME/inc/sme_Api.h
+++ b/CORE/SME/inc/sme_Api.h
@@ -2114,6 +2114,70 @@ eHalStatus sme_ConfigureSuspendInd( tHalHandle hHal,
 eHalStatus sme_ConfigureResumeReq( tHalHandle hHal,
                              tpSirWlanResumeParam  wlanResumeParam);
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureExtWoW
+
+  \brief
+    SME will pass this request to lower mac to configure Indoor WoW parameters.
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanExtParams- Depicts the wlan Ext params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureExtWoW( tHalHandle hHal,
+                          tpSirExtWoWParams  wlanExtParams,
+                          csrReadyToSuspendCallback callback,
+                          void *callbackContext);
+
+
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureAppType1Params
+
+  \brief
+    SME will pass this request to lower mac to configure Indoor WoW parameters.
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanAppType1Params- Depicts the wlan Indoor params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureAppType1Params( tHalHandle hHal,
+                          tpSirAppType1Params  wlanAppType1Params);
+
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureAppType2Params
+
+  \brief
+    SME will pass this request to lower mac to configure Indoor WoW parameters.
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanAppType2Params- Depicts the wlan Indoor params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureAppType2Params( tHalHandle hHal,
+                          tpSirAppType2Params  wlanAppType2Params);
+#endif
 
 /* ---------------------------------------------------------------------------
 
@@ -3959,6 +4023,21 @@ eHalStatus sme_SetLinkLayerStatsIndCB
   --------------------------------------------------------------------------*/
 eHalStatus sme_UpdateRoamOffloadEnabled(tHalHandle hHal,
                                      v_BOOL_t nRoamOffloadEnabled);
+
+/*--------------------------------------------------------------------------
+  \brief sme_UpdateRoamKeyMgmtOffloadEnabled() - enable/disable key mgmt offload
+  This is a synchronous call
+  \param hHal - The handle returned by macOpen.
+  \param  sessionId - Session Identifier
+  \param nRoamKeyMgmtOffloadEnabled - The boolean to update with
+  \return eHAL_STATUS_SUCCESS - SME update config successfully.
+          Other status means SME is failed to update.
+  \sa
+  --------------------------------------------------------------------------*/
+eHalStatus sme_UpdateRoamKeyMgmtOffloadEnabled(tHalHandle hHal,
+                                     tANI_U8 sessionId,
+                                     v_BOOL_t nRoamKeyMgmtOffloadEnabled);
+
 #endif
 
 #ifdef WLAN_FEATURE_NAN
diff --git a/CORE/SME/inc/sme_Trace.h b/CORE/SME/inc/sme_Trace.h
index 19bd38f1f8ba..dfdb9962fc6e 100644
--- a/CORE/SME/inc/sme_Trace.h
+++ b/CORE/SME/inc/sme_Trace.h
@@ -112,6 +112,11 @@ enum {
     TRACE_CODE_SME_RX_HDD_CONFIG_RXPFIL,
     TRACE_CODE_SME_RX_HDD_CONFIG_SUSPENDIND,
     TRACE_CODE_SME_RX_HDD_CONFIG_RESUMEREQ,
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+    TRACE_CODE_SME_RX_HDD_CONFIG_EXTWOW,
+    TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE1,
+    TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE2,
+#endif
     TRACE_CODE_SME_RX_HDD_SET_MAXTXPOW,
     TRACE_CODE_SME_RX_HDD_SET_TXPOW,
     TRACE_CODE_SME_RX_HDD_SET_TMLEVEL,
diff --git a/CORE/SME/src/csr/csrApiRoam.c b/CORE/SME/src/csr/csrApiRoam.c
index 87c985a34925..f902e6c15c89 100644
--- a/CORE/SME/src/csr/csrApiRoam.c
+++ b/CORE/SME/src/csr/csrApiRoam.c
@@ -16364,6 +16364,19 @@ csrRoamScanOffloadPrepareProbeReqTemplate(tpAniSirGlobal pMac,
 }
 
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
+eHalStatus csrRoamSetKeyMgmtOffload(tpAniSirGlobal pMac,
+                                    tANI_U32 sessionId,
+                                    v_BOOL_t nRoamKeyMgmtOffloadEnabled)
+{
+    tCsrRoamSession *pSession = CSR_GET_SESSION(pMac, sessionId);
+    if (!pSession) {
+        smsLog(pMac, LOGE, FL("session %d not found"), sessionId);
+        return eHAL_STATUS_FAILURE;
+    }
+    pSession->RoamKeyMgmtOffloadEnabled = nRoamKeyMgmtOffloadEnabled;
+    return eHAL_STATUS_SUCCESS;
+}
+
 void csrRoamOffload(tpAniSirGlobal pMac, tSirRoamOffloadScanReq *pRequestBuf,
                                                    tCsrRoamSession *pSession)
 {
@@ -16717,6 +16730,7 @@ eHalStatus csrRoamOffloadScan(tpAniSirGlobal pMac, tANI_U8 sessionId,
    pRequestBuf->allowDFSChannelRoam = pMac->roam.configParam.allowDFSChannelRoam;
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
    pRequestBuf->RoamOffloadEnabled = csrRoamIsRoamOffloadEnabled(pMac);
+   pRequestBuf->RoamKeyMgmtOffloadEnabled = pSession->RoamKeyMgmtOffloadEnabled;
    /* Roam Offload piggybacks upon the Roam Scan offload command.*/
    if (pRequestBuf->RoamOffloadEnabled){
        csrRoamOffload(pMac, pRequestBuf, pSession);
diff --git a/CORE/SME/src/csr/csrApiScan.c b/CORE/SME/src/csr/csrApiScan.c
index 2bee76670762..23eac328d3df 100644
--- a/CORE/SME/src/csr/csrApiScan.c
+++ b/CORE/SME/src/csr/csrApiScan.c
@@ -8735,8 +8735,12 @@ eHalStatus csrScanSaveRoamOffloadApToScanCache(tpAniSirGlobal pMac,
    }
    else
    {
-      pBssDescr->channelId = pParsedFrame->channelNumber;
+      /*If DS Params or HTIE is not present in the probe resp or beacon,
+       * then use the channel frequency provided by firmware to fill the
+       * channel in the BSS descriptor.*/
+      pBssDescr->channelId = vos_freq_to_chan(pRoamOffloadSynchInd->chan_freq);
    }
+   pBssDescr->channelIdSelf = pBssDescr->channelId;
 
    if ((pBssDescr->channelId > 0) && (pBssDescr->channelId < 15))
    {
@@ -8780,12 +8784,13 @@ eHalStatus csrScanSaveRoamOffloadApToScanCache(tpAniSirGlobal pMac,
       vos_mem_copy((tANI_U8 *)pBssDescr->mdie, (tANI_U8 *)pParsedFrame->mdie, SIR_MDIE_SIZE);
    }
 
-   VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+   VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
                                 "LFR3:%s:BssDescr Info:", __func__);
-   VOS_TRACE_HEX_DUMP(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+   VOS_TRACE_HEX_DUMP(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
                                  pBssDescr->bssId, sizeof(tSirMacAddr));
    VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
-              "chan= %d, rssi = %d",pBssDescr->channelId,pBssDescr->rssi);
+             "LFR3:chan = %d, rssi = %d",
+             pBssDescr->channelId, pBssDescr->rssi);
 
    if (uLen)
    {
@@ -8808,7 +8813,7 @@ eHalStatus csrScanSaveRoamOffloadApToScanCache(tpAniSirGlobal pMac,
 
    fDupBss = csrRemoveDupBssDescription(pMac,
                                         &pScanResult->Result.BssDescriptor,
-                                        pIesLocal, &tmpSsid, &timer, FALSE);
+                                        pIesLocal, &tmpSsid, &timer, TRUE);
    if ( CSR_SCAN_IS_OVER_BSS_LIMIT(pMac) )
    {
       VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
diff --git a/CORE/SME/src/csr/csrInsideApi.h b/CORE/SME/src/csr/csrInsideApi.h
index 567a71f1bd22..c5d75ba3719c 100644
--- a/CORE/SME/src/csr/csrInsideApi.h
+++ b/CORE/SME/src/csr/csrInsideApi.h
@@ -778,6 +778,19 @@ eHalStatus csrRoamSetPMKIDCache( tpAniSirGlobal pMac, tANI_U32 sessionId,
  *-------------------------------------------------------------------------------*/
 eHalStatus csrRoamSetPSK_PMK(tpAniSirGlobal pMac, tANI_U32 sessionId,
                              tANI_U8 *pPSK_PMK, size_t pmk_len);
+
+/* ---------------------------------------------------------------------------
+ *\fn csrRoamSetKeyMgmtOffload
+ *\brief sets nRoamKeyMgmtOffloadEnabled
+ *\param pMac  - pointer to global structure for MAC
+ *\param sessionId - Sme session id
+ *\param nRoamKeyMgmtOffloadEnabled - value of key mgmt offload enable
+ *\return eHalStatus - usually it succeed unless sessionId is not found
+ *\Note:
+ *-------------------------------------------------------------------------------*/
+eHalStatus csrRoamSetKeyMgmtOffload(tpAniSirGlobal pMac,
+                                    tANI_U32 sessionId,
+                                    v_BOOL_t nRoamKeyMgmtOffloadEnabled);
 #endif
 /* ---------------------------------------------------------------------------
     \fn csrRoamGetWpaRsnReqIE
diff --git a/CORE/SME/src/csr/csrNeighborRoam.c b/CORE/SME/src/csr/csrNeighborRoam.c
index 3ef402fea699..6dddb64a6d57 100644
--- a/CORE/SME/src/csr/csrNeighborRoam.c
+++ b/CORE/SME/src/csr/csrNeighborRoam.c
@@ -5134,46 +5134,40 @@ eHalStatus csrNeighborRoamIndicateConnect(tpAniSirGlobal pMac,
                          if (eSIR_ROAM_AUTH_STATUS_AUTHENTICATED ==
                              pSession->roamOffloadSynchParams.authStatus)
                          {
-                             pRoamOffloadSynchCnf =
-                             vos_mem_malloc(sizeof(tSirSmeRoamOffloadSynchCnf));
-                             if (NULL == pRoamOffloadSynchCnf)
-                             {
-                                 VOS_TRACE(VOS_MODULE_ID_SME,
-                                 VOS_TRACE_LEVEL_ERROR,
-                                 "%s: not able to allocate memory for roam"
-                                 "offload synch confirmation data", __func__);
-                                 return eHAL_STATUS_FAILURE;
-                             }
                              VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
                                "LFR3: Sending authorized event to supplicant");
                              csrRoamCallCallback(pMac, sessionId, &roamInfo, 0,
                                                 eCSR_ROAM_AUTHORIZED_EVENT, 0);
-                             pRoamOffloadSynchCnf->sessionId = sessionId;
-                             msg.type     = WDA_ROAM_OFFLOAD_SYNCH_CNF;
-                             msg.reserved = 0;
-                             msg.bodyptr  = pRoamOffloadSynchCnf;
-                             VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
-                                   "LFR3: Posting WDA_ROAM_OFFLOAD_SYNCH_CNF");
-                             if (!VOS_IS_STATUS_SUCCESS(vos_mq_post_message(
-                                                    VOS_MODULE_ID_WDA, &msg)))
-                             {
-                                 VOS_TRACE(VOS_MODULE_ID_SME,
-                                 VOS_TRACE_LEVEL_DEBUG,
-                                 "%s: Not able to post"
-                                 "WDA_ROAM_OFFLOAD_SYNCH_CNF message to WDA",
-                                 __func__);
-                                 vos_mem_free(pRoamOffloadSynchCnf);
-                                 return eHAL_STATUS_FAILURE;
-                             }
+                         }
+                         pRoamOffloadSynchCnf =
+                         vos_mem_malloc(sizeof(tSirSmeRoamOffloadSynchCnf));
+                         if (NULL == pRoamOffloadSynchCnf)
+                         {
+                             VOS_TRACE(VOS_MODULE_ID_SME,
+                             VOS_TRACE_LEVEL_ERROR,
+                             "%s: not able to allocate memory for roam"
+                             "offload synch confirmation data", __func__);
+                             return eHAL_STATUS_FAILURE;
+                         }
+                         pRoamOffloadSynchCnf->sessionId = sessionId;
+                         msg.type     = WDA_ROAM_OFFLOAD_SYNCH_CNF;
+                         msg.reserved = 0;
+                         msg.bodyptr  = pRoamOffloadSynchCnf;
+                         VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_DEBUG,
+                               "LFR3: Posting WDA_ROAM_OFFLOAD_SYNCH_CNF");
+                         if (!VOS_IS_STATUS_SUCCESS(vos_mq_post_message(
+                                                VOS_MODULE_ID_WDA, &msg)))
+                         {
+                             VOS_TRACE(VOS_MODULE_ID_SME,
+                             VOS_TRACE_LEVEL_DEBUG,
+                             "%s: Not able to post"
+                             "WDA_ROAM_OFFLOAD_SYNCH_CNF message to WDA",
+                              __func__);
+                              vos_mem_free(pRoamOffloadSynchCnf);
+                              return eHAL_STATUS_FAILURE;
                          }
                          pSession->roamOffloadSynchParams.bRoamSynchInProgress =
                          VOS_FALSE;
-                         if (eSIR_ROAM_AUTH_STATUS_CONNECTED ==
-                             pSession->roamOffloadSynchParams.authStatus) {
-                             csrRoamOffloadScan(pMac, sessionId,
-                                                ROAM_SCAN_OFFLOAD_START,
-                                                REASON_CONNECT);
-                         }
                      } else
 #endif
                      csrRoamOffloadScan(pMac, sessionId,
diff --git a/CORE/SME/src/sme_common/sme_Api.c b/CORE/SME/src/sme_common/sme_Api.c
index d7c554f66d52..513832b30bf9 100644
--- a/CORE/SME/src/sme_common/sme_Api.c
+++ b/CORE/SME/src/sme_common/sme_Api.c
@@ -1704,6 +1704,46 @@ void sme_ProcessReadyToSuspend( tHalHandle hHal,
    }
 }
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+/*--------------------------------------------------------------------------
+
+  \fn - sme_ProcessReadyToExtWoW
+  \brief - On getting ready to Ext WoW indication, this function calls
+             callback registered (HDD callbacks) with SME to inform
+             ready to ExtWoW indication.
+
+  \param hHal - Handle returned by macOpen.
+   pReadyToExtWoW - Parameter received along with ready to Ext WoW
+                                indication from WMA.
+
+  \return None
+
+  \sa
+
+ --------------------------------------------------------------------------*/
+void sme_ProcessReadyToExtWoW( tHalHandle hHal,
+                                 tpSirReadyToExtWoWInd pReadyToExtWoW)
+{
+   tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
+
+   if (NULL == pMac)
+   {
+       VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_FATAL,
+             "%s: pMac is null", __func__);
+       return ;
+   }
+
+   if (NULL != pMac->readyToExtWoWCallback)
+   {
+       pMac->readyToExtWoWCallback (pMac->readyToExtWoWContext,
+                                    pReadyToExtWoW->status);
+       pMac->readyToExtWoWCallback = NULL;
+       pMac->readyToExtWoWContext = NULL;
+   }
+
+}
+#endif
+
 /* ---------------------------------------------------------------------------
     \fn sme_ChangeConfigParams
     \brief The SME API exposed for HDD to provide config params to SME during
@@ -2623,6 +2663,21 @@ eHalStatus sme_ProcessMsg(tHalHandle hHal, vos_msg_t* pMsg)
                 }
                 break ;
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+           case eWNI_SME_READY_TO_EXTWOW_IND:
+                if (pMsg->bodyptr)
+                {
+                     sme_ProcessReadyToExtWoW(pMac, pMsg->bodyptr);
+                     vos_mem_free(pMsg->bodyptr);
+                }
+                else
+                {
+                     smsLog(pMac, LOGE, "Empty rsp message"
+                     "for (eWNI_SME_READY_TO_EXTWOW_IND), nothing to process");
+                }
+                break ;
+#endif
+
 #ifdef FEATURE_WLAN_CH_AVOID
            /* channel avoid message arrived, send IND to client */
            case eWNI_SME_CH_AVOID_IND:
@@ -7236,6 +7291,173 @@ eHalStatus sme_ConfigureResumeReq( tHalHandle hHal,
     return(status);
 }
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureExtWoW
+
+  \brief
+    SME will pass this request to lower mac to configure Extr WoW
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanExtParams- Depicts the wlan Ext params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureExtWoW( tHalHandle hHal,
+                          tpSirExtWoWParams  wlanExtParams,
+                          csrReadyToExtWoWCallback callback,
+                             void *callbackContext)
+{
+    eHalStatus status = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+    tpSirExtWoWParams MsgPtr = vos_mem_malloc(sizeof(*MsgPtr));
+
+    if (!MsgPtr)
+        return eHAL_STATUS_FAILURE;
+
+    MTRACE(vos_trace(VOS_MODULE_ID_SME,
+                  TRACE_CODE_SME_RX_HDD_CONFIG_EXTWOW, NO_SESSION, 0));
+
+    pMac->readyToExtWoWCallback = callback;
+    pMac->readyToExtWoWContext = callbackContext;
+
+    if ( eHAL_STATUS_SUCCESS ==
+              ( status = sme_AcquireGlobalLock( &pMac->sme ) ) ) {
+
+        /* serialize the req through MC thread */
+        vos_mem_copy(MsgPtr, wlanExtParams, sizeof(*MsgPtr));
+        vosMessage.bodyptr = MsgPtr;
+        vosMessage.type =  WDA_WLAN_EXT_WOW;
+        vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &vosMessage );
+        if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) {
+            pMac->readyToExtWoWCallback = NULL;
+            pMac->readyToExtWoWContext = NULL;
+            vos_mem_free(MsgPtr);
+            status = eHAL_STATUS_FAILURE;
+        }
+        sme_ReleaseGlobalLock( &pMac->sme );
+    } else {
+        pMac->readyToExtWoWCallback = NULL;
+        pMac->readyToExtWoWContext = NULL;
+        vos_mem_free(MsgPtr);
+    }
+
+    return(status);
+}
+
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureAppType1Params
+
+  \brief
+   SME will pass this request to lower mac to configure Indoor WoW parameters.
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanAppType1Params- Depicts the wlan App Type 1(Indoor) params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureAppType1Params( tHalHandle hHal,
+                          tpSirAppType1Params  wlanAppType1Params)
+{
+    eHalStatus status = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+    vos_msg_t       vosMessage;
+    tpSirAppType1Params MsgPtr = vos_mem_malloc(sizeof(*MsgPtr));
+
+    if (!MsgPtr)
+        return eHAL_STATUS_FAILURE;
+
+    MTRACE(vos_trace(VOS_MODULE_ID_SME,
+                  TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE1, NO_SESSION, 0));
+
+    if ( eHAL_STATUS_SUCCESS ==
+              ( status = sme_AcquireGlobalLock( &pMac->sme ) ) ) {
+
+        /* serialize the req through MC thread */
+        vos_mem_copy(MsgPtr, wlanAppType1Params, sizeof(*MsgPtr));
+        vosMessage.bodyptr = MsgPtr;
+        vosMessage.type    =  WDA_WLAN_SET_APP_TYPE1_PARAMS;
+        vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &vosMessage );
+        if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) {
+           vos_mem_free(MsgPtr);
+           status = eHAL_STATUS_FAILURE;
+        }
+        sme_ReleaseGlobalLock( &pMac->sme );
+    } else {
+        vos_mem_free(MsgPtr);
+    }
+
+    return(status);
+}
+
+/* ---------------------------------------------------------------------------
+
+  \fn    sme_ConfigureAppType2Params
+
+  \brief
+   SME will pass this request to lower mac to configure Indoor WoW parameters.
+
+  \param
+
+    hHal - The handle returned by macOpen.
+
+    wlanAppType2Params- Depicts the wlan App Type 2 (Outdoor) params
+
+  \return eHalStatus
+
+
+--------------------------------------------------------------------------- */
+eHalStatus sme_ConfigureAppType2Params( tHalHandle hHal,
+                          tpSirAppType2Params  wlanAppType2Params)
+{
+    eHalStatus status = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+    vos_msg_t       vosMessage;
+    tpSirAppType2Params MsgPtr = vos_mem_malloc(sizeof(*MsgPtr));
+
+    if (!MsgPtr)
+        return eHAL_STATUS_FAILURE;
+
+    MTRACE(vos_trace(VOS_MODULE_ID_SME,
+                  TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE2, NO_SESSION, 0));
+
+    if ( eHAL_STATUS_SUCCESS ==
+            ( status = sme_AcquireGlobalLock( &pMac->sme ) ) ) {
+
+        /* serialize the req through MC thread */
+        vos_mem_copy(MsgPtr, wlanAppType2Params, sizeof(*MsgPtr));
+        vosMessage.bodyptr = MsgPtr;
+        vosMessage.type =  WDA_WLAN_SET_APP_TYPE2_PARAMS;
+        vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &vosMessage );
+        if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) {
+           vos_mem_free(MsgPtr);
+           status = eHAL_STATUS_FAILURE;
+        }
+        sme_ReleaseGlobalLock( &pMac->sme );
+    } else {
+        vos_mem_free(MsgPtr);
+    }
+
+    return(status);
+}
+#endif
+
 /* ---------------------------------------------------------------------------
 
     \fn sme_GetInfraSessionId
@@ -13697,4 +13919,43 @@ eHalStatus sme_UpdateRoamOffloadEnabled(tHalHandle hHal,
 
     return status ;
 }
+
+/*--------------------------------------------------------------------------
+  \brief sme_UpdateRoamKeyMgmtOffloadEnabled() - enable/disable key mgmt offload
+  This is a synchronous call
+  \param hHal - The handle returned by macOpen.
+  \param  sessionId - Session Identifier
+  \param nRoamKeyMgmtOffloadEnabled - The boolean to update with
+  \return eHAL_STATUS_SUCCESS - SME update config successfully.
+          Other status means SME is failed to update.
+  \sa
+  --------------------------------------------------------------------------*/
+
+eHalStatus sme_UpdateRoamKeyMgmtOffloadEnabled(tHalHandle hHal,
+                                     tANI_U8 sessionId,
+                                     v_BOOL_t nRoamKeyMgmtOffloadEnabled)
+
+{
+    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+
+    status = sme_AcquireGlobalLock(&pMac->sme);
+    if (HAL_STATUS_SUCCESS(status))
+    {
+        if (CSR_IS_SESSION_VALID(pMac, sessionId)) {
+            VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+                      "%s: LFR3: KeyMgmtOffloadEnabled changed to %d",
+                      __func__,
+                      nRoamKeyMgmtOffloadEnabled);
+            status = csrRoamSetKeyMgmtOffload(pMac,
+                                              sessionId,
+                                              nRoamKeyMgmtOffloadEnabled);
+        } else {
+            status = eHAL_STATUS_INVALID_PARAMETER;
+        }
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+
+    return status ;
+}
 #endif
diff --git a/CORE/SME/src/sme_common/sme_Trace.c b/CORE/SME/src/sme_common/sme_Trace.c
index 0295cbfc9468..c38d09a14cc4 100644
--- a/CORE/SME/src/sme_common/sme_Trace.c
+++ b/CORE/SME/src/sme_common/sme_Trace.c
@@ -120,6 +120,11 @@ static tANI_U8* smeTraceGetRxMsgString( tANI_U32 code )
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_RXPFIL);
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_SUSPENDIND);
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_RESUMEREQ);
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+        CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_EXTWOW);
+        CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE1);
+        CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_CONFIG_APP_TYPE2);
+#endif
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_SET_MAXTXPOW);
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_SET_TXPOW);
         CASE_RETURN_STRING(TRACE_CODE_SME_RX_HDD_SET_TMLEVEL);
diff --git a/CORE/SYS/legacy/src/utils/src/macTrace.c b/CORE/SYS/legacy/src/utils/src/macTrace.c
index c408e00323f8..323106db780d 100644
--- a/CORE/SYS/legacy/src/utils/src/macTrace.c
+++ b/CORE/SYS/legacy/src/utils/src/macTrace.c
@@ -730,6 +730,11 @@ tANI_U8* macTraceGetWdaMsgString( tANI_U16 wdaMsg )
         CASE_RETURN_STRING(WDA_TX_COMPLETE_TIMEOUT_IND);
         CASE_RETURN_STRING(WDA_WLAN_SUSPEND_IND);
         CASE_RETURN_STRING(WDA_WLAN_RESUME_REQ);
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+        CASE_RETURN_STRING(WDA_WLAN_EXT_WOW);
+        CASE_RETURN_STRING(WDA_WLAN_SET_APP_TYPE1_PARAMS);
+        CASE_RETURN_STRING(WDA_WLAN_SET_APP_TYPE2_PARAMS);
+#endif
         CASE_RETURN_STRING(WDA_MSG_TYPES_END);
         CASE_RETURN_STRING(WDA_MMH_TXMB_READY_EVT);
         CASE_RETURN_STRING(WDA_MMH_RXMB_DONE_EVT);
diff --git a/CORE/WDA/inc/wlan_qct_wda.h b/CORE/WDA/inc/wlan_qct_wda.h
index fb4cf660df67..286247baadfe 100644
--- a/CORE/WDA/inc/wlan_qct_wda.h
+++ b/CORE/WDA/inc/wlan_qct_wda.h
@@ -972,6 +972,12 @@ tSirRetStatus uMacPostCtrlMsg(void* pSirGlobal, tSirMbMsg* pMb);
 #define WDA_LINK_STATUS_GET_REQ SIR_HAL_LINK_STATUS_GET_REQ
 #define WDA_GET_LINK_STATUS_RSP_IND SIR_HAL_GET_LINK_STATUS_RSP_IND
 
+#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
+#define WDA_WLAN_EXT_WOW                      SIR_HAL_CONFIG_EXT_WOW
+#define WDA_WLAN_SET_APP_TYPE1_PARAMS         SIR_HAL_CONFIG_APP_TYPE1_PARAMS
+#define WDA_WLAN_SET_APP_TYPE2_PARAMS         SIR_HAL_CONFIG_APP_TYPE2_PARAMS
+#endif
+
 tSirRetStatus wdaPostCtrlMsg(tpAniSirGlobal pMac, tSirMsgQ *pMsg);
 
 #define HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME 0x40 // Bit 6 will be used to control BD rate for Management frames
diff --git a/Kbuild b/Kbuild
index 81876500bc2b..b8475398845c 100644
--- a/Kbuild
+++ b/Kbuild
@@ -199,6 +199,11 @@ CONFIG_CHECKSUM_OFFLOAD := 1
 #Enable GTK offload
 CONFIG_GTK_OFFLOAD := 1
 
+#Enable EXT WOW
+ifeq ($(CONFIG_ROME_IF),pci)
+	CONFIG_EXT_WOW := 1
+endif
+
 #Set this to 1 to catch erroneous Target accesses during debug.
 CONFIG_ATH_PCIE_ACCESS_DEBUG := 0
 
@@ -1181,6 +1186,11 @@ CDEFINES += -DWLAN_FEATURE_GTK_OFFLOAD
 CDEFINES += -DIGTK_OFFLOAD
 endif
 
+#Enable GTK Offload
+ifeq ($(CONFIG_EXT_WOW), 1)
+CDEFINES += -DWLAN_FEATURE_EXTWOW_SUPPORT
+endif
+
 #Mark it as SMP Kernel
 ifeq ($(CONFIG_SMP),y)
 CDEFINES += -DQCA_CONFIG_SMP