Merge "Release 1.0.0.133 QCACLD WLAN Driver"

24 files changed, 1215 insertions, 69 deletions

diff --git a/CORE/CLD_TXRX/TLSHIM/tl_shim.c b/CORE/CLD_TXRX/TLSHIM/tl_shim.c
index 210f37e34510..de3d16017b0d 100644
--- a/CORE/CLD_TXRX/TLSHIM/tl_shim.c
+++ b/CORE/CLD_TXRX/TLSHIM/tl_shim.c
@@ -46,6 +46,9 @@
 #include "wma_api.h"
 #include "vos_utils.h"
 #include "wdi_out.h"
+
+#define TLSHIM_PEER_AUTHORIZE_WAIT 10
+
 #define ENTER() VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__)
 
 #define TLSHIM_LOGD(args...) \
@@ -1543,8 +1546,16 @@ VOS_STATUS WLANTL_ChangeSTAState(void *vos_ctx, u_int8_t sta_id,
 	struct ol_txrx_peer_t *peer;
 	enum ol_txrx_peer_state txrx_state = ol_txrx_peer_state_invalid;
 	int err;
+	struct txrx_tl_shim_ctx *tl_shim = vos_get_context(VOS_MODULE_ID_TL,
+							   vos_ctx);
 
 	ENTER();
+
+	if (!tl_shim) {
+		TLSHIM_LOGE("%s: Failed to get TLSHIM context", __func__);
+		return VOS_STATUS_E_FAILURE;
+	}
+
 	if (sta_id >= WLAN_MAX_STA_COUNT) {
 		TLSHIM_LOGE("Invalid sta id :%d", sta_id);
 		return VOS_STATUS_E_INVAL;
@@ -1565,6 +1576,10 @@ VOS_STATUS WLANTL_ChangeSTAState(void *vos_ctx, u_int8_t sta_id,
 				  txrx_state);
 
 	if (txrx_state == ol_txrx_peer_state_auth) {
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+		/* make sure event is reset */
+		vos_event_reset(&tl_shim->peer_authorized_events[peer->vdev->vdev_id]);
+#endif
 		err = wma_set_peer_param(
 				((pVosContextType) vos_ctx)->pWDAContext,
 				peer->mac_addr.raw, WMI_PEER_AUTHORIZE,
@@ -1576,6 +1591,15 @@ VOS_STATUS WLANTL_ChangeSTAState(void *vos_ctx, u_int8_t sta_id,
 
 		if (peer->vdev->opmode == wlan_op_mode_sta) {
 #ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+			/*
+			 * TODO: following code waits on event without
+			 * checking if the event was already set. Currently
+			 * there is no vos api to check if event was already
+			 * set fix it cleanly later.
+			 */
+			/* wait for event from firmware to set the event */
+			vos_wait_single_event(&tl_shim->peer_authorized_events[peer->vdev->vdev_id],
+					      TLSHIM_PEER_AUTHORIZE_WAIT);
 			wdi_in_vdev_unpause(peer->vdev,
 				    OL_TXQ_PAUSE_REASON_PEER_UNAUTHORIZED);
 #endif
@@ -1734,8 +1758,14 @@ VOS_STATUS WLANTL_Close(void *vos_ctx)
 	for (i = 0;
 		i < wdi_out_cfg_max_vdevs(((pVosContextType)vos_ctx)->cfg_ctx);
 		i++) {
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+		vos_event_destroy(&tl_shim->peer_authorized_events[i]);
+#endif
 		adf_os_spinlock_destroy(&tl_shim->session_flow_control[i].fc_lock);
 	}
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+	adf_os_mem_free(tl_shim->peer_authorized_events);
+#endif
 	adf_os_mem_free(tl_shim->session_flow_control);
 #endif /* QCA_LL_TX_FLOW_CT */
 	adf_os_mem_free(tl_shim->vdev_active);
@@ -1819,11 +1849,32 @@ VOS_STATUS WLANTL_Open(void *vos_ctx, WLANTL_ConfigInfoType *tl_cfg)
 		return VOS_STATUS_E_NOMEM;
 	}
 
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+	tl_shim->peer_authorized_events = adf_os_mem_alloc(NULL,
+					  max_vdev * sizeof(vos_event_t));
+	if (!tl_shim->peer_authorized_events) {
+		TLSHIM_LOGE("Failed to allocate memory for events");
+		adf_os_mem_free(tl_shim->session_flow_control);
+		vos_free_context(vos_ctx, VOS_MODULE_ID_TL, tl_shim);
+		return VOS_STATUS_E_NOMEM;
+	}
+#endif
 	for (i = 0; i < max_vdev; i++) {
 		tl_shim->session_flow_control[i].flowControl = NULL;
 		tl_shim->session_flow_control[i].sessionId = 0xFF;
 		tl_shim->session_flow_control[i].adpaterCtxt = NULL;
 		tl_shim->session_flow_control[i].vdev = NULL;
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+		status = vos_event_init(&tl_shim->peer_authorized_events[i]);
+		if (!VOS_IS_STATUS_SUCCESS(status)) {
+			TLSHIM_LOGE("%s: Failed to initialized a event.",
+				    __func__);
+			adf_os_mem_free(tl_shim->peer_authorized_events);
+			adf_os_mem_free(tl_shim->session_flow_control);
+			vos_free_context(vos_ctx, VOS_MODULE_ID_TL, tl_shim);
+			return status;
+		}
+#endif
 		adf_os_spinlock_init(&tl_shim->session_flow_control[i].fc_lock);
 	}
 #endif /* QCA_LL_TX_FLOW_CT */
@@ -2183,3 +2234,16 @@ void WLANTL_SetAdapterMaxQDepth
 }
 #endif /* QCA_LL_TX_FLOW_CT */
 
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+void tl_shim_set_peer_authorized_event(void *vos_ctx, v_U8_t session_id)
+{
+	struct txrx_tl_shim_ctx *tl_shim = vos_get_context(VOS_MODULE_ID_TL, vos_ctx);
+
+	if (!tl_shim) {
+		TLSHIM_LOGE("%s: Failed to get TLSHIM context", __func__);
+		return;
+	}
+
+	vos_event_set(&tl_shim->peer_authorized_events[session_id]);
+}
+#endif
diff --git a/CORE/CLD_TXRX/TLSHIM/tl_shim.h b/CORE/CLD_TXRX/TLSHIM/tl_shim.h
index a0eaacfc3d3e..4d3070f5ec6f 100644
--- a/CORE/CLD_TXRX/TLSHIM/tl_shim.h
+++ b/CORE/CLD_TXRX/TLSHIM/tl_shim.h
@@ -94,6 +94,10 @@ struct deferred_iapp_work iapp_work;
 #ifdef QCA_LL_TX_FLOW_CT
 	struct tlshim_session_flow_Control *session_flow_control;
 #endif /* QCA_LL_TX_FLOW_CT */
+
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+	vos_event_t  *peer_authorized_events;
+#endif
 };
 
 /*
@@ -112,4 +116,11 @@ int tlshim_mgmt_roam_event_ind(void *context, u_int32_t vdev_id);
 void *tl_shim_get_vdev_by_addr(void *vos_context, uint8_t *mac_addr);
 void *tl_shim_get_vdev_by_sta_id(void *vos_context, uint8_t sta_id);
 
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+void tl_shim_set_peer_authorized_event(void *vos_ctx, v_U8_t session_id);
+#else
+static inline void tl_shim_set_peer_authorized_event(void *vos_ctx, v_U8_t session_id)
+{
+}
+#endif
 #endif
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_classify.c b/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
index 9663d2cf0f83..d5136f0b5245 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_classify.c
@@ -170,33 +170,80 @@ ol_tx_tid_by_ipv6(
     return (IPV6_TRAFFIC_CLASS((struct ipv6_hdr_t *) pkt) >> 5) & 0x7;
 }
 
-static inline A_UINT8
-ol_tx_tid_by_ether_type(
+static inline void
+ol_tx_set_ether_type(
     A_UINT8 *datap,
     struct ol_txrx_msdu_info_t *tx_msdu_info)
 {
-    A_UINT8 tid;
-    A_UINT8 *l3_data_ptr;
     A_UINT16 typeorlength;
     A_UINT8 * ptr;
+    A_UINT8 *l3_data_ptr;
 
-    ptr = (datap + ETHERNET_ADDR_LEN * 2);
-    typeorlength = (ptr[0] << 8) | ptr[1];
-    l3_data_ptr = datap + sizeof(struct ethernet_hdr_t);//ETHERNET_HDR_LEN;
+    if (tx_msdu_info->htt.info.l2_hdr_type == htt_pkt_type_raw) {
+         /* adjust hdr_ptr to RA */
+        struct ieee80211_frame *wh = (struct ieee80211_frame *)datap;
 
-    if (typeorlength == ETHERTYPE_VLAN) {
-        ptr = (datap + ETHERNET_ADDR_LEN * 2 + ETHERTYPE_VLAN_LEN);
+        if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_DATA) {
+            struct llc_snap_hdr_t *llc;
+            /* dot11 encapsulated frame */
+            struct ieee80211_qosframe *whqos = (struct ieee80211_qosframe *)datap;
+            if (whqos->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
+                tx_msdu_info->htt.info.l3_hdr_offset =
+                    sizeof(struct ieee80211_qosframe);
+            } else {
+                tx_msdu_info->htt.info.l3_hdr_offset =
+                    sizeof(struct ieee80211_frame);
+            }
+            llc = (struct llc_snap_hdr_t *)
+                (datap + tx_msdu_info->htt.info.l3_hdr_offset);
+            tx_msdu_info->htt.info.ethertype =
+                (llc->ethertype[0] << 8) | llc->ethertype[1];
+            /*
+             * l3_hdr_offset refers to the end of the 802.3 or 802.11 header,
+             * which may be a LLC/SNAP header rather than the IP header.
+             * Thus, don't increment l3_hdr_offset += sizeof(*llc); rather,
+             * leave it as is.
+             */
+        } else {
+            /*
+             * This function should only be applied to data frames.
+             * For management frames, we already know to use HTT_TX_EXT_TID_MGMT.
+             */
+            TXRX_ASSERT2(0);
+        }
+    } else if (tx_msdu_info->htt.info.l2_hdr_type == htt_pkt_type_ethernet) {
+        ptr = (datap + ETHERNET_ADDR_LEN * 2);
         typeorlength = (ptr[0] << 8) | ptr[1];
-        l3_data_ptr += ETHERTYPE_VLAN_LEN;
-    }
+        l3_data_ptr = datap + sizeof(struct ethernet_hdr_t);//ETHERNET_HDR_LEN;
 
-    if (!IS_ETHERTYPE(typeorlength)) { // 802.3 header
-        struct llc_snap_hdr_t *llc_hdr = (struct llc_snap_hdr_t *) l3_data_ptr;
-        typeorlength = (llc_hdr->ethertype[0] << 8) | llc_hdr->ethertype[1];
-        l3_data_ptr += sizeof(struct llc_snap_hdr_t);
+        if (typeorlength == ETHERTYPE_VLAN) {
+            ptr = (datap + ETHERNET_ADDR_LEN * 2 + ETHERTYPE_VLAN_LEN);
+            typeorlength = (ptr[0] << 8) | ptr[1];
+            l3_data_ptr += ETHERTYPE_VLAN_LEN;
+        }
+
+        if (!IS_ETHERTYPE(typeorlength)) { // 802.3 header
+            struct llc_snap_hdr_t *llc_hdr = (struct llc_snap_hdr_t *) l3_data_ptr;
+            typeorlength = (llc_hdr->ethertype[0] << 8) | llc_hdr->ethertype[1];
+            l3_data_ptr += sizeof(struct llc_snap_hdr_t);
+        }
+
+        tx_msdu_info->htt.info.l3_hdr_offset = (A_UINT8)(l3_data_ptr - datap);
+        tx_msdu_info->htt.info.ethertype = typeorlength;
     }
-    tx_msdu_info->htt.info.l3_hdr_offset = (A_UINT8)(l3_data_ptr - datap);
-    tx_msdu_info->htt.info.ethertype = typeorlength;
+}
+
+static inline A_UINT8
+ol_tx_tid_by_ether_type(
+    A_UINT8 *datap,
+    struct ol_txrx_msdu_info_t *tx_msdu_info)
+{
+    A_UINT8 tid;
+    A_UINT8 *l3_data_ptr;
+    A_UINT16 typeorlength;
+
+    l3_data_ptr = datap + tx_msdu_info->htt.info.l3_hdr_offset;
+    typeorlength = tx_msdu_info->htt.info.ethertype;
 
     /* IP packet, do packet inspection for TID */
     if (typeorlength == ETHERTYPE_IPV4) {
@@ -229,28 +276,13 @@ ol_tx_tid_by_raw_type(
      * is not at usual location.
      */
     if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_DATA) {
-        struct llc_snap_hdr_t *llc;
         /* dot11 encapsulated frame */
         struct ieee80211_qosframe *whqos = (struct ieee80211_qosframe *)datap;
         if (whqos->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
             tid = whqos->i_qos[0] & IEEE80211_QOS_TID;
-            tx_msdu_info->htt.info.l3_hdr_offset =
-                sizeof(struct ieee80211_qosframe);
         } else {
             tid = HTT_NON_QOS_TID;
-            tx_msdu_info->htt.info.l3_hdr_offset =
-                sizeof(struct ieee80211_frame);
         }
-        llc = (struct llc_snap_hdr_t *)
-            (datap + tx_msdu_info->htt.info.l3_hdr_offset);
-        tx_msdu_info->htt.info.ethertype =
-            (llc->ethertype[0] << 8) | llc->ethertype[1];
-        /*
-         * l3_hdr_offset refers to the end of the 802.3 or 802.11 header,
-         * which may be a LLC/SNAP header rather than the IP header.
-         * Thus, don't increment l3_hdr_offset += sizeof(*llc); rather,
-         * leave it as is.
-         */
     } else {
         /*
          * This function should only be applied to data frames.
@@ -272,10 +304,18 @@ ol_tx_tid(
 
     if (pdev->frame_format == wlan_frm_fmt_raw) {
         tx_msdu_info->htt.info.l2_hdr_type = htt_pkt_type_raw;
-	tid = ol_tx_tid_by_raw_type(datap, tx_msdu_info);
+
+        ol_tx_set_ether_type(datap, tx_msdu_info);
+        tid = tx_msdu_info->htt.info.ext_tid == ADF_NBUF_TX_EXT_TID_INVALID ?
+            ol_tx_tid_by_raw_type(datap, tx_msdu_info) :
+            tx_msdu_info->htt.info.ext_tid;
     } else if (pdev->frame_format == wlan_frm_fmt_802_3) {
         tx_msdu_info->htt.info.l2_hdr_type = htt_pkt_type_ethernet;
-	tid = ol_tx_tid_by_ether_type(datap, tx_msdu_info);
+
+        ol_tx_set_ether_type(datap, tx_msdu_info);
+        tid = tx_msdu_info->htt.info.ext_tid == ADF_NBUF_TX_EXT_TID_INVALID ?
+            ol_tx_tid_by_ether_type(datap, tx_msdu_info) :
+            tx_msdu_info->htt.info.ext_tid;
     } else if (pdev->frame_format == wlan_frm_fmt_native_wifi) {
         struct llc_snap_hdr_t *llc;
 
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 9a4fa0671534..7153195931a6 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -6054,6 +6054,7 @@ static void hdd_update_tgt_ht_cap(hdd_context_t *hdd_ctx,
     else
     {
         pconfig->enable2x2 = 0;
+        pconfig->enableTxSTBC = 0;
     }
     val32 = val16;
     status = ccmCfgSetInt(hdd_ctx->hHal, WNI_CFG_HT_CAP_INFO,
diff --git a/CORE/MAC/inc/qwlan_version.h b/CORE/MAC/inc/qwlan_version.h
index 3ae792a3c5bb..a1a5c8860991 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            132
+#define QWLAN_VERSION_BUILD            133
 
-#define QWLAN_VERSIONSTR               "1.0.0.132"
+#define QWLAN_VERSIONSTR               "1.0.0.133"
 
 #ifdef QCA_WIFI_2_0
 
diff --git a/CORE/SAP/src/sapChSelect.c b/CORE/SAP/src/sapChSelect.c
index 33afbd993fcd..4b66717c8c2c 100644
--- a/CORE/SAP/src/sapChSelect.c
+++ b/CORE/SAP/src/sapChSelect.c
@@ -300,8 +300,16 @@ void sapCleanupChannelList
     }
 
     pSapCtx->SapChnlList.numChannel = 0;
-    vos_mem_free(pSapCtx->SapChnlList.channelList);
-    pSapCtx->SapChnlList.channelList = NULL;
+    if (pSapCtx->SapChnlList.channelList) {
+        vos_mem_free(pSapCtx->SapChnlList.channelList);
+        pSapCtx->SapChnlList.channelList = NULL;
+    }
+
+    pSapCtx->SapAllChnlList.numChannel = 0;
+    if (pSapCtx->SapAllChnlList.channelList) {
+        vos_mem_free(pSapCtx->SapAllChnlList.channelList);
+        pSapCtx->SapAllChnlList.channelList = NULL;
+    }
 }
 
 /*==========================================================================
diff --git a/CORE/SAP/src/sapFsm.c b/CORE/SAP/src/sapFsm.c
index 96cfeb636f6c..172c438d78bc 100644
--- a/CORE/SAP/src/sapFsm.c
+++ b/CORE/SAP/src/sapFsm.c
@@ -2485,6 +2485,11 @@ static VOS_STATUS sapGet5GHzChannelList(ptSapContext sapContext)
         return VOS_STATUS_E_FAULT;
     }
 
+    if (sapContext->SapAllChnlList.channelList) {
+        vos_mem_free(sapContext->SapAllChnlList.channelList);
+        sapContext->SapAllChnlList.channelList = NULL;
+    }
+
     sapContext->SapAllChnlList.channelList =
                 (v_U8_t *)vos_mem_malloc(WNI_CFG_VALID_CHANNEL_LIST_LEN);
     if (NULL == sapContext->SapAllChnlList.channelList)
diff --git a/CORE/SERVICES/BMI/ol_fw.c b/CORE/SERVICES/BMI/ol_fw.c
index 512551fef1ab..0b70e68f1ff6 100644
--- a/CORE/SERVICES/BMI/ol_fw.c
+++ b/CORE/SERVICES/BMI/ol_fw.c
@@ -1928,6 +1928,7 @@ u_int8_t ol_get_number_of_peers_supported(struct ol_softc *scn)
 
 	switch (scn->target_version) {
 		case AR6320_REV1_1_VERSION:
+		case AR6320_REV2_1_VERSION:
 			if(scn->max_no_of_peers > MAX_SUPPORTED_PEERS_REV1_1)
 				max_no_of_peers = MAX_SUPPORTED_PEERS_REV1_1;
 			else
diff --git a/CORE/SERVICES/COMMON/wlan_module_ids.h b/CORE/SERVICES/COMMON/wlan_module_ids.h
index 7d8ca1d8914e..abec4d27978c 100644
--- a/CORE/SERVICES/COMMON/wlan_module_ids.h
+++ b/CORE/SERVICES/COMMON/wlan_module_ids.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011, 2014 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -82,6 +82,7 @@ typedef enum {
   WLAN_MODULE_IBSS_PWRSAVE,
   WLAN_MODULE_HIF_UART,
   WLAN_MODULE_LPI,
+  WLAN_MODULE_EXTSCAN,
   WLAN_MODULE_ID_MAX,
   WLAN_MODULE_ID_INVALID = WLAN_MODULE_ID_MAX,
 } WLAN_MODULE_ID;
diff --git a/CORE/SERVICES/COMMON/wmi_services.h b/CORE/SERVICES/COMMON/wmi_services.h
index fd6e9b274eac..4f4ee13ef275 100644
--- a/CORE/SERVICES/COMMON/wmi_services.h
+++ b/CORE/SERVICES/COMMON/wmi_services.h
@@ -106,6 +106,7 @@ typedef  enum  {
     WMI_SERVICE_TDLS_UAPSD_SLEEP_STA,  /* TDLS UAPSD Sleep STA support */
     WMI_SERVICE_IBSS_PWRSAVE,         /* IBSS power save support */
     WMI_SERVICE_LPASS,                /*Service to support LPASS*/
+    WMI_SERVICE_EXTSCAN,              /* Extended Scans */
     WMI_MAX_SERVICE=128               /* max service */
 } WMI_SERVICE;
 
diff --git a/CORE/SERVICES/COMMON/wmi_tlv_defs.h b/CORE/SERVICES/COMMON/wmi_tlv_defs.h
index 6f6bef686855..07bad20faa2b 100644
--- a/CORE/SERVICES/COMMON/wmi_tlv_defs.h
+++ b/CORE/SERVICES/COMMON/wmi_tlv_defs.h
@@ -462,6 +462,30 @@ typedef enum {
     WMITLV_TAG_STRUC_wmi_lpi_stop_scan_cmd_fixed_param,
     WMITLV_TAG_STRUC_wmi_lpi_result_event_fixed_param,
     WMITLV_TAG_STRUC_wmi_peer_state_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_bucket_channel_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_start_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_stop_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_wlan_change_bssid_param_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_get_cached_results_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_get_wlan_change_results_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_set_capabilities_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_get_capabilities_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_operation_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_start_stop_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_table_usage_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_wlan_descriptor_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_rssi_info_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_cached_results_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_wlan_change_results_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_wlan_change_result_bssid_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_hotlist_match_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_capabilities_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_cache_capabilities_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_wlan_change_monitor_capabilities_event_fixed_param,
+    WMITLV_TAG_STRUC_wmi_extscan_hotlist_monitor_capabilities_event_fixed_param,
 } WMITLV_TAG_ID;
 
 /*
@@ -631,7 +655,16 @@ typedef enum {
     OP(WMI_CLEAR_LINK_STATS_CMDID) \
     OP(WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID) \
     OP(WMI_LPI_START_SCAN_CMDID) \
-    OP(WMI_LPI_STOP_SCAN_CMDID)
+    OP(WMI_LPI_STOP_SCAN_CMDID) \
+    OP(WMI_EXTSCAN_START_CMDID) \
+    OP(WMI_EXTSCAN_STOP_CMDID) \
+    OP(WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID) \
+    OP(WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID) \
+    OP(WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID) \
+    OP(WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID) \
+    OP(WMI_EXTSCAN_SET_CAPABILITIES_CMDID) \
+    OP(WMI_EXTSCAN_GET_CAPABILITIES_CMDID)
+
 
 /*
  * IMPORTANT: Please add _ALL_ WMI Events Here.
@@ -706,7 +739,14 @@ typedef enum {
     OP(WMI_PEER_LINK_STATS_EVENTID) \
     OP(WMI_RADIO_LINK_STATS_EVENTID) \
     OP(WMI_LPI_RESULT_EVENTID) \
-    OP(WMI_PEER_STATE_EVENTID)
+    OP(WMI_PEER_STATE_EVENTID) \
+    OP(WMI_EXTSCAN_START_STOP_EVENTID) \
+    OP(WMI_EXTSCAN_OPERATION_EVENTID) \
+    OP(WMI_EXTSCAN_TABLE_USAGE_EVENTID) \
+    OP(WMI_EXTSCAN_CACHED_RESULTS_EVENTID) \
+    OP(WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID) \
+    OP(WMI_EXTSCAN_HOTLIST_MATCH_EVENTID) \
+    OP(WMI_EXTSCAN_CAPABILITIES_EVENTID)
 
 /* TLV definitions of WMI commands */
 
@@ -870,6 +910,64 @@ WMITLV_CREATE_PARAM_STRUC(WMI_VDEV_PLMREQ_STOP_CMDID);
 
 WMITLV_CREATE_PARAM_STRUC(WMI_START_SCAN_CMDID);
 
+/* Start ExtScan Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_START_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_start_cmd_fixed_param, wmi_extscan_start_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_FIXED_STRUC, wmi_ssid, ssid_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_FIXED_STRUC, wmi_mac_addr, bssid_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, ie_data, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_bucket, bucket_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_bucket_channel, channel_list, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_START_CMDID);
+
+/* Stop ExtScan Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_STOP_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_stop_cmd_fixed_param, wmi_extscan_stop_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_STOP_CMDID);
+
+/* Start ExtScan BSSID Monitoring Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param, wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_change_bssid_param, wlan_change_descriptor_list, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID);
+
+/* Start Hot List Monitoring Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param, wmi_extscan_configure_hotlist_monitor_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_hotlist_entry, hotlist, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID);
+
+/* Get ExtScan BSSID/RSSI list Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_get_cached_results_cmd_fixed_param, wmi_extscan_get_cached_results_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID);
+
+/* Get ExtScan BSSID monitor results Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_get_wlan_change_results_cmd_fixed_param, wmi_extscan_get_wlan_change_results_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID);
+
+/* Set ExtScan Capabilities Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_SET_CAPABILITIES_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_set_capabilities_cmd_fixed_param, wmi_extscan_set_capabilities_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_cache_capabilities, extscan_cache_capabilities, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_change_monitor_capabilities, wlan_change_capabilities, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_hotlist_monitor_capabilities, hotlist_capabilities, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_SET_CAPABILITIES_CMDID);
+
+/* Get ExtScan Capabilities Cmd */
+#define WMITLV_TABLE_WMI_EXTSCAN_GET_CAPABILITIES_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_get_capabilities_cmd_fixed_param, wmi_extscan_get_capabilities_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_GET_CAPABILITIES_CMDID);
+
 /* P2P set vendor ID data Cmd */
 #define WMITLV_TABLE_WMI_P2P_SET_VENDOR_IE_DATA_CMDID(id,op,buf,len) \
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_p2p_set_vendor_ie_data_cmd_fixed_param, wmi_p2p_set_vendor_ie_data_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
@@ -1736,6 +1834,58 @@ WMITLV_CREATE_PARAM_STRUC(WMI_READY_EVENTID);
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_scan_event_fixed_param, wmi_scan_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
 WMITLV_CREATE_PARAM_STRUC(WMI_SCAN_EVENTID);
 
+/* ExtScan Start/Stop Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_START_STOP_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_start_stop_event_fixed_param, wmi_extscan_start_stop_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_START_STOP_EVENTID);
+
+/* ExtScan Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_OPERATION_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_operation_event_fixed_param, wmi_extscan_operation_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_UINT32, A_UINT32, bucket_id, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_OPERATION_EVENTID);
+
+/* ExtScan Table Usage Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_TABLE_USAGE_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_table_usage_event_fixed_param, wmi_extscan_table_usage_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_TABLE_USAGE_EVENTID);
+
+/* ExtScan Result Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_CACHED_RESULTS_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_cached_results_event_fixed_param, wmi_extscan_cached_results_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_descriptor, bssid_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_rssi_info, rssi_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, ie_list, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_CACHED_RESULTS_EVENTID);
+
+/* ExtScan Monitor RSSI List Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_wlan_change_results_event_fixed_param, wmi_extscan_wlan_change_results_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_change_result_bssid, bssid_signal_descriptor_list, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, rssi_list, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID);
+
+/* ExtScan Hot List Match Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_HOTLIST_MATCH_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_hotlist_match_event_fixed_param, wmi_extscan_hotlist_match_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_descriptor, hotlist_match, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_HOTLIST_MATCH_EVENTID);
+
+/* ExtScan Hot List Match Event */
+#define WMITLV_TABLE_WMI_EXTSCAN_CAPABILITIES_EVENTID(id,op,buf,len)                                                                                                 \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_extscan_capabilities_event_fixed_param, wmi_extscan_capabilities_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_cache_capabilities, extscan_cache_capabilities, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_wlan_change_monitor_capabilities, wlan_change_capabilities, WMITLV_SIZE_VAR) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_STRUC, wmi_extscan_hotlist_monitor_capabilities, hotlist_capabilities, WMITLV_SIZE_VAR)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_EXTSCAN_CAPABILITIES_EVENTID);
+
 /* Update_whal_mib_stats Event */
 #define WMITLV_TABLE_WMI_UPDATE_WHAL_MIB_STATS_EVENTID(id,op,buf,len)                                                                                                 \
     WMITLV_ELEM(id, op, buf, len, WMITLV_TAG_STRUC_wmi_update_whal_mib_stats_event_fixed_param, wmi_update_whal_mib_stats_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
diff --git a/CORE/SERVICES/COMMON/wmi_unified.h b/CORE/SERVICES/COMMON/wmi_unified.h
index 6ae00301d51d..72de951bb729 100644
--- a/CORE/SERVICES/COMMON/wmi_unified.h
+++ b/CORE/SERVICES/COMMON/wmi_unified.h
@@ -174,6 +174,7 @@ typedef enum {
     WMI_GRP_COEX,
     WMI_GRP_OBSS_OFL,
     WMI_GRP_LPI,
+    WMI_GRP_EXTSCAN,
 } WMI_GRP_ID;
 
 #define WMI_CMD_GRP_START_ID(grp_id) (((grp_id) << 12) | 0x1)
@@ -646,6 +647,15 @@ typedef enum {
     /**LPI scan stop command*/
     WMI_LPI_STOP_SCAN_CMDID,
 
+     /** ExtScan commands */
+    WMI_EXTSCAN_START_CMDID = WMI_CMD_GRP_START_ID(WMI_GRP_EXTSCAN),
+    WMI_EXTSCAN_STOP_CMDID,
+    WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID,
+    WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID,
+    WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID,
+    WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID,
+    WMI_EXTSCAN_SET_CAPABILITIES_CMDID,
+    WMI_EXTSCAN_GET_CAPABILITIES_CMDID,
 } WMI_CMD_ID;
 
 typedef enum {
@@ -873,6 +883,14 @@ typedef enum {
     /* LPI Event */
     WMI_LPI_RESULT_EVENTID = WMI_EVT_GRP_START_ID(WMI_GRP_LPI),
 
+     /* ExtScan events */
+    WMI_EXTSCAN_START_STOP_EVENTID = WMI_EVT_GRP_START_ID(WMI_GRP_EXTSCAN),
+    WMI_EXTSCAN_OPERATION_EVENTID,
+    WMI_EXTSCAN_TABLE_USAGE_EVENTID,
+    WMI_EXTSCAN_CACHED_RESULTS_EVENTID,
+    WMI_EXTSCAN_WLAN_CHANGE_RESULTS_EVENTID,
+    WMI_EXTSCAN_HOTLIST_MATCH_EVENTID,
+    WMI_EXTSCAN_CAPABILITIES_EVENTID,
 } WMI_EVT_ID;
 
 /* defines for OEM message sub-types */
@@ -7471,6 +7489,638 @@ typedef struct {
     A_UINT32 tlv_header;
 } wmi_chan_avoid_update_cmd_param;
 
+/* ExtScan operation mode */
+typedef enum {
+   WMI_EXTSCAN_MODE_NONE          = 0x0000,
+   WMI_EXTSCAN_MODE_START         = 0x0001,    // ExtScan/TableMonitoring operation started
+   WMI_EXTSCAN_MODE_STOP          = 0x0002,    // ExtScan/TableMonitoring operation stopped
+   WMI_EXTSCAN_MODE_IGNORED       = 0x0003,    // ExtScan command ignored due to error
+} wmi_extscan_operation_mode;
+
+/* Channel Mask */
+typedef enum {
+   WMI_CHANNEL_BAND_UNSPECIFIED = 0x0000,
+   WMI_CHANNEL_BAND_24          = 0x0001,    // 2.4 channel
+   WMI_CHANNEL_BAND_5_NON_DFS   = 0x0002,    // 5G Channels (No DFS channels)
+   WMI_CHANNEL_BAND_DFS         = 0x0004,    // DFS channels
+} wmi_channel_band_mask;
+
+typedef enum {
+    WMI_EXTSCAN_CYCLE_STARTED_EVENT     = 0x0001,
+    WMI_EXTSCAN_CYCLE_COMPLETED_EVENT   = 0x0002,
+    WMI_EXTSCAN_BUCKET_STARTED_EVENT    = 0x0004,
+    WMI_EXTSCAN_BUCKET_COMPLETED_EVENT  = 0x0008,
+    WMI_EXTSCAN_BUCKET_FAILED_EVENT     = 0x0010,
+    WMI_EXTSCAN_BUCKET_OVERRUN_EVENT    = 0x0020,
+
+    WMI_EXTSCAN_EVENT_MAX               = 0x8000
+} wmi_extscan_event_type;
+
+#define WMI_EXTSCAN_CYCLE_EVENTS_MASK    (WMI_EXTSCAN_CYCLE_STARTED_EVENT   | \
+                                          WMI_EXTSCAN_CYCLE_COMPLETED_EVENT)
+
+#define WMI_EXTSCAN_BUCKET_EVENTS_MASK   (WMI_EXTSCAN_BUCKET_STARTED_EVENT   | \
+                                          WMI_EXTSCAN_BUCKET_COMPLETED_EVENT | \
+                                          WMI_EXTSCAN_BUCKET_FAILED_EVENT    | \
+                                          WMI_EXTSCAN_BUCKET_OVERRUN_EVENT)
+
+typedef enum {
+    WMI_EXTSCAN_NO_FORWARDING         = 0x0000,
+    WMI_EXTSCAN_FORWARD_FRAME_TO_HOST = 0x0001
+} wmi_extscan_forwarding_flags;
+
+typedef enum {
+    WMI_EXTSCAN_USE_MSD = 0x0001,    // Use Motion Sensor Detection */
+} wmi_extscan_configuration_flags;
+
+typedef enum {
+    WMI_EXTSCAN_STATUS_OK    = 0,
+    WMI_EXTSCAN_STATUS_ERROR = 0x80000000,
+    WMI_EXTSCAN_STATUS_INVALID_PARAMETERS,
+    WMI_EXTSCAN_STATUS_INTERNAL_ERROR
+} wmi_extscan_start_stop_status;
+
+typedef struct {
+    /** Request ID - to identify command. Cannot be 0 */
+    A_UINT32     request_id;
+    /** Requestor ID - client requesting ExtScan */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32     vdev_id;
+} wmi_extscan_command_id;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /** channel number */
+    A_UINT32    channel;
+
+    /** dwell time in msec - use defaults if 0 */
+    A_UINT32    min_dwell_time;
+    A_UINT32    max_dwell_time;
+    /** passive/active channel and other flags */
+    A_UINT32    control_flags;                        // 0 => active, 1 => passive scan; ignored for DFS
+} wmi_extscan_bucket_channel;
+
+/* Scan Bucket specification */
+typedef struct {
+    A_UINT32        tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /** Bucket ID  - 0-based */
+    A_UINT32        bucket_id;
+    /** ExtScan events subscription - events to be reported to client (see wmi_extscan_event_type) */
+    A_UINT32        notify_extscan_events;
+    /** Options to forward scan results - see wmi_extscan_forwarding_flags */
+    A_UINT32        forwarding_flags;
+    /** ExtScan configuration flags - wmi_extscan_configuration_flags */
+    A_UINT32        configuration_flags;
+    /** multiplier to be applied to the periodic scan's base period */
+    A_UINT32        base_period_multiplier;
+    /** dwell time in msec on active channels - use defaults if 0 */
+    A_UINT32        min_dwell_time_active;
+    A_UINT32        max_dwell_time_active;
+    /** dwell time in msec on passive channels - use defaults if 0 */
+    A_UINT32        min_dwell_time_passive;
+    A_UINT32        max_dwell_time_passive;
+    /** see wmi_channel_band_mask; when equal to WMI_CHANNEL_UNSPECIFIED, use channel list */
+    A_UINT32        channel_band;
+    /** number of channels (if channel_band is WMI_CHANNEL_UNSPECIFIED) */
+    A_UINT32        num_channels;
+/** Followed by the variable length TLV chan_list:
+ *  wmi_extscan_bucket_channel chan_list[] */
+} wmi_extscan_bucket;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_start_cmd_fixed_param */
+    /** Request ID - to identify command. Cannot be 0 */
+    A_UINT32     request_id;
+    /** Requestor ID - client requesting ExtScan */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32     vdev_id;
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32     table_id;
+    /** Base period (milliseconds) used by scan buckets to define periodicity of the scans */
+    A_UINT32     base_period;
+    /** Maximum number of iterations to run - one iteration is the scanning of the least frequent bucket */
+    A_UINT32     max_iterations;
+    /** Options to forward scan results - see wmi_extscan_forwarding_flags */
+    A_UINT32     forwarding_flags;
+    /** ExtScan configuration flags - wmi_extscan_configuration_flags */
+    A_UINT32     configuration_flags;
+    /** ExtScan events subscription - bitmask indicating which events should be send to client (see wmi_extscan_event_type) */
+    A_UINT32     notify_extscan_events;
+    /** Scan Priority, input to scan scheduler */
+    A_UINT32     scan_priority;
+    /** Maximum number of BSSIDs to cache on each scan cycle */
+    A_UINT32     max_bssids_per_scan_cycle;
+    /** Minimum RSSI value to report */
+    A_UINT32     min_rssi;
+    /** Maximum table usage in percentage */
+    A_UINT32     max_table_usage;
+    /** default dwell time in msec on active channels */
+    A_UINT32     min_dwell_time_active;
+    A_UINT32     max_dwell_time_active;
+    /** default dwell time in msec on passive channels */
+    A_UINT32     min_dwell_time_passive;
+    A_UINT32     max_dwell_time_passive;
+    /** min time in msec on the BSS channel,only valid if atleast one VDEV is active*/
+    A_UINT32     min_rest_time;
+    /** max rest time in msec on the BSS channel,only valid if at least one VDEV is active*/
+    /** the scanner will rest on the bss channel at least min_rest_time. after min_rest_time the scanner
+     *  will start checking for tx/rx activity on all VDEVs. if there is no activity the scanner will
+     *  switch to off channel. if there is activity the scanner will let the radio on the bss channel
+     *  until max_rest_time expires.at max_rest_time scanner will switch to off channel
+     *  irrespective of activity. activity is determined by the idle_time parameter.
+     */
+    A_UINT32     max_rest_time;
+    /** time before sending next set of probe requests.
+     *   The scanner keeps repeating probe requests transmission with period specified by repeat_probe_time.
+     *   The number of probe requests specified depends on the ssid_list and bssid_list
+     */
+    /** Max number of probes to be sent */
+    A_UINT32     n_probes;
+    /** time in msec between 2 sets of probe requests. */
+    A_UINT32     repeat_probe_time;
+    /** time in msec between 2 consequetive probe requests with in a set. */
+    A_UINT32     probe_spacing_time;
+    /** data inactivity time in msec on bss channel that will be used by scanner for measuring the inactivity  */
+    A_UINT32     idle_time;
+    /** maximum time in msec allowed for scan  */
+    A_UINT32     max_scan_time;
+    /** delay in msec before sending first probe request after switching to a channel */
+    A_UINT32     probe_delay;
+    /** Scan control flags */
+    A_UINT32     scan_ctrl_flags;
+    /** Burst duration time in msec*/
+    A_UINT32     burst_duration;
+
+    /** number of bssids in the TLV bssid_list[] */
+    A_UINT32     num_bssid;
+    /** number of ssid in the TLV ssid_list[] */
+    A_UINT32     num_ssids;
+    /** number of bytes in TLV ie_data[] */
+    A_UINT32     ie_len;
+    /** number of buckets in the TLV bucket_list[] */
+    A_UINT32     num_buckets;
+    /** number of channels in channel_list[] determined by the
+        sum of wmi_extscan_bucket.num_channels in array  */
+
+/**
+ * TLV (tag length value ) parameters follow the extscan_cmd
+ * structure. The TLV's are:
+ *     wmi_ssid                   ssid_list[];
+ *     wmi_mac_addr               bssid_list[];
+ *     A_UINT8                    ie_data[];
+ *     wmi_extscan_bucket         bucket_list[];
+ *     wmi_extscan_bucket_channel channel_list[];
+ */
+} wmi_extscan_start_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_stop_cmd_fixed_param */
+    /** Request ID - to match running command. 0 matches any request */
+    A_UINT32     request_id;
+    /** Requestor ID - client requesting stop */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32     vdev_id;
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32     table_id;
+} wmi_extscan_stop_cmd_fixed_param;
+
+enum wmi_extscan_get_cached_results_flags {
+    WMI_EXTSCAN_GET_CACHED_RESULTS_FLAG_NONE        = 0x0000,
+    WMI_EXTSCAN_GET_CACHED_RESULTS_FLAG_FLUSH_TABLE = 0x0001
+};
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_get_cached_results_cmd_fixed_param */
+    /** request ID - used to correlate command with events */
+    A_UINT32    request_id;
+    /** Requestor ID - client that requested results */
+    A_UINT32    requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32    vdev_id;
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32    table_id;
+    /** maximum number of results to be returned  */
+    A_UINT32    max_results;
+    /** flush BSSID list - wmi_extscan_get_cached_results_flags */
+    A_UINT32    control_flags;    // enum wmi_extscan_get_cached_results_flags
+} wmi_extscan_get_cached_results_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_get_wlan_change_results_cmd_fixed_param */
+    /** request ID - used to correlate command with events */
+    A_UINT32    request_id;
+    /** Requestor ID - client that requested results */
+    A_UINT32    requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32    vdev_id;
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32    table_id;
+} wmi_extscan_get_wlan_change_results_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32        tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /**bssid */
+    wmi_mac_addr    bssid;
+    /**channel number */
+    A_UINT32        channel;
+    /**upper RSSI limit */
+    A_UINT32        upper_rssi_limit;
+    /**lower RSSI limit */
+    A_UINT32        lower_rssi_limit;
+} wmi_extscan_wlan_change_bssid_param;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param */
+    /** Request ID - to identify command. Cannot be 0 */
+    A_UINT32    request_id;
+    /** Requestor ID - client requesting wlan change monitoring */
+    A_UINT32    requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32    vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32    table_id;
+    /** operation mode: start/stop */
+    A_UINT32    mode;    // wmi_extscan_operation_mode
+    /** number of rssi samples to store */
+    A_UINT32    max_rssi_samples;
+    /** number of samples to use to calculate RSSI average */
+    A_UINT32    rssi_averaging_samples;
+    /** number of scans to confirm loss of contact with RSSI */
+    A_UINT32    lost_ap_scan_count;
+    /** number of out-of-range BSSIDs necessary to send event */
+    A_UINT32    max_out_of_range_count;
+    /** total number of bssid signal descriptors (in all pages) */
+    A_UINT32    total_entries;
+    /** index of the first bssid entry found in the TLV wlan_change_descriptor_list*/
+    A_UINT32    first_entry_index;
+    /** number of bssid signal descriptors in this page */
+    A_UINT32    num_entries_in_page;
+    /* Following this structure is the TLV:
+     *     wmi_extscan_wlan_change_bssid_param wlan_change_descriptor_list[];    // number of elements given by field num_page_entries.
+     */
+} wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32        tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /**bssid */
+    wmi_mac_addr    bssid;
+    /**RSSI threshold for reporting */
+    A_UINT32        min_rssi;
+    /**channel number */
+    A_UINT32        channel;
+} wmi_extscan_hotlist_entry;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param */
+    /** Request ID - to identify command. Cannot be 0 */
+    A_UINT32    request_id;
+    /** Requestor ID - client requesting hotlist monitoring */
+    A_UINT32    requestor_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32    vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32    table_id;
+    /** operation mode: start/stop */
+    A_UINT32    mode;    // wmi_extscan_operation_mode
+    /**total number of bssids (in all pages) */
+    A_UINT32    total_entries;
+    /**index of the first bssid entry found in the TLV wmi_extscan_hotlist_entry*/
+    A_UINT32    first_entry_index;
+    /**number of bssids in this page */
+    A_UINT32    num_entries_in_page;
+    /* Following this structure is the TLV:
+     *     wmi_extscan_hotlist_entry hotlist[];    // number of elements given by field num_page_entries.
+     */
+} wmi_extscan_configure_hotlist_monitor_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32    table_id;
+    /** size in bytes of scan cache entry */
+    A_UINT32    scan_cache_entry_size;
+    /** maximum number of scan cache entries */
+    A_UINT32    max_scan_cache_entries;
+    /** maximum number of buckets per extscan request */
+    A_UINT32    max_buckets;
+    /** maximum number of BSSIDs that will be stored in each scan (best n/w as per RSSI) */
+    A_UINT32    max_bssid_per_scan;
+    /** table usage level at which indication must be sent to host */
+    A_UINT32    max_table_usage_threshold;
+} wmi_extscan_cache_capabilities;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32    table_id;
+    /** size in bytes of wlan change entry */
+    A_UINT32    wlan_change_entry_size;
+    /** maximum number of entries in wlan change table */
+    A_UINT32    max_wlan_change_entries;
+    /** number of RSSI samples used for averaging RSSI */
+    A_UINT32    max_rssi_averaging_samples;
+    /** number of BSSID/RSSI entries (BSSID pointer, RSSI, timestamp) that device can hold */
+    A_UINT32    max_rssi_history_entries;
+} wmi_extscan_wlan_change_monitor_capabilities;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32    table_id;
+    /** size in bytes of hotlist entry */
+    A_UINT32    wlan_hotlist_entry_size;
+    /** maximum number of entries in wlan change table */
+    A_UINT32    max_hotlist_entries;
+} wmi_extscan_hotlist_monitor_capabilities;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_set_capabilities_cmd_fixed_param */
+    /** Request ID - matches request ID used to start hot list monitoring */
+    A_UINT32    request_id;
+    /** Requestor ID - client requesting stop */
+    A_UINT32    requestor_id;
+    /** number of extscan caches */
+    A_UINT32    num_extscan_cache_tables;
+    /** number of wlan change lists */
+    A_UINT32    num_wlan_change_monitor_tables;
+    /** number of hotlists */
+    A_UINT32    num_hotlist_monitor_tables;
+    /** if one sided rtt data collection is supported */
+    A_UINT32    rtt_one_sided_supported;
+    /** if 11v data collection is supported */
+    A_UINT32    rtt_11v_supported;
+    /** if 11mc data collection is supported */
+    A_UINT32    rtt_ftm_supported;
+    /** number of extscan cache capabilities (one per table)  */
+    A_UINT32    num_extscan_cache_capabilities;
+    /** number of wlan change  capabilities (one per table)  */
+    A_UINT32    num_extscan_wlan_change_capabilities;
+    /** number of extscan hotlist capabilities (one per table)  */
+    A_UINT32    num_extscan_hotlist_capabilities;
+    /* Following this structure is the TLV:
+     *     wmi_extscan_cache_capabilities               extscan_cache_capabilities; // number of capabilities given by num_extscan_caches
+     *     wmi_extscan_wlan_change_monitor_capabilities wlan_change_capabilities;   // number of capabilities given by num_wlan_change_monitor_tables
+     *     wmi_extscan_hotlist_monitor_capabilities     hotlist_capabilities;       // number of capabilities given by num_hotlist_monitor_tables
+     */
+} wmi_extscan_set_capabilities_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_get_capabilities_cmd_fixed_param */
+    /** Request ID - matches request ID used to start hot list monitoring */
+    A_UINT32    request_id;
+    /** Requestor ID - client requesting capabilities */
+    A_UINT32    requestor_id;
+} wmi_extscan_get_capabilities_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_start_stop_event_fixed_param */
+    /** Request ID of the operation that was started/stopped */
+    A_UINT32     request_id;
+    /** Requestor ID of the operation that was started/stopped */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the operation that was started/stopped */
+    A_UINT32     vdev_id;
+    /** extscan WMI command */
+    A_UINT32     command;
+    /** operation mode: start/stop */
+    A_UINT32     mode;      // wmi_extscan_operation_mode
+    /**success/failure */
+    A_UINT32     status;    // enum wmi_extscan_start_stop_status
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32     table_id;
+} wmi_extscan_start_stop_event_fixed_param;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_operation_event_fixed_param */
+    /** Request ID of the extscan operation that is currently running */
+    A_UINT32     request_id;
+    /** Requestor ID of the extscan operation that is currently running */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the extscan operation that is currently running */
+    A_UINT32     vdev_id;
+    /** scan event (wmi_scan_event_type) */
+    A_UINT32     event;    // wmi_extscan_event_type
+    /** table ID - to allow support for multiple simultaneous requests */
+    A_UINT32     table_id;
+    /**number of buckets */
+    A_UINT32     num_buckets;
+    /* Following this structure is the TLV:
+     *     A_UINT32    bucket_id[];    // number of elements given by field num_buckets.
+     */
+} wmi_extscan_operation_event_fixed_param;
+
+/* Types of extscan tables */
+typedef enum {
+    EXTSCAN_TABLE_NONE    = 0,
+    EXTSCAN_TABLE_BSSID   = 1,
+    EXTSCAN_TABLE_RSSI    = 2,
+} wmi_extscan_table_type;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_table_usage_event_fixed_param */
+    /** Request ID of the extscan operation that is currently running */
+    A_UINT32     request_id;
+    /** Requestor ID of the extscan operation that is currently running */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the extscan operation that is currently running */
+    A_UINT32     vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32     table_id;
+    /**see wmi_extscan_table_type for table reporting usage */
+    A_UINT32     table_type;
+    /**number of entries in use */
+    A_UINT32     entries_in_use;
+    /**maximum number of entries in table */
+    A_UINT32     maximum_entries;
+} wmi_extscan_table_usage_event_fixed_param;
+
+typedef struct {
+    A_UINT32    tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /**RSSI */
+    A_UINT32    rssi;
+    /**time stamp in seconds */
+    A_UINT32    tstamp;
+} wmi_extscan_rssi_info;
+
+typedef struct {
+    A_UINT32        tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /**bssid */
+    wmi_mac_addr    bssid;
+    /**ssid */
+    wmi_ssid        ssid;
+    /**channel number */
+    A_UINT32        channel;
+    /* capabilities */
+    A_UINT32        capabilities;
+    /* beacon interval in TUs */
+    A_UINT32        beacon_interval;
+    /**time stamp in seconds - time last seen */
+    A_UINT32        tstamp;
+    /**flags - _tExtScanEntryFlags */
+    A_UINT32        flags;
+    /**RTT in ns */
+    A_UINT32        rtt;
+    /**rtt standard deviation */
+    A_UINT32        rtt_sd;
+    /* rssi information */
+    A_UINT32        number_rssi_samples;
+    /** IE length */
+    A_UINT32        ie_length;             // length of IE data
+} wmi_extscan_wlan_descriptor;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_cached_results_event_fixed_param */
+    /** Request ID of the WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID */
+    A_UINT32     request_id;
+    /** Requestor ID of the WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID */
+    A_UINT32     vdev_id;
+    /** Request ID of the extscan operation that is currently running */
+    A_UINT32     extscan_request_id;
+    /** Requestor ID of the extscan operation that is currently running */
+    A_UINT32     extscan_requestor_id;
+    /** VDEV id(interface) of the extscan operation that is currently running */
+    A_UINT32     extscan_vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32     table_id;
+    /**current time stamp in seconds. Used to provide a baseline for the relative timestamps returned for each block and entry */
+    A_UINT32     current_tstamp;
+    /**total number of bssids (in all pages) */
+    A_UINT32     total_entries;
+    /**index of the first bssid entry found in the TLV wmi_extscan_wlan_descriptor*/
+    A_UINT32     first_entry_index;
+    /**number of bssids in this page */
+    A_UINT32     num_entries_in_page;
+    /* Followed by the variable length TLVs
+     *     wmi_extscan_wlan_descriptor    bssid_list[]
+     *     wmi_extscan_rssi_info          rssi_list[]
+     *     A_UINT8                        ie_list[]
+     */
+} wmi_extscan_cached_results_event_fixed_param;
+
+typedef enum {
+    EXTSCAN_WLAN_CHANGE_FLAG_NONE         = 0x00,
+    EXTSCAN_WLAN_CHANGE_FLAG_OUT_OF_RANGE = 0x01,
+    EXTSCAN_WLAN_CHANGE_FLAG_AP_LOST      = 0x02,
+} wmi_extscan_wlan_change_flags;
+
+typedef struct {
+    A_UINT32        tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_ARRAY_STRUC */
+    /**bssid */
+    wmi_mac_addr    bssid;
+    /**time stamp in seconds */
+    A_UINT32        tstamp;
+    /**upper RSSI limit */
+    A_UINT32        upper_rssi_limit;
+    /**lower RSSI limit */
+    A_UINT32        lower_rssi_limit;
+    /** channel */
+    A_UINT32        channel;    /* in MHz */
+    /**current RSSI average */
+    A_UINT32        rssi_average;
+    /**flags - wmi_extscan_wlan_change_flags */
+    A_UINT32        flags;
+    /**legnth of RSSI history to follow (number of values) */
+    A_UINT32        num_rssi_samples;
+} wmi_extscan_wlan_change_result_bssid;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_wlan_change_results_event_fixed_param */
+    /** Request ID of the WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID command that requested the results */
+    A_UINT32     request_id;
+    /** Requestor ID of the WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID command that requested the results */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID command that requested the results */
+    A_UINT32     vdev_id;
+    /** Request ID of the WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID command that configured the table */
+    A_UINT32     config_request_id;
+    /** Requestor ID of the WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID command that configured the table */
+    A_UINT32     config_requestor_id;
+    /** VDEV id(interface) of the WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID command that configured the table */
+    A_UINT32     config_vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32     table_id;
+    /**number of entries with RSSI out of range or BSSID not detected */
+    A_UINT32     change_count;
+    /**total number of bssid signal descriptors (in all pages) */
+    A_UINT32     total_entries;
+    /**index of the first bssid signal descriptor entry found in the TLV wmi_extscan_wlan_descriptor*/
+    A_UINT32     first_entry_index;
+    /**number of bssids signal descriptors in this page */
+    A_UINT32     num_entries_in_page;
+    /* Following this structure is the TLV:
+     *     wmi_extscan_wlan_change_result_bssid bssid_signal_descriptor_list[];    // number of descriptors given by field num_entries_in_page.
+     * Following this structure is the list of RSSI values (each is an A_UINT8):
+     *     A_UINT8 rssi_list[];    // last N RSSI values.
+     */
+} wmi_extscan_wlan_change_results_event_fixed_param;
+
+enum _tExtScanEntryFlags
+{
+    WMI_HOTLIST_FLAG_NONE     = 0x00,
+    WMI_HOTLIST_FLAG_PRESENCE = 0x01
+};
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_hotlist_match_event_fixed_param */
+    /** Request ID of the WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID that configured the table */
+    A_UINT32     config_request_id;
+    /** Requestor ID of the WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID that configured the table */
+    A_UINT32     config_requestor_id;
+    /** VDEV id(interface) of the WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID that configured the table */
+    A_UINT32     config_vdev_id;
+    /** table ID - to allow support for multiple simultaneous tables */
+    A_UINT32     table_id;
+    /**total number of bssids (in all pages) */
+    A_UINT32     total_entries;
+    /**index of the first bssid entry found in the TLV wmi_extscan_wlan_descriptor*/
+    A_UINT32     first_entry_index;
+    /**number of bssids in this page */
+    A_UINT32     num_entries_in_page;
+    /* Following this structure is the TLV:
+     *     wmi_extscan_wlan_descriptor hotlist_match[];    // number of descriptors given by field num_entries_in_page.
+     */
+} wmi_extscan_hotlist_match_event_fixed_param;
+
+typedef struct {
+    A_UINT32     tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_extscan_capabilities_event_fixed_param */
+    /** Request ID of the WMI_EXTSCAN_GET_CAPABILITIES_CMDID */
+    A_UINT32     request_id;
+    /** Requestor ID of the WMI_EXTSCAN_GET_CAPABILITIES_CMDID */
+    A_UINT32     requestor_id;
+    /** VDEV id(interface) of the WMI_EXTSCAN_GET_CAPABILITIES_CMDID */
+    A_UINT32     vdev_id;
+    /** number of extscan caches */
+    A_UINT32     num_extscan_cache_tables;
+    /** number of wlan change lists */
+    A_UINT32     num_wlan_change_monitor_tables;
+    /** number of hotlists */
+    A_UINT32     num_hotlist_monitor_tables;
+    /** if one sided rtt data collection is supported */
+    A_UINT32     rtt_one_sided_supported;
+    /** if 11v data collection is supported */
+    A_UINT32     rtt_11v_supported;
+    /** if 11mc data collection is supported */
+    A_UINT32     rtt_ftm_supported;
+    /** number of extscan cache capabilities (one per table)  */
+    A_UINT32     num_extscan_cache_capabilities;
+    /** number of wlan change  capabilities (one per table)  */
+    A_UINT32     num_extscan_wlan_change_capabilities;
+    /** number of extscan hotlist capabilities (one per table)  */
+    A_UINT32     num_extscan_hotlist_capabilities;
+    /* Following this structure are the TLVs describing the capabilities of of the various types of lists. The FW theoretically
+     * supports multiple lists of each type.
+     *
+     *     wmi_extscan_cache_capabilities               extscan_cache_capabilities[] // capabilities of extscan cache (BSSID/RSSI lists)
+     *     wmi_extscan_wlan_change_monitor_capabilities wlan_change_capabilities[]   // capabilities of wlan_change_monitor_tables
+     *     wmi_extscan_hotlist_monitor_capabilities     hotlist_capabilities[]       // capabilities of hotlist_monitor_tables
+     */
+} wmi_extscan_capabilities_event_fixed_param;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/CORE/SERVICES/COMMON/wmi_version.h b/CORE/SERVICES/COMMON/wmi_version.h
index 3a1d8b0c2b18..2e6ab07e643d 100644
--- a/CORE/SERVICES/COMMON/wmi_version.h
+++ b/CORE/SERVICES/COMMON/wmi_version.h
@@ -36,7 +36,8 @@
 #define __WMI_VER_MINOR_    0
 /** WMI revision number has to be incremented when there is a
  *  change that may or may not break compatibility. */
-#define __WMI_REVISION_ 54
+
+#define __WMI_REVISION_ 55
 
 /** The Version Namespace should not be normally changed. Only
  *  host and firmware of the same WMI namespace will work
diff --git a/CORE/SERVICES/WMA/wma.c b/CORE/SERVICES/WMA/wma.c
index 1d003478c779..416a85d0ddb0 100644
--- a/CORE/SERVICES/WMA/wma.c
+++ b/CORE/SERVICES/WMA/wma.c
@@ -106,6 +106,12 @@
 #include "dfs.h"
 #include "radar_filters.h"
 /* ################### defines ################### */
+/*
+ * TODO: Following constant should be shared by firwmare in
+ * wmi_unified.h. This will be done once wmi_unified.h is updated.
+ */
+#define WMI_PEER_STATE_AUTHORIZED 0x2
+
 #define WMA_2_4_GHZ_MAX_FREQ  3000
 #define WOW_CSA_EVENT_OFFSET 12
 
@@ -2897,6 +2903,42 @@ wma_register_dfs_event_handler(tp_wma_handle wma_handle)
 	return;
 }
 
+static int wma_peer_state_change_event_handler(void *handle,
+					       u_int8_t *event_buff,
+					       u_int32_t len)
+{
+	WMI_PEER_STATE_EVENTID_param_tlvs *param_buf;
+	wmi_peer_state_event_fixed_param *event;
+	ol_txrx_vdev_handle vdev;
+	tp_wma_handle wma_handle = (tp_wma_handle)handle;
+
+	param_buf = (WMI_PEER_STATE_EVENTID_param_tlvs *)event_buff;
+	if (!param_buf) {
+		WMA_LOGE("%s: Received NULL buf ptr from FW", __func__);
+		return -ENOMEM;
+	}
+
+	event = param_buf->fixed_param;
+	vdev = wma_find_vdev_by_id( wma_handle, event->vdev_id);
+	if (NULL == vdev) {
+		WMA_LOGP("%s: Couldn't find vdev for vdev_id: %d",
+		__func__, event->vdev_id);
+		return -EINVAL;
+	}
+
+	if (vdev->opmode == wlan_op_mode_sta
+		&& event->state == WMI_PEER_STATE_AUTHORIZED) {
+		/*
+		 * set event so that WLANTL_ChangeSTAState
+		 * can procced and unpause tx queue
+		 */
+		tl_shim_set_peer_authorized_event(wma_handle->vos_context,
+						  event->vdev_id);
+	}
+
+	return 0;
+}
+
 /*
  * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or
  * WMI_DFS_PHYERR_FILTER_DIS_CMDID command
@@ -3381,6 +3423,12 @@ VOS_STATUS WDA_open(v_VOID_t *vos_context, v_VOID_t *os_ctx,
 	 */
 	wma_register_dfs_event_handler(wma_handle);
 
+	/* Register peer change event handler */
+	wmi_unified_register_event_handler(wma_handle->wmi_handle,
+					   WMI_PEER_STATE_EVENTID,
+					   wma_peer_state_change_event_handler);
+
+
    /* Register beacon tx complete event id. The event is required
     * for sending channel switch announcement frames
     */
@@ -18315,7 +18363,7 @@ skip_pno_cmp_ind:
 
 #endif
 
-#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+#if defined(CONFIG_HL_SUPPORT) || defined(QCA_SUPPORT_TXRX_VDEV_PAUSE_LL)
 /* Handle TX pause event from FW */
 static int wma_mcc_vdev_tx_pause_evt_handler(void *handle, u_int8_t *event,
 					u_int32_t len)
@@ -19015,7 +19063,7 @@ VOS_STATUS wma_start(v_VOID_t *vos_ctx)
 	}
 #endif
 
-#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+#if defined(CONFIG_HL_SUPPORT) || defined(QCA_SUPPORT_TXRX_VDEV_PAUSE_LL)
 	WMA_LOGE("MCC TX Pause Event Handler register");
 	status = wmi_unified_register_event_handler(
 			wma_handle->wmi_handle,
diff --git a/CORE/SERVICES/WMI/wmi_unified.c b/CORE/SERVICES/WMI/wmi_unified.c
index a241117f75fe..11dc1da8876d 100644
--- a/CORE/SERVICES/WMI/wmi_unified.c
+++ b/CORE/SERVICES/WMI/wmi_unified.c
@@ -540,6 +540,14 @@ static u_int8_t* get_wmi_cmd_string(WMI_CMD_ID wmi_command)
 		CASE_RETURN_STRING(WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID);
 		CASE_RETURN_STRING(WMI_LPI_START_SCAN_CMDID);
 		CASE_RETURN_STRING(WMI_LPI_STOP_SCAN_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_START_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_STOP_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_GET_WLAN_CHANGE_RESULTS_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_SET_CAPABILITIES_CMDID);
+		CASE_RETURN_STRING(WMI_EXTSCAN_GET_CAPABILITIES_CMDID);
 	}
 	return "Invalid WMI cmd";
 }
diff --git a/CORE/SME/inc/csrApi.h b/CORE/SME/inc/csrApi.h
index 075feb7699ca..3f75968130d9 100644
--- a/CORE/SME/inc/csrApi.h
+++ b/CORE/SME/inc/csrApi.h
@@ -387,6 +387,12 @@ typedef struct tagCsrScanResultFilter
     tCsrMobilityDomainInfo MDID;
 #endif
     tANI_BOOLEAN p2pResult;
+#ifdef WLAN_FEATURE_11W
+    // Management Frame Protection
+    tANI_BOOLEAN MFPEnabled;
+    tANI_U8 MFPRequired;
+    tANI_U8 MFPCapable;
+#endif
 }tCsrScanResultFilter;
 
 
diff --git a/CORE/SME/inc/csrSupport.h b/CORE/SME/inc/csrSupport.h
index f7d1a6785246..3f69f5bfb4b6 100644
--- a/CORE/SME/inc/csrSupport.h
+++ b/CORE/SME/inc/csrSupport.h
@@ -765,7 +765,12 @@ tANI_BOOLEAN csrRatesIsDot11Rate11bSupportedRate( tANI_U8 dot11Rate );
 tANI_BOOLEAN csrRatesIsDot11Rate11aSupportedRate( tANI_U8 dot11Rate );
 tAniEdType csrTranslateEncryptTypeToEdType( eCsrEncryptionType EncryptType );
 //pIes shall contain IEs from pSirBssDesc. It shall be returned from function csrGetParsedBssDescriptionIEs
-tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEncryptionList *pUCEncryptionType, tCsrEncryptionList *pMCEncryptionType,
+tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType,
+                                 tCsrEncryptionList *pUCEncryptionType,
+                                 tCsrEncryptionList *pMCEncryptionType,
+                                 tANI_BOOLEAN *pMFPEnabled,
+                                 tANI_U8 *pMFPRequired,
+                                 tANI_U8 *pMFPCapable,
                                  tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes,
                                  eCsrAuthType *negotiatedAuthtype, eCsrEncryptionType *negotiatedUCCipher, eCsrEncryptionType *negotiatedMCCipher );
 tANI_BOOLEAN csrIsBSSTypeMatch(eCsrRoamBssType bssType1, eCsrRoamBssType bssType2);
diff --git a/CORE/SME/src/csr/csrApiRoam.c b/CORE/SME/src/csr/csrApiRoam.c
index 12c3cbaa65ec..0a89b08addf7 100644
--- a/CORE/SME/src/csr/csrApiRoam.c
+++ b/CORE/SME/src/csr/csrApiRoam.c
@@ -9169,6 +9169,13 @@ eHalStatus csrRoamPrepareFilterFromProfile(tpAniSirGlobal pMac, tCsrRoamProfile
         }
 #endif
 
+#ifdef WLAN_FEATURE_11W
+        // Management Frame Protection
+        pScanFilter->MFPEnabled = pProfile->MFPEnabled;
+        pScanFilter->MFPRequired = pProfile->MFPRequired;
+        pScanFilter->MFPCapable = pProfile->MFPCapable;
+#endif
+
     }while(0);
 
     if(!HAL_STATUS_SUCCESS(status))
diff --git a/CORE/SME/src/csr/csrApiScan.c b/CORE/SME/src/csr/csrApiScan.c
index b14f8e1be55c..ea5e2ccb7df8 100644
--- a/CORE/SME/src/csr/csrApiScan.c
+++ b/CORE/SME/src/csr/csrApiScan.c
@@ -2183,9 +2183,14 @@ eHalStatus csrScanGetResult(tpAniSirGlobal pMac, tCsrScanResultFilter *pFilter,
                     }
                     else
                     {
-                        fMatch = csrIsSecurityMatch( pMac, &pFilter->authType,
-                       &pFilter->EncryptionType, &pFilter->mcEncryptionType,
-                      &pBssDesc->Result.BssDescriptor, pIes, NULL, NULL, NULL );
+                        fMatch = csrIsSecurityMatch(pMac, &pFilter->authType,
+                                                &pFilter->EncryptionType,
+                                                &pFilter->mcEncryptionType,
+                                                &pFilter->MFPEnabled,
+                                                &pFilter->MFPRequired,
+                                                &pFilter->MFPCapable,
+                                                &pBssDesc->Result.BssDescriptor,
+                                                pIes, NULL, NULL, NULL );
                     }
                     if ((pBssDesc->Result.pvIes == NULL) && pIes)
                          vos_mem_free(pIes);
diff --git a/CORE/SME/src/csr/csrNeighborRoam.c b/CORE/SME/src/csr/csrNeighborRoam.c
index 072b9878f35c..df8067a3c864 100644
--- a/CORE/SME/src/csr/csrNeighborRoam.c
+++ b/CORE/SME/src/csr/csrNeighborRoam.c
@@ -3506,8 +3506,19 @@ tANI_BOOLEAN csrNeighborRoamIsSsidAndSecurityMatch(
                     eANI_BOOLEAN_TRUE );
             if(TRUE == fMatch)
             {
-                fMatch = csrIsSecurityMatch( pMac, &authType, &uCEncryptionType,
-                            &mCEncryptionType, pBssDesc, pIes, NULL, NULL, NULL );
+                /*
+                 * for now we are sending NULL for all PMF related filter
+                 * parameters during roam to the neighbor AP because
+                 * so far 80211W spec doesn't specify anything about
+                 * roaming scenario.
+                 *
+                 * Once roaming scenario is defined, we should re-visit
+                 * this section and remove this comment.
+                 */
+                fMatch = csrIsSecurityMatch(pMac, &authType, &uCEncryptionType,
+                                            &mCEncryptionType,
+                                            NULL, NULL, NULL,
+                                            pBssDesc, pIes, NULL, NULL, NULL);
                 return (fMatch);
             }
             else
diff --git a/CORE/SME/src/csr/csrUtil.c b/CORE/SME/src/csr/csrUtil.c
index cab1849d390c..498494bb2dca 100644
--- a/CORE/SME/src/csr/csrUtil.c
+++ b/CORE/SME/src/csr/csrUtil.c
@@ -3940,16 +3940,116 @@ tANI_BOOLEAN csrGetRSNInformation( tHalHandle hHal, tCsrAuthList *pAuthType, eCs
     return( fAcceptableCyphers );
 }
 
+#ifdef WLAN_FEATURE_11W
+/* ---------------------------------------------------------------------------
+    \fn csrIsPMFCapabilitiesInRSNMatch
+
+    \brief this function is to match our current capabilities with the AP
+           to which we are expecting make the connection.
+
+    \param hHal               - HAL Pointer
+           pFilterMFPEnabled  - given by supplicant to us to specify what kind
+                                of connection supplicant is expecting to make
+                                if it is enabled then make PMF connection.
+                                if it is disabled then make normal connection.
+           pFilterMFPRequired - given by supplicant based on our configuration
+                                if it is 1 then we will require mandatory
+                                PMF connection and if it is 0 then we PMF
+                                connection is optional.
+           pFilterMFPCapable  - given by supplicant based on our configuration
+                                if it 1 then we are PMF capable and if it 0
+                                then we are not PMF capable.
+           pRSNIe             - RSNIe from Beacon/probe response of
+                                neighbor AP against which we will compare
+                                our capabilities.
+
+    \return tANI_BOOLEAN      - if our PMF capabilities matches with AP then we
+                                will return true to indicate that we are good
+                                to make connection with it. Else we will return
+                                false.
+  -------------------------------------------------------------------------------*/
+static tANI_BOOLEAN
+csrIsPMFCapabilitiesInRSNMatch( tHalHandle hHal,
+                                tANI_BOOLEAN *pFilterMFPEnabled,
+                                tANI_U8 *pFilterMFPRequired,
+                                tANI_U8 *pFilterMFPCapable,
+                                tDot11fIERSN *pRSNIe)
+{
+    tANI_U8 apProfileMFPCapable  = 0;
+    tANI_U8 apProfileMFPRequired = 0;
+    if (pRSNIe && pFilterMFPEnabled && pFilterMFPCapable && pFilterMFPRequired)
+    {
+       /* Extracting MFPCapable bit from RSN Ie */
+       apProfileMFPCapable  = (pRSNIe->RSN_Cap[0] >> 7) & 0x1;
+       apProfileMFPRequired = (pRSNIe->RSN_Cap[0] >> 6) & 0x1;
+       if (*pFilterMFPEnabled && *pFilterMFPCapable && *pFilterMFPRequired
+           && (apProfileMFPCapable == 0))
+       {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+                     "AP is not capable to make PMF connection");
+           return VOS_FALSE;
+       }
+       else if (*pFilterMFPEnabled && *pFilterMFPCapable &&
+                !(*pFilterMFPRequired) && (apProfileMFPCapable == 0))
+       {
+           /*
+            * This is tricky, because supplicant asked us to make mandatory
+            * PMF connection eventhough PMF connection is optional here.
+            * so if AP is not capable of PMF then drop it. Don't try to
+            * connect with it.
+            */
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+           "we need PMF connection & AP isn't capable to make PMF connection");
+           return VOS_FALSE;
+       }
+       else if (!(*pFilterMFPCapable) &&
+                apProfileMFPCapable && apProfileMFPRequired)
+       {
 
-tANI_BOOLEAN csrIsRSNMatch( tHalHandle hHal, tCsrAuthList *pAuthType, eCsrEncryptionType enType, tCsrEncryptionList *pEnMcType,
-                            tDot11fBeaconIEs *pIes, eCsrAuthType *pNegotiatedAuthType, eCsrEncryptionType *pNegotiatedMCCipher )
+           /*
+            * In this case, AP with whom we trying to connect requires
+            * mandatory PMF connections and we are not capable so this AP
+            * is not good choice to connect
+            */
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+           "AP needs PMF connection and we are not capable of pmf connection");
+           return VOS_FALSE;
+       }
+       else if (!(*pFilterMFPEnabled) && *pFilterMFPCapable &&
+                (apProfileMFPCapable == 1))
+       {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
+           "we don't need PMF connection eventhough both parties are capable");
+           return VOS_FALSE;
+       }
+    }
+    return VOS_TRUE;
+}
+#endif
+
+tANI_BOOLEAN csrIsRSNMatch( tHalHandle hHal, tCsrAuthList *pAuthType,
+                            eCsrEncryptionType enType,
+                            tCsrEncryptionList *pEnMcType,
+                            tANI_BOOLEAN *pMFPEnabled, tANI_U8 *pMFPRequired,
+                            tANI_U8 *pMFPCapable,
+                            tDot11fBeaconIEs *pIes,
+                            eCsrAuthType *pNegotiatedAuthType,
+                            eCsrEncryptionType *pNegotiatedMCCipher )
 {
     tANI_BOOLEAN fRSNMatch = FALSE;
 
         // See if the cyphers in the Bss description match with the settings in the profile.
     fRSNMatch = csrGetRSNInformation( hHal, pAuthType, enType, pEnMcType, &pIes->RSN, NULL, NULL, NULL, NULL,
                                       pNegotiatedAuthType, pNegotiatedMCCipher );
-
+#ifdef WLAN_FEATURE_11W
+    /* If all the filter matches then finally checks for PMF capabilities */
+    if (fRSNMatch)
+    {
+        fRSNMatch = csrIsPMFCapabilitiesInRSNMatch( hHal, pMFPEnabled,
+                                                    pMFPRequired, pMFPCapable,
+                                                    &pIes->RSN);
+    }
+#endif
     return( fRSNMatch );
 }
 
@@ -5062,9 +5162,16 @@ tANI_BOOLEAN csrValidateWep( tpAniSirGlobal pMac, eCsrEncryptionType ucEncryptio
 
 
 //pIes shall contain IEs from pSirBssDesc. It shall be returned from function csrGetParsedBssDescriptionIEs
-tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEncryptionList *pUCEncryptionType, tCsrEncryptionList *pMCEncryptionType,
-                                 tSirBssDescription *pSirBssDesc, tDot11fBeaconIEs *pIes,
-                                 eCsrAuthType *negotiatedAuthtype, eCsrEncryptionType *negotiatedUCCipher, eCsrEncryptionType *negotiatedMCCipher )
+tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType,
+                                 tCsrEncryptionList *pUCEncryptionType,
+                                 tCsrEncryptionList *pMCEncryptionType,
+                                 tANI_BOOLEAN *pMFPEnabled,
+                                 tANI_U8 *pMFPRequired, tANI_U8 *pMFPCapable,
+                                 tSirBssDescription *pSirBssDesc,
+                                 tDot11fBeaconIEs *pIes,
+                                 eCsrAuthType *negotiatedAuthtype,
+                                 eCsrEncryptionType *negotiatedUCCipher,
+                                 eCsrEncryptionType *negotiatedMCCipher )
 {
     tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
     tANI_BOOLEAN fMatch = FALSE;
@@ -5148,7 +5255,10 @@ tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEn
                     if(pIes)
                     {
                         // First check if there is a RSN match
-                        fMatch = csrIsRSNMatch( pMac, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
+                        fMatch = csrIsRSNMatch( pMac, authType, ucCipher,
+                                                pMCEncryptionType, pMFPEnabled,
+                                                pMFPRequired, pMFPCapable,
+                                                pIes, &negAuthType, &mcCipher );
                         if( !fMatch )
                         {
                             // If not RSN, then check if there is a WPA match
@@ -5187,12 +5297,19 @@ tANI_BOOLEAN csrIsSecurityMatch( tHalHandle hHal, tCsrAuthList *authType, tCsrEn
                 {
                     //Check AES first
                     ucCipher = eCSR_ENCRYPT_TYPE_AES;
-                    fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
+                    fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher,
+                                               pMCEncryptionType, pMFPEnabled,
+                                               pMFPRequired, pMFPCapable, pIes,
+                                               &negAuthType, &mcCipher );
                     if(!fMatchAny)
                     {
                         //Check TKIP
                         ucCipher = eCSR_ENCRYPT_TYPE_TKIP;
-                        fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher, pMCEncryptionType, pIes, &negAuthType, &mcCipher );
+                        fMatchAny = csrIsRSNMatch( hHal, authType, ucCipher,
+                                                   pMCEncryptionType,
+                                                   pMFPEnabled, pMFPRequired,
+                                                   pMFPCapable, pIes,
+                                                   &negAuthType, &mcCipher );
                     }
 #ifdef FEATURE_WLAN_WAPI
                     if(!fMatchAny)
@@ -5796,8 +5913,14 @@ tANI_BOOLEAN csrMatchBSS( tHalHandle hHal, tSirBssDescription *pBssDesc, tCsrSca
 #endif
         if ( !csrIsPhyModeMatch( pMac, pFilter->phyMode, pBssDesc, NULL, NULL, pIes ) ) break;
         if ( (!pFilter->bWPSAssociation) && (!pFilter->bOSENAssociation) &&
-             !csrIsSecurityMatch( pMac, &pFilter->authType, &pFilter->EncryptionType, &pFilter->mcEncryptionType,
-                                 pBssDesc, pIes, pNegAuth, pNegUc, pNegMc ) ) break;
+             !csrIsSecurityMatch( pMac, &pFilter->authType,
+                                  &pFilter->EncryptionType,
+                                  &pFilter->mcEncryptionType,
+                                  &pFilter->MFPEnabled,
+                                  &pFilter->MFPRequired,
+                                  &pFilter->MFPCapable,
+                                  pBssDesc, pIes, pNegAuth,
+                                  pNegUc, pNegMc ) ) break;
         if ( !csrIsCapabilitiesMatch( pMac, pFilter->BSSType, pBssDesc ) ) break;
         if ( !csrIsRateSetMatch( pMac, &pIes->SuppRates, &pIes->ExtSuppRates ) ) break;
         //Tush-QoS: validate first if asked for APSD or WMM association
@@ -5854,7 +5977,9 @@ tANI_BOOLEAN csrMatchConnectedBSSSecurity( tpAniSirGlobal pMac, tCsrRoamConnecte
     authList.numEntries = 1;
     authList.authType[0] = pProfile->AuthType;
 
-    return( csrIsSecurityMatch( pMac, &authList, &ucEncryptionList, &mcEncryptionList, pBssDesc, pIes, NULL, NULL, NULL ));
+    return( csrIsSecurityMatch( pMac, &authList, &ucEncryptionList,
+                                &mcEncryptionList, NULL, NULL, NULL,
+                                pBssDesc, pIes, NULL, NULL, NULL ));
 
 }
 
diff --git a/CORE/SYS/legacy/src/utils/src/parserApi.c b/CORE/SYS/legacy/src/utils/src/parserApi.c
index a894ee4b58dd..fbe71325b7b3 100644
--- a/CORE/SYS/legacy/src/utils/src/parserApi.c
+++ b/CORE/SYS/legacy/src/utils/src/parserApi.c
@@ -867,13 +867,13 @@ PopulateDot11fVHTCaps(tpAniSirGlobal           pMac,
         pDot11f->shortGI160and80plus80MHz = (nCfgValue & 0x0001);
 
         nCfgValue = 0;
-        if (psessionEntry->htConfig.ht_rx_stbc)
+        if (psessionEntry->htConfig.ht_tx_stbc)
             CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TXSTBC, nCfgValue );
 
         pDot11f->txSTBC = (nCfgValue & 0x0001);
 
         nCfgValue = 0;
-        if (psessionEntry->htConfig.ht_tx_stbc)
+        if (psessionEntry->htConfig.ht_rx_stbc)
             CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_RXSTBC, nCfgValue );
 
         pDot11f->rxSTBC = (nCfgValue & 0x0007);
diff --git a/Kbuild b/Kbuild
index f1adc044d033..c75cf28b8de9 100644
--- a/Kbuild
+++ b/Kbuild
@@ -991,8 +991,6 @@ CDEFINES :=	-DANI_LITTLE_BYTE_ENDIAN \
 		-DFEATURE_WLAN_LPHB \
 		-DFEATURE_WLAN_PAL_TIMER_DISABLE \
 		-DFEATURE_WLAN_PAL_MEM_DISABLE \
-                -DQCA_SUPPORT_TXRX_VDEV_PAUSE_LL \
-		-DQCA_SUPPORT_TX_THROTTLE_LL \
 		-DWMI_INTERFACE_EVENT_LOGGING \
 		-DATH_SUPPORT_WAPI \
 		-DFEATURE_WLAN_EXTSCAN
@@ -1015,7 +1013,9 @@ else
 CDEFINES +=	-DOSIF_NEED_RX_PEER_ID \
 		-DQCA_SUPPORT_TXRX_LOCAL_PEER_ID
 ifeq ($(CONFIG_ROME_IF),pci)
-CDEFINES +=	-DQCA_LL_TX_FLOW_CT
+CDEFINES +=	-DQCA_LL_TX_FLOW_CT \
+		-DQCA_SUPPORT_TXRX_VDEV_PAUSE_LL \
+		-DQCA_SUPPORT_TX_THROTTLE_LL
 endif
 endif
 
diff --git a/tools/fwdebuglog/Android.mk b/tools/fwdebuglog/Android.mk
index 171e8636edca..b2ffb31938eb 100644
--- a/tools/fwdebuglog/Android.mk
+++ b/tools/fwdebuglog/Android.mk
@@ -18,7 +18,6 @@ LOCAL_SHARED_LIBRARIES := libc libcutils libdiag libhardware_legacy
 LOCAL_SRC_FILES := cld-fwlog-netlink.c parser.c
 LOCAL_CFLAGS += -DCONFIG_ANDROID_LOG
 LOCAL_LDLIBS += -llog
-LOCAL_LDLIBS := -landroid
 include $(BUILD_EXECUTABLE)
 
 include $(CLEAR_VARS)
@@ -32,7 +31,6 @@ LOCAL_SHARED_LIBRARIES := libc libcutils libdiag libhardware_legacy
 LOCAL_SRC_FILES := cld-fwlog-netlink.c parser.c
 LOCAL_CFLAGS += -DCONFIG_ANDROID_LOG
 LOCAL_LDLIBS += -llog
-LOCAL_LDLIBS := -landroid
 include $(BUILD_EXECUTABLE)