Merge "Release 1.0.0.132 QCACLD WLAN Driver"

32 files changed, 3590 insertions, 421 deletions

diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_queue.c b/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
index 995ffe354e7f..779009abd032 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
@@ -511,7 +511,7 @@ ol_txrx_pdev_pause(ol_txrx_pdev_handle pdev)
     struct ol_txrx_vdev_t *vdev = NULL, *tmp;
 
     TAILQ_FOREACH_SAFE(vdev, &pdev->vdev_list, vdev_list_elem, tmp) {
-        ol_txrx_vdev_pause(vdev);
+        ol_txrx_vdev_pause(vdev, 0);
     }
 }
 
@@ -521,7 +521,7 @@ ol_txrx_pdev_unpause(ol_txrx_pdev_handle pdev)
     struct ol_txrx_vdev_t *vdev = NULL, *tmp;
 
     TAILQ_FOREACH_SAFE(vdev, &pdev->vdev_list, vdev_list_elem, tmp) {
-        ol_txrx_vdev_unpause(vdev);
+        ol_txrx_vdev_unpause(vdev, 0);
     }
 }
 
diff --git a/CORE/HDD/inc/qc_sap_ioctl.h b/CORE/HDD/inc/qc_sap_ioctl.h
index 6e28f9314ded..867ebe716265 100644
--- a/CORE/HDD/inc/qc_sap_ioctl.h
+++ b/CORE/HDD/inc/qc_sap_ioctl.h
@@ -91,62 +91,6 @@ typedef enum {
     eQC_WPS_ASSOC_RSP_IE
 } eQCWPSType;
 
-typedef struct s_CommitConfig {
-
-    tSSIDInfo SSIDinfo;
-
-    u_int32_t beacon_int;       /* Beacon Interval */
-
-    tQcPhyMode hw_mode;         /* Wireless Mode */
-
-    u_int32_t channel;          /* Operation channel */
-
-    u_int32_t max_num_sta;      /* maximum number of STAs in station table */
-
-    u_int32_t dtim_period;      /* dtim interval */
-    u_int32_t max_listen_interval;
-
-    enum {
-        QC_ACCEPT_UNLESS_DENIED = 0,
-        QC_DENY_UNLESS_ACCEPTED = 1,
-    } qc_macaddr_acl;
-
-    struct qc_mac_acl_entry *accept_mac; /* MAC filtering */
-    u_int32_t num_accept_mac;
-    struct qc_mac_acl_entry *deny_mac;   /* MAC filtering */
-    u_int32_t num_deny_mac;
-
-    u_int32_t ap_table_max_size;
-    u_int32_t ap_table_expiration_time;
-
-    int qcsap80211d;
-
-    u_int32_t countryCode[3];  //it ignored if [0] is 0.
-
-    u_int32_t ht_op_mode_fixed;
-
-    /*HT capability information to enable/diabale protection
-     *           bit15   bit14   bit13   bit12 bit11 bit10    bit9 bit8
-     * (overlap) from11a from11b from11g Ht20  NonGf LsigTxop Rifs OBSS
-     * bit7    bit6    bit5    bit4 bit3  bit2     bit1 bit0
-     * from11a from11b from11g ht20 nonGf lsigTxop rifs obss*/
-    u_int16_t ht_capab;
-
-    u_int32_t qcsap80211n;
-
-    eQcAuthType authType;
-
-    u_int8_t privacy;
-
-    u_int8_t set_ieee8021x;
-
-    u_int8_t RSNWPAReqIE[QCSAP_MAX_OPT_IE];     //If not null, it has the IE byte stream for RSN/WPA
-    u_int16_t RSNWPAReqIELength;  //The byte count in the pRSNReqIE/ WPAIE
-
-    u_int8_t wps_state; //wps_state - disbaled/not configured, configured
-} s_CommitConfig_t;
-
-
 /*
  * MLME state manipulation request.  QCSAP_MLME_ASSOC
  * is used for station mode only.  The other types are used for station or ap mode.
@@ -211,7 +155,7 @@ typedef struct
 
 #define QCSAP_IOCTL_SETPARAM          (SIOCIWFIRSTPRIV+0)
 #define QCSAP_IOCTL_GETPARAM          (SIOCIWFIRSTPRIV+1)
-#define QCSAP_IOCTL_COMMIT            (SIOCIWFIRSTPRIV+2)
+/* (SIOCIWFIRSTPRIV+2) is unused */
 #define QCSAP_IOCTL_SETMLME           (SIOCIWFIRSTPRIV+3)
 
 #define QCSAP_IOCTL_GET_STAWPAIE      (SIOCIWFIRSTPRIV+4)
diff --git a/CORE/HDD/inc/wlan_hdd_cfg.h b/CORE/HDD/inc/wlan_hdd_cfg.h
index f30efb7929cf..b788e62fee08 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg.h
@@ -2584,21 +2584,21 @@ This feature requires the dependent cfg.ini "gRoamPrefer5GHz" set to 1 */
 #endif /* MSM_PLATFORM */
 
 #ifdef WLAN_FEATURE_11W
-#define CFG_PMF_SA_QUERY_MAX_RETRIES_NAME                    "pmfSaQueryMaxRetries"
-#define CFG_PMF_SA_QUERY_MAX_RETRIES_DEFAULT                 ( 5  )
-#define CFG_PMF_SA_QUERY_MAX_RETRIES_MIN                     ( 0 )
-#define CFG_PMF_SA_QUERY_MAX_RETRIES_MAX                     ( 20  )
+#define CFG_PMF_SA_QUERY_MAX_RETRIES_NAME          "pmfSaQueryMaxRetries"
+#define CFG_PMF_SA_QUERY_MAX_RETRIES_DEFAULT       ( 5 )
+#define CFG_PMF_SA_QUERY_MAX_RETRIES_MIN           ( 0 )
+#define CFG_PMF_SA_QUERY_MAX_RETRIES_MAX           ( 20 )
 
-#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_NAME                 "pmfSaQueryRetryInterval"
-#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_DEFAULT              ( 200    )
-#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_MIN                  ( 0 )
-#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_MAX                  ( 2000  )
+#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_NAME       "pmfSaQueryRetryInterval"
+#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_DEFAULT    ( 200 )
+#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_MIN        ( 0 )
+#define CFG_PMF_SA_QUERY_RETRY_INTERVAL_MAX        ( 2000 )
 #endif
 
-#define CFG_MAX_CONCURRENT_CONNECTIONS_NAME       "gMaxConcurrentActiveSessions"
-#define CFG_MAX_CONCURRENT_CONNECTIONS_DEFAULT    ( 2 )
-#define CFG_MAX_CONCURRENT_CONNECTIONS_MIN        ( 1 )
-#define CFG_MAX_CONCURRENT_CONNECTIONS_MAX        ( 4 )
+#define CFG_MAX_CONCURRENT_CONNECTIONS_NAME        "gMaxConcurrentActiveSessions"
+#define CFG_MAX_CONCURRENT_CONNECTIONS_DEFAULT     ( 2 )
+#define CFG_MAX_CONCURRENT_CONNECTIONS_MIN         ( 1 )
+#define CFG_MAX_CONCURRENT_CONNECTIONS_MAX         ( 4 )
 
 #ifdef QCA_HT_2040_COEX
 #define CFG_ENABLE_HT_2040_COEX                    "gHT2040CoexEnabled"
@@ -2607,10 +2607,15 @@ This feature requires the dependent cfg.ini "gRoamPrefer5GHz" set to 1 */
 #define CFG_ENABLE_HT_2040_COEX_DEFAULT            ( 0 )
 #endif
 
-#define CFG_IGNORE_CAC_NAME     "gIgnoreCAC"
-#define CFG_IGNORE_CAC_MIN      (0)
-#define CFG_IGNORE_CAC_MAX      (1)
-#define CFG_IGNORE_CAC_DEFAULT  (0)
+#define CFG_IGNORE_CAC_NAME                        "gIgnoreCAC"
+#define CFG_IGNORE_CAC_MIN                         ( 0 )
+#define CFG_IGNORE_CAC_MAX                         ( 1 )
+#define CFG_IGNORE_CAC_DEFAULT                     ( 0 )
+
+#define CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_NAME      "gEnableSAPDfsChSifsBurst"
+#define CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_MIN       ( 0 )
+#define CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_MAX       ( 1 )
+#define CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_DEFAULT   ( 1 )
 
 /*---------------------------------------------------------------------------
   Type declarations
@@ -3170,6 +3175,7 @@ typedef struct
    v_BOOL_t                    ht2040CoexEnabled;
 #endif
    v_U8_t      ignoreCAC;
+   v_BOOL_t                    IsSapDfsChSifsBurstEnabled;
 } 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 a1b0aa7d11cb..8e01acfc9774 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg80211.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg80211.h
@@ -121,13 +121,46 @@ typedef struct {
  * git://w1.fi/srv/git/hostap.git; the values here are just a copy of that
  */
 #define QCA_NL80211_VENDOR_ID                          0x001374
-#define QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY      10
-#define QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY       11
-#define QCA_NL80211_VENDOR_SUBCMD_NAN                  12
-#define QCA_NL80211_VENDOR_SUBCMD_STATS_EXT            13
 
-enum qca_wlan_vendor_attr
-{
+enum qca_nl80211_vendor_subcmds {
+    QCA_NL80211_VENDOR_SUBCMD_UNSPEC = 0,
+    QCA_NL80211_VENDOR_SUBCMD_TEST = 1,
+    /* subcmds 2..9 not yet allocated */
+    QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY = 10,
+    QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY =  11,
+    QCA_NL80211_VENDOR_SUBCMD_NAN =  12,
+    QCA_NL80211_VENDOR_SUBCMD_STATS_EXT = 13,
+    /* subcommands for link layer statistics start here */
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_SET = 14,
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_GET = 15,
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_CLR = 16,
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_RADIO_RESULTS = 17,
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_IFACE_RESULTS = 18,
+    QCA_NL80211_VENDOR_SUBCMD_LL_STATS_PEERS_RESULTS = 19,
+    /* subcommands for extscan start here */
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START = 20,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP = 21,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_VALID_CHANNELS = 22,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES = 23,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS = 24,
+    /* Used when report_threshold is reached in scan cache. */
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE = 25,
+    /* Used to report scan results when each probe rsp. is received,
+     * if report_events enabled in wifi_scan_cmd_params.
+     */
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT = 26,
+    /* Indicates progress of scanning state-machine. */
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT = 27,
+    /* Indicates BSSID Hotlist. */
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND = 28,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST = 29,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST = 30,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE = 31,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE = 32,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE = 33,
+};
+
+enum qca_wlan_vendor_attr {
     QCA_WLAN_VENDOR_ATTR_INVALID = 0,
     /* used by QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY */
     QCA_WLAN_VENDOR_ATTR_DFS     = 1,
@@ -135,22 +168,277 @@ enum qca_wlan_vendor_attr
     QCA_WLAN_VENDOR_ATTR_NAN     = 2,
     /* used by QCA_NL80211_VENDOR_SUBCMD_STATS_EXT */
     QCA_WLAN_VENDOR_ATTR_STATS_EXT     = 3,
+
     QCA_WLAN_VENDOR_ATTR_IFINDEX     = 4,
+
     /* keep last */
     QCA_WLAN_VENDOR_ATTR_AFTER_LAST,
     QCA_WLAN_VENDOR_ATTR_MAX       = QCA_WLAN_VENDOR_ATTR_AFTER_LAST - 1,
 };
 
-/* Vendor specific sub-command index, may change later due to NAN */
-#ifdef WLAN_FEATURE_STATS_EXT
-#define QCA_NL80211_VENDOR_SUBCMD_STATS_EXT_INDEX   1
-#endif /* WLAN_FEATURE_STATS_EXT */
 
-/* Vendor specific sub-command id and their index */
+enum qca_wlan_vendor_attr_extscan_config_params
+{
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_INVALID = 0,
+
+    /* Unsigned 32-bit value; Middleware provides it to the driver. Middle ware
+     * either gets it from caller, e.g., framework, or generates one if
+     * framework doesn't provide it.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID,
+
+    /* NL attributes for data used by
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_VALID_CHANNELS sub command.
+     */
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_MAX_CHANNELS,
+
+    /* NL attributes for input params used by
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START sub command.
+     */
+
+    /* Unsigned 32-bit value; channel frequency */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL,
+    /* Unsigned 32-bit value; dwell time in ms. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME,
+    /* Unsigned 8-bit value; 0: active; 1: passive; N/A for DFS */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE,
+    /* Unsigned 8-bit value; channel class */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CLASS,
+
+    /* Unsigned 8-bit value; bucket index, 0 based */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX,
+    /* Unsigned 8-bit value; band. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND,
+    /* Unsigned 32-bit value; desired period, in ms. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD,
+    /* Unsigned 8-bit value; report events semantics. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS,
+    /* Unsigned 32-bit value.
+     * Followed by a nested array of EXTSCAN_CHANNEL_SPEC_* attributes.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS,
+
+    /* Array of QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_* attributes.
+     * Array size: QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC,
+
+    /* Unsigned 32-bit value; base timer period in ms. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD,
+    /* Unsigned 32-bit value; number of APs to store in each scan in the
+     * BSSID/RSSI history buffer (keep the highest RSSI APs).
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN,
+    /* Unsigned 8-bit value; In %, when scan buffer is this much full, wake up
+     * APPS.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD,
+    /* Unsigned 8-bit value; number of scan bucket specs; followed by a nested
+     * array of_EXTSCAN_BUCKET_SPEC_* attributes and values. The size of the
+     * array is determined by NUM_BUCKETS.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS,
+
+    /* Array of QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_* attributes.
+     * Array size: QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC,
+
+    /* Unsigned 8-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_FLUSH,
+    /* Unsigned 32-bit value; maximum number of results to be returned. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_MAX,
+
+    /* An array of 6 x Unsigned 8-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID,
+    /* Signed 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW,
+    /* Signed 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL,
+
+    /* Number of hotlist APs as unsigned 32-bit value, followed by a nested
+     * array of AP_THRESHOLD_PARAM attributes and values. The size of the
+     * array is determined by NUM_AP.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_BSSID_HOTLIST_PARAMS_NUM_AP,
+
+    /* Array of QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_* attributes.
+     * Array size: QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM,
+
+    /* Unsigned 32bit value; number of samples for averaging RSSI. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_RSSI_SAMPLE_SIZE,
+    /* Unsigned 32bit value; number of samples to confirm AP loss. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_LOST_AP_SAMPLE_SIZE,
+    /* Unsigned 32bit value; number of APs breaching threshold. */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_MIN_BREACHING,
+    /* Unsigned 32bit value; number of APs. Followed by an array of
+     * AP_THRESHOLD_PARAM attributes. Size of the array is NUM_AP.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_NUM_AP,
+
+    /* keep last */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_AFTER_LAST,
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX =
+        QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_extscan_results
+{
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_INVALID = 0,
+
+    /* Unsigned 32-bit value; must match the request Id supplied by Wi-Fi HAL
+      * in the corresponding subcmd NL msg
+      */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+
+    /* Unsigned 32-bit value; used to indicate the status response from
+      * firmware/driver for the vendor sub-command.
+      */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS,
+
+    /* EXTSCAN Valid Channels attributes */
+    /* Unsigned 32bit value; followed by a nested array of CHANNELS.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_CHANNELS,
+    /* An array of NUM_CHANNELS x Unsigned 32bit value integers representing
+     * channel numbers
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CHANNELS,
+
+    /* EXTSCAN Capabilities attributes */
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_CACHE_SIZE,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_BUCKETS,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_AP_CACHE_PER_SCAN,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_RSSI_SAMPLE_SIZE,
+    /* Signed 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_REPORTING_THRESHOLD,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_HOTLIST_APS,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SIGNIFICANT_WIFI_CHANGE_APS,
+    /* Unsigned 32bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_BSSID_HISTORY_ENTRIES,
+
+    /* EXTSCAN Attributes used with
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE sub-command.
+     */
+
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE,
+
+
+    /* EXTSCAN attributes used with
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT sub-command.
+     */
+
+    /* An array of NUM_RESULTS_AVAILABLE x
+     * QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_*
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_LIST,
+
+    /* Unsigned 64-bit value; age of sample at the time of retrieval */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_TIME_STAMP,
+    /* 33 x unsiged 8-bit value; NULL terminated SSID */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_SSID,
+    /* An array of 6 x Unsigned 8-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BSSID,
+    /* Unsigned 32-bit value; channel frequency in MHz */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CHANNEL,
+    /* Signed 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RSSI,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT_SD,
+    /* Unsigned 16-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BEACON_PERIOD,
+    /* Unsigned 16-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CAPABILITY,
+    /* Unsigned 32-bit value; size of the IE DATA blob */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_LENGTH,
+    /* An array of IE_LENGTH x Unsigned 8-bit value; blob of all the
+     * information elements found in the beacon; this data should be a
+     * packed list of wifi_information_element objects, one after the other.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_DATA,
+    /* Unsigned 8-bit value; set by driver to indicate more scan results are
+     * available.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_MORE_DATA,
+
+    /* EXTSCAN attributes for
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT sub-command.
+     */
+    /* Unsigned 8-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_EVENT_TYPE,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_EVENT_STATUS,
+
+    /* EXTSCAN attributes for
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND sub-command.
+     */
+    /* Use attr QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE
+     * to indicate number of results.
+     */
+
+    /* EXTSCAN attributes for
+     * QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE sub-command.
+     */
+    /* An array of 6 x Unsigned 8-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_BSSID,
+    /* Unsigned 32-bit value */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_CHANNEL,
+    /* Unsigned 32-bit value.
+      */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_NUM_RSSI,
+    /* A nested array of signed 32-bit RSSI values. Size of the array is
+     * determined by (NUM_RSSI of SIGNIFICANT_CHANGE_RESULT_NUM_RSSI.
+     */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_RSSI_LIST,
+
+    /* keep last */
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_AFTER_LAST,
+    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_MAX =
+        QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_AFTER_LAST - 1,
+};
+
+enum qca_nl80211_vendor_subcmds_index {
 #ifdef FEATURE_WLAN_CH_AVOID
-#define QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY_INDEX   0
+    QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY_INDEX = 0,
 #endif /* FEATURE_WLAN_CH_AVOID */
 
+#ifdef WLAN_FEATURE_STATS_EXT
+    QCA_NL80211_VENDOR_SUBCMD_STATS_EXT_INDEX,
+#endif /* WLAN_FEATURE_STATS_EXT */
+
+#ifdef FEATURE_WLAN_EXTSCAN
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE_INDEX,
+    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE_INDEX,
+#endif /* FEATURE_WLAN_EXTSCAN */
+};
+
 #ifdef FEATURE_WLAN_CH_AVOID
 #define HDD_MAX_AVOID_FREQ_RANGES   4
 typedef struct sHddAvoidFreqRange
@@ -260,5 +548,10 @@ void hdd_resume_wlan(void);
 int wlan_hdd_send_avoid_freq_event(hdd_context_t *pHddCtx,
                                    tHddAvoidFreqList *pAvoidFreqList);
 #endif
+#ifdef FEATURE_WLAN_EXTSCAN
+void wlan_hdd_cfg80211_extscan_callback(void *ctx,
+                                      const tANI_U16 evType,
+                                      void *pMsg);
+#endif /* FEATURE_WLAN_EXTSCAN */
 
 #endif
diff --git a/CORE/HDD/src/wlan_hdd_cfg.c b/CORE/HDD/src/wlan_hdd_cfg.c
index df7849afadcd..233faaf0f6ca 100644
--- a/CORE/HDD/src/wlan_hdd_cfg.c
+++ b/CORE/HDD/src/wlan_hdd_cfg.c
@@ -3599,12 +3599,20 @@ REG_TABLE_ENTRY g_registry_table[] =
                 CFG_ENABLE_HT_2040_COEX_MIN,
                 CFG_ENABLE_HT_2040_COEX_MAX ),
 #endif
+
    REG_VARIABLE(CFG_IGNORE_CAC_NAME, WLAN_PARAM_Integer,
                 hdd_config_t, ignoreCAC,
                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
                 CFG_IGNORE_CAC_DEFAULT,
                 CFG_IGNORE_CAC_MIN,
                 CFG_IGNORE_CAC_MAX),
+
+   REG_VARIABLE(CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_NAME, WLAN_PARAM_Integer,
+                hdd_config_t, IsSapDfsChSifsBurstEnabled,
+                VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK_ASSUME_DEFAULT,
+                CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_DEFAULT,
+                CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_MIN,
+                CFG_ENABLE_SAP_DFS_CH_SIFS_BURST_MAX ),
 };
 
 #ifdef WLAN_FEATURE_MBSSID
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 0b663bc5acf0..5977ff4415a7 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -178,6 +178,17 @@
 
 #define HDD_CHANNEL_14 14
 
+#ifdef FEATURE_WLAN_EXTSCAN
+/*
+ * Used to allocate the size of 4096 for the EXTScan NL data.
+ * The size of 4096 is considered assuming that all data per
+ * respective event fit with in the limit.Please take a call
+ * on the limit based on the data requirements.
+ */
+
+#define EXTSCAN_EVENT_BUF_SIZE 4096
+#endif
+
 static const u32 hdd_cipher_suites[] =
 {
     WLAN_CIPHER_SUITE_WEP40,
@@ -666,6 +677,51 @@ static const struct nla_policy wlan_hdd_tm_policy[WLAN_HDD_TM_ATTR_MAX + 1] =
 };
 #endif /* WLAN_NL80211_TESTMODE */
 
+#ifdef FEATURE_WLAN_EXTSCAN
+
+static const struct nla_policy
+wlan_hdd_extscan_config_policy[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1] =
+{
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CLASS] = { .type = NLA_U8 },
+
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS] = { .type = NLA_U8 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_FLUSH] = { .type = NLA_U8 },
+
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_MAX] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID] = { .type = NLA_UNSPEC },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW] = { .type = NLA_S32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH] = { .type = NLA_S32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_BSSID_HOTLIST_PARAMS_NUM_AP] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_RSSI_SAMPLE_SIZE] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_LOST_AP_SAMPLE_SIZE] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_MIN_BREACHING] = { .type = NLA_U32 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_NUM_AP] = { .type = NLA_U32 },
+};
+
+static const struct nla_policy
+wlan_hdd_extscan_results_policy[QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_MAX + 1] =
+{
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BEACON_PERIOD] = { .type = NLA_U16 },
+    [QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CAPABILITY] = { .type = NLA_U16 },
+};
+
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 #ifdef FEATURE_WLAN_CH_AVOID
 /*
  * FUNCTION: wlan_hdd_send_avoid_freq_event
@@ -718,18 +774,72 @@ int wlan_hdd_send_avoid_freq_event(hdd_context_t *pHddCtx,
 static const struct nl80211_vendor_cmd_info wlan_hdd_cfg80211_vendor_events[] =
 {
 #ifdef FEATURE_WLAN_CH_AVOID
-    {
+    [QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY_INDEX] = {
         .vendor_id = QCA_NL80211_VENDOR_ID,
         .subcmd = QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY
     },
 #endif /* FEATURE_WLAN_CH_AVOID */
 
 #ifdef WLAN_FEATURE_STATS_EXT
-    {
+    [QCA_NL80211_VENDOR_SUBCMD_STATS_EXT_INDEX] = {
         .vendor_id = QCA_NL80211_VENDOR_ID,
         .subcmd = QCA_NL80211_VENDOR_SUBCMD_STATS_EXT
     },
 #endif /* WLAN_FEATURE_STATS_EXT */
+#ifdef FEATURE_WLAN_EXTSCAN
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE
+    },
+    [QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE
+    },
+#endif /* FEATURE_WLAN_EXTSCAN */
 };
 
 int is_driver_dfs_capable(struct wiphy *wiphy, struct wireless_dev *wdev,
@@ -872,6 +982,856 @@ void wlan_hdd_cfg80211_stats_ext_init(hdd_context_t *pHddCtx)
 
 #endif
 
+#ifdef FEATURE_WLAN_EXTSCAN
+static int wlan_hdd_cfg80211_extscan_get_capabilities(struct wiphy *wiphy,
+                                                struct wireless_dev *wdev,
+                                                void *data, int data_len)
+{
+    tpSirGetExtScanCapabilitiesReqParams pReqMsg = NULL;
+    struct net_device *dev                     = wdev->netdev;
+    hdd_adapter_t *pAdapter                    = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                     = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    eHalStatus status;
+
+    ENTER();
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    status = sme_ExtScanGetCapabilities(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               FL("sme_ExtScanGetCapabilities failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_get_cached_results(struct wiphy *wiphy,
+                                                  struct wireless_dev *wdev,
+                                                  void *data, int data_len)
+{
+    tpSirExtScanGetCachedResultsReqParams pReqMsg = NULL;
+    struct net_device *dev                      = wdev->netdev;
+    hdd_adapter_t *pAdapter                     = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                      = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    eHalStatus status;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    /* Parse and fetch flush parameter */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_FLUSH])
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr flush failed"));
+        goto fail;
+    }
+    pReqMsg->flush = nla_get_u8(
+       tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_FLUSH]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Flush (%d)"), pReqMsg->flush);
+
+    status = sme_getCachedResults(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               FL("sme_getCachedResults failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_set_bssid_hotlist(struct wiphy *wiphy,
+                                                 struct wireless_dev *wdev,
+                                                 void *data, int data_len)
+{
+    tpSirExtScanSetBssidHotListReqParams pReqMsg = NULL;
+    struct net_device *dev                     = wdev->netdev;
+    hdd_adapter_t *pAdapter                    = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                     = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *apTh;
+    eHalStatus status;
+    tANI_U8 i;
+    int rem;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    /* Parse and fetch number of APs */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BSSID_HOTLIST_PARAMS_NUM_AP]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr number of AP failed"));
+        goto fail;
+    }
+    pReqMsg->numAp = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BSSID_HOTLIST_PARAMS_NUM_AP]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Number of AP (%d)"), pReqMsg->numAp);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    i = 0;
+    nla_for_each_nested(apTh,
+                tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM], rem) {
+        if (nla_parse(tb2, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                nla_data(apTh), nla_len(apTh),
+                wlan_hdd_extscan_config_policy)) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla_parse failed"));
+            goto fail;
+        }
+
+        /* Parse and fetch MAC address */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr mac address failed"));
+            goto fail;
+        }
+        nla_memcpy(pReqMsg->ap[i].bssid, nla_data(
+                tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID]),
+                sizeof(tSirMacAddr));
+        hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pReqMsg->ap[i].bssid));
+
+        /* Parse and fetch low RSSI */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr low RSSI failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].low = nla_get_s32(
+             tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("RSSI low (%d)"), pReqMsg->ap[i].low);
+
+        /* Parse and fetch high RSSI */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr high RSSI failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].high = nla_get_s32(
+            tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("RSSI High (%d)"),
+                                         pReqMsg->ap[i].high);
+
+        /* Parse and fetch channel */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr channel failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].channel = nla_get_u32(
+              tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("Channel (%u)"),
+                                     pReqMsg->ap[i].channel);
+        i++;
+    }
+
+    status = sme_SetBssHotlist(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("sme_SetBssHotlist failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_set_significant_change(
+                                        struct wiphy *wiphy,
+                                        struct wireless_dev *wdev,
+                                        void *data, int data_len)
+{
+    tpSirExtScanSetSigChangeReqParams pReqMsg = NULL;
+    struct net_device *dev                  = wdev->netdev;
+    hdd_adapter_t *pAdapter                 = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                  = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *apTh;
+    eHalStatus status;
+    tANI_U8 i;
+    int rem;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    /* Parse and fetch RSSI sample size */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_RSSI_SAMPLE_SIZE])
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr RSSI sample size failed"));
+        goto fail;
+    }
+    pReqMsg->rssiSampleSize = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_RSSI_SAMPLE_SIZE]);
+    hddLog(VOS_TRACE_LEVEL_INFO,
+               FL("RSSI sample size (%u)"), pReqMsg->rssiSampleSize);
+
+    /* Parse and fetch lost AP sample size */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_LOST_AP_SAMPLE_SIZE])
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr lost AP sample size failed"));
+        goto fail;
+    }
+    pReqMsg->lostApSampleSize = nla_get_u32(
+       tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_LOST_AP_SAMPLE_SIZE]);
+    hddLog(VOS_TRACE_LEVEL_INFO,
+               FL("Lost AP sample size (%u)"), pReqMsg->lostApSampleSize);
+
+    /* Parse and fetch AP min breacing */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_MIN_BREACHING])
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr AP min breaching"));
+        goto fail;
+    }
+    pReqMsg->minBreaching = nla_get_u32(
+     tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_MIN_BREACHING]);
+    hddLog(VOS_TRACE_LEVEL_INFO,
+               FL("AP min breaching (%u)"), pReqMsg->minBreaching);
+
+    /* Parse and fetch number of APs */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_NUM_AP]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr number of AP failed"));
+        goto fail;
+    }
+    pReqMsg->numAp = nla_get_u32(
+            tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SIGNIFICANT_CHANGE_PARAMS_NUM_AP]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Number of AP (%d)"), pReqMsg->numAp);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    i = 0;
+    nla_for_each_nested(apTh,
+                tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM], rem) {
+        if (nla_parse(tb2,
+                QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                nla_data(apTh), nla_len(apTh),
+                wlan_hdd_extscan_config_policy)) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla_parse failed"));
+            goto fail;
+        }
+
+        /* Parse and fetch MAC address */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr mac address failed"));
+            goto fail;
+        }
+        nla_memcpy(pReqMsg->ap[i].bssid, nla_data(
+                tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_BSSID]),
+                sizeof(tSirMacAddr));
+        hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pReqMsg->ap[i].bssid));
+
+        /* Parse and fetch low RSSI */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr low RSSI failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].low = nla_get_s32(
+             tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_LOW]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("RSSI low (%d)"), pReqMsg->ap[i].low);
+
+        /* Parse and fetch high RSSI */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr high RSSI failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].high = nla_get_s32(
+            tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH]);
+        hddLog(VOS_TRACE_LEVEL_INFO,
+                                    FL("RSSI High (%d)"), pReqMsg->ap[i].high);
+
+        /* Parse and fetch channel */
+        if (!tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr channel failed"));
+            goto fail;
+        }
+        pReqMsg->ap[i].channel = nla_get_u32(
+              tb2[QCA_WLAN_VENDOR_ATTR_EXTSCAN_AP_THRESHOLD_PARAM_CHANNEL]);
+        hddLog(VOS_TRACE_LEVEL_INFO,
+                           FL("Channel (%u)"), pReqMsg->ap[i].channel);
+        i++;
+    }
+
+    status = sme_SetSignificantChange(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("sme_SetSignificantChange failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_get_valid_channels(struct wiphy *wiphy,
+                                        struct wireless_dev *wdev,
+                                        void *data, int data_len)
+{
+    hdd_context_t *pHddCtx                               = wiphy_priv(wiphy);
+    tANI_U32 ChannelList[WNI_CFG_VALID_CHANNEL_LIST_LEN] = {0};
+    tANI_U8 numChannels                                  = 0;
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    tANI_U32 requestId;
+    tWifiBand wifiBand;
+    eHalStatus status;
+    struct sk_buff *reply_skb;
+    tANI_U8 i;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                  data, data_len,
+                  wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        return -EINVAL;
+    }
+    requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), requestId);
+
+    /* Parse and fetch wifi band */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND])
+    {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr wifi band failed"));
+        return -EINVAL;
+    }
+    wifiBand = nla_get_u32(
+     tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Wifi band (%d)"), wifiBand);
+
+    status = sme_GetValidChannelsByBand((tHalHandle)(pHddCtx->hHal),
+                                        wifiBand, ChannelList,
+                                        &numChannels);
+    if (eHAL_STATUS_SUCCESS != status) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+           FL("sme_GetValidChannelsByBand failed (err=%d)"), status);
+        return -EINVAL;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Number of channels (%d)"), numChannels);
+    for (i = 0; i < numChannels; i++)
+        hddLog(VOS_TRACE_LEVEL_INFO, "Channel: %u ", ChannelList[i]);
+
+    reply_skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, sizeof(u32) +
+                                                    sizeof(u32) * numChannels +
+                                                    NLMSG_HDRLEN);
+
+    if (reply_skb) {
+        if (nla_put_u32(reply_skb,
+                        QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_CHANNELS,
+                        numChannels) ||
+            nla_put(reply_skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CHANNELS,
+                    sizeof(u32) * numChannels, ChannelList)) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+            kfree_skb(reply_skb);
+            return -EINVAL;
+        }
+
+        return cfg80211_vendor_cmd_reply(reply_skb);
+    }
+    hddLog(VOS_TRACE_LEVEL_ERROR,
+              FL("valid channels: buffer alloc fail"));
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy,
+                                           struct wireless_dev *wdev,
+                                           void *data, int data_len)
+{
+    tpSirWifiScanCmdReqParams pReqMsg       = NULL;
+    struct net_device *dev                  = wdev->netdev;
+    hdd_adapter_t *pAdapter                 = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                  = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    struct nlattr *buckets;
+    struct nlattr *channels;
+    int rem1, rem2;
+    eHalStatus status;
+    tANI_U8 bktIndex, i, j;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    /* Parse and fetch base period */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr base period failed"));
+        goto fail;
+    }
+    pReqMsg->basePeriod = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Base Period (%d)"),
+                                         pReqMsg->basePeriod);
+
+    /* Parse and fetch max AP per scan */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr max_ap_per_scan failed"));
+        goto fail;
+    }
+    pReqMsg->maxAPperScan = nla_get_u32(
+             tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Max AP per Scan (%d)"),
+                                         pReqMsg->maxAPperScan);
+
+    /* Parse and fetch report threshold */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr report_threshold failed"));
+        goto fail;
+    }
+    pReqMsg->reportThreshold = nla_get_u8(
+            tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Report Threshold (%d)"),
+                                         pReqMsg->reportThreshold);
+
+    /* Parse and fetch number of buckets */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr number of buckets failed"));
+        goto fail;
+    }
+    pReqMsg->numBuckets = nla_get_u8(
+                 tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS]);
+    if (pReqMsg->numBuckets > WLAN_EXTSCAN_MAX_BUCKETS) {
+        hddLog(VOS_TRACE_LEVEL_WARN, FL("Exceeded MAX number of buckets "
+          "Setting numBuckets to %u"), WLAN_EXTSCAN_MAX_BUCKETS);
+        pReqMsg->numBuckets = WLAN_EXTSCAN_MAX_BUCKETS;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Number of Buckets (%d)"),
+                                         pReqMsg->numBuckets);
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr bucket spec failed"));
+        goto fail;
+    }
+
+    i = 0;
+    nla_for_each_nested(buckets,
+                tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC], rem1) {
+        if (nla_parse(bucket,
+            QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+            nla_data(buckets), nla_len(buckets), NULL)) { //policy
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla_parse failed"));
+            goto fail;
+        }
+
+        /* Parse and fetch bucket spec */
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr bucket index failed"));
+            goto fail;
+        }
+        bktIndex = nla_get_u8(
+                       bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("Bucket spec Index (%d)"), bktIndex);
+        pReqMsg->buckets[bktIndex].bucket = bktIndex;
+
+        /* Parse and fetch wifi band */
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr wifi band failed"));
+            goto fail;
+        }
+        pReqMsg->buckets[bktIndex].band = nla_get_u8(
+                        bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("Wifi band (%d)"),
+                           pReqMsg->buckets[bktIndex].band);
+
+        /* Parse and fetch period */
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr period failed"));
+            goto fail;
+        }
+        pReqMsg->buckets[bktIndex].period = nla_get_u32(
+                      bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("period (%d)"),
+                           pReqMsg->buckets[bktIndex].period);
+
+        /* Parse and fetch report events */
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr report events failed"));
+            goto fail;
+        }
+        pReqMsg->buckets[bktIndex].reportEvents = nla_get_u8(
+               bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("report events (%d)"),
+                           pReqMsg->buckets[bktIndex].reportEvents);
+
+        /* Parse and fetch number of channels */
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr num channels failed"));
+            goto fail;
+        }
+        pReqMsg->buckets[bktIndex].numChannels = nla_get_u32(
+           bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS]);
+        hddLog(VOS_TRACE_LEVEL_INFO, FL("num channels (%d)"),
+                           pReqMsg->buckets[bktIndex].numChannels);
+
+        if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC]) {
+            hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr channel spec failed"));
+            goto fail;
+        }
+
+        j = 0;
+        nla_for_each_nested(channels,
+                    bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC], rem2) {
+            if (nla_parse(channel,
+                QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                nla_data(channels), nla_len(channels),
+                wlan_hdd_extscan_config_policy)) {
+                hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla_parse failed"));
+                goto fail;
+            }
+
+            /* Parse and fetch channel */
+            if (!channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL]) {
+                hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr channel failed"));
+                goto fail;
+            }
+            pReqMsg->buckets[bktIndex].channels[j].channel = nla_get_u32(
+                   channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL]);
+            hddLog(VOS_TRACE_LEVEL_INFO, FL("channel (%u)"),
+                         pReqMsg->buckets[bktIndex].channels[j].channel);
+
+            /* Parse and fetch dwell time */
+            if (!channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME]) {
+                hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr dwelltime failed"));
+                goto fail;
+            }
+            pReqMsg->buckets[bktIndex].channels[j].dwellTimeMs = nla_get_u32(
+                channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME]);
+            hddLog(VOS_TRACE_LEVEL_INFO, FL("Dwell time (%u ms)"),
+                     pReqMsg->buckets[bktIndex].channels[j].dwellTimeMs);
+
+            /* Parse and fetch channel spec passive */
+            if (!channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE]) {
+                hddLog(VOS_TRACE_LEVEL_ERROR,
+                                     FL("attr channel spec passive failed"));
+                goto fail;
+            }
+            pReqMsg->buckets[bktIndex].channels[j].passive = nla_get_u8(
+                   channel[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE]);
+            hddLog(VOS_TRACE_LEVEL_INFO, FL("Chnl spec passive (%u)"),
+                     pReqMsg->buckets[bktIndex].channels[j].passive);
+            j++;
+        }
+        i++;
+    }
+
+    status = sme_ExtScanStart(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                     FL("sme_ExtScanStart failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_stop(struct wiphy *wiphy,
+                                        struct wireless_dev *wdev,
+                                        void *data, int data_len)
+{
+    tpSirExtScanStopReqParams pReqMsg         = NULL;
+    struct net_device *dev                  = wdev->netdev;
+    hdd_adapter_t *pAdapter                 = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                  = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    eHalStatus status;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    status = sme_ExtScanStop(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                    FL("sme_ExtScanStop failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_reset_bssid_hotlist(struct wiphy *wiphy,
+                                        struct wireless_dev *wdev,
+                                        void *data, int data_len)
+{
+    tpSirExtScanResetBssidHotlistReqParams pReqMsg = NULL;
+    struct net_device *dev                       = wdev->netdev;
+    hdd_adapter_t *pAdapter                      = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                       = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    eHalStatus status;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    status = sme_ResetBssHotlist(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                          FL("sme_ResetBssHotlist failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+static int wlan_hdd_cfg80211_extscan_reset_significant_change(
+                                        struct wiphy *wiphy,
+                                        struct wireless_dev *wdev,
+                                        void *data, int data_len)
+{
+    tpSirExtScanResetSignificantChangeReqParams pReqMsg = NULL;
+    struct net_device *dev                            = wdev->netdev;
+    hdd_adapter_t *pAdapter                           = WLAN_HDD_GET_PRIV_PTR(dev);
+    hdd_context_t *pHddCtx                            = wiphy_priv(wiphy);
+    struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1];
+    eHalStatus status;
+
+    ENTER();
+
+    if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX,
+                    data, data_len,
+                    wlan_hdd_extscan_config_policy)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("Invalid ATTR"));
+        return -EINVAL;
+    }
+
+    pReqMsg = vos_mem_malloc(sizeof(*pReqMsg));
+    if (!pReqMsg) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("vos_mem_malloc failed"));
+        return -ENOMEM;
+    }
+
+    /* Parse and fetch request Id */
+    if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("attr request id failed"));
+        goto fail;
+    }
+
+    pReqMsg->requestId = nla_get_u32(
+              tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID]);
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Req Id (%d)"), pReqMsg->requestId);
+
+    pReqMsg->sessionId = pAdapter->sessionId;
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id (%d)"), pReqMsg->sessionId);
+
+    status = sme_ResetSignificantChange(pHddCtx->hHal, pReqMsg);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                   FL("sme_ResetSignificantChange failed(err=%d)"), status);
+        vos_mem_free(pReqMsg);
+        return -EINVAL;
+    }
+
+    return 0;
+
+fail:
+    vos_mem_free(pReqMsg);
+    return -EINVAL;
+}
+
+#endif /* FEATURE_WLAN_EXTSCAN */
 const struct wiphy_vendor_command hdd_wiphy_vendor_commands[] =
 {
     {
@@ -891,9 +1851,81 @@ const struct wiphy_vendor_command hdd_wiphy_vendor_commands[] =
                  WIPHY_VENDOR_CMD_NEED_NETDEV |
                  WIPHY_VENDOR_CMD_NEED_RUNNING,
         .doit = wlan_hdd_cfg80211_stats_ext_request
-    }
+    },
 #endif
-
+#ifdef FEATURE_WLAN_EXTSCAN
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_start
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_stop
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_VALID_CHANNELS,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV,
+        .doit = wlan_hdd_cfg80211_extscan_get_valid_channels
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_get_capabilities
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_get_cached_results
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_set_bssid_hotlist
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_reset_bssid_hotlist
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_set_significant_change
+    },
+    {
+        .info.vendor_id = QCA_NL80211_VENDOR_ID,
+        .info.subcmd = QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE,
+        .flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+                 WIPHY_VENDOR_CMD_NEED_NETDEV |
+                 WIPHY_VENDOR_CMD_NEED_RUNNING,
+        .doit = wlan_hdd_cfg80211_extscan_reset_significant_change
+    },
+#endif /* FEATURE_WLAN_EXTSCAN */
 };
 
 
@@ -3786,7 +4818,7 @@ done:
 
 #ifdef WLAN_FEATURE_LPSS
     vstatus = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-    while (NULL != pAdapterNode && VOS_STATUS_SUCCESS == status) {
+    while (NULL != pAdapterNode && VOS_STATUS_SUCCESS == vstatus) {
         pDataAdapter = pAdapterNode->pAdapter;
         if (pDataAdapter) {
             if (pDataAdapter->device_mode == WLAN_HDD_INFRA_STATION)
@@ -5296,13 +6328,6 @@ static int wlan_hdd_cfg80211_update_bss( struct wiphy *wiphy,
 }
 
 void
-hddPrintMacAddr(tCsrBssid macAddr, tANI_U8 logLevel)
-{
-    VOS_TRACE(VOS_MODULE_ID_HDD, logLevel,
-              MAC_ADDRESS_STR, MAC_ADDR_ARRAY(macAddr));
-} /****** end hddPrintMacAddr() ******/
-
-void
 hddPrintPmkId(tANI_U8 *pmkId, tANI_U8 logLevel)
 {
     VOS_TRACE(VOS_MODULE_ID_HDD, logLevel,
@@ -5312,18 +6337,6 @@ hddPrintPmkId(tANI_U8 *pmkId, tANI_U8 logLevel)
               pmkId[11], pmkId[12], pmkId[13], pmkId[14], pmkId[15]);
 } /****** end hddPrintPmkId() ******/
 
-//hddPrintMacAddr(tCsrBssid macAddr, tANI_U8 logLevel);
-//hddPrintMacAddr(macAddr, VOS_TRACE_LEVEL_FATAL);
-
-//void sirDumpBuf(tpAniSirGlobal pMac, tANI_U8 modId, tANI_U32 level, tANI_U8 *buf, tANI_U32 size);
-//sirDumpBuf(pMac, VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, pmkid, 16);
-
-#define dump_bssid(bssid) \
-    { \
-        hddLog(VOS_TRACE_LEVEL_INFO, "BSSID (MAC) address:\t"); \
-        hddPrintMacAddr(bssid, VOS_TRACE_LEVEL_INFO);\
-    }
-
 #define dump_pmkid(pMac, pmkid) \
     { \
         hddLog(VOS_TRACE_LEVEL_INFO, "PMKSA-ID:\t"); \
@@ -5354,7 +6367,8 @@ int wlan_hdd_cfg80211_pmksa_candidate_notify(
 
     if (eANI_BOOLEAN_TRUE == hdd_is_okc_mode_enabled(pHddCtx))
     {
-        dump_bssid(pRoamInfo->bssid);
+        hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pRoamInfo->bssid));
         cfg80211_pmksa_candidate_notify(dev, index,
                                     pRoamInfo->bssid, preauth, GFP_KERNEL);
     }
@@ -8867,7 +9881,8 @@ static int __wlan_hdd_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device
                     CSR_RSN_PMKID_SIZE);
             hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Reusing cache entry %d.",
                     __func__, j );
-            dump_bssid(pmksa->bssid);
+            hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pmksa->bssid));
             dump_pmkid(halHandle, pmksa->pmkid);
             break;
         }
@@ -8886,7 +9901,8 @@ static int __wlan_hdd_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device
                 CSR_RSN_PMKID_SIZE);
         hddLog(VOS_TRACE_LEVEL_DEBUG, "%s: Adding a new cache entry %d.",
                 __func__, pHddStaCtx->PMKIDCacheIndex );
-        dump_bssid(pmksa->bssid);
+        hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pmksa->bssid));
         dump_pmkid(halHandle, pmksa->pmkid);
         // Increment the HDD Local Cache index
         // The "i=0" doesn't work for the call to sme_RoamSetPMKIDCache() - LFR FIXME
@@ -9007,7 +10023,8 @@ static int __wlan_hdd_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device
                 status = -EINVAL;
              }
 
-             dump_bssid(pmksa->bssid);
+             hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pmksa->bssid));
              dump_pmkid(halHandle,pmksa->pmkid);
 
              break;
@@ -9020,7 +10037,8 @@ static int __wlan_hdd_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device
        hddLog(VOS_TRACE_LEVEL_FATAL,
               "%s: No such PMKSA entry existed " MAC_ADDRESS_STR,
               __func__, MAC_ADDR_ARRAY(pmksa->bssid));
-       dump_bssid(pmksa->bssid);
+       hddLog(VOS_TRACE_LEVEL_INFO, MAC_ADDRESS_STR,
+               MAC_ADDR_ARRAY(pmksa->bssid));
        dump_pmkid(halHandle, pmksa->pmkid);
        return -EINVAL;
     }
@@ -11300,6 +12318,969 @@ int wlan_hdd_cfg80211_set_ap_channel_width(struct wiphy *wiphy,
 }
 #endif
 
+#ifdef FEATURE_WLAN_EXTSCAN
+
+static void wlan_hdd_cfg80211_extscan_get_capabilities_ind(void *ctx,
+                                                           void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanCapabilitiesEvent pData =
+                    (tpSirExtScanCapabilitiesEvent) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                      EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                      QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CAPABILITIES_INDEX,
+                      GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Scan cache size (%u)", pData->scanCacheSize);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Scan buckets (%u)", pData->scanBuckets);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Max AP per scan (%u)", pData->maxApPerScan);
+    hddLog(VOS_TRACE_LEVEL_INFO, "maxRssiSampleSize (%u)",
+                                        pData->maxRssiSampleSize);
+    hddLog(VOS_TRACE_LEVEL_INFO, "maxScanReportingThreshold (%u)",
+                                        pData->maxScanReportingThreshold);
+    hddLog(VOS_TRACE_LEVEL_INFO, "maxHotlistAPs (%u)", pData->maxHotlistAPs);
+    hddLog(VOS_TRACE_LEVEL_INFO, "maxSignificantWifiChangeAPs (%u)",
+                                        pData->maxSignificantWifiChangeAPs);
+    hddLog(VOS_TRACE_LEVEL_INFO, "maxBsidHistoryEntries (%u)",
+                                        pData->maxBsidHistoryEntries);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+           pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status) ||
+        nla_put_u32(skb,
+          QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_CACHE_SIZE,
+           pData->scanCacheSize) ||
+        nla_put_u32(skb,
+           QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_BUCKETS,
+           pData->scanBuckets) ||
+        nla_put_u32(skb,
+         QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_AP_CACHE_PER_SCAN,
+         pData->maxApPerScan) ||
+        nla_put_u32(skb,
+          QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_RSSI_SAMPLE_SIZE,
+          pData->maxRssiSampleSize) ||
+        nla_put_u32(skb,
+       QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SCAN_REPORTING_THRESHOLD,
+       pData->maxScanReportingThreshold) ||
+        nla_put_u32(skb,
+           QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_HOTLIST_APS,
+           pData->maxHotlistAPs) ||
+        nla_put_u32(skb,
+        QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_SIGNIFICANT_WIFI_CHANGE_APS,
+        pData->maxSignificantWifiChangeAPs) ||
+      nla_put_u32(skb,
+      QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_CAPABILITIES_MAX_BSSID_HISTORY_ENTRIES,
+      pData->maxBsidHistoryEntries)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+static void wlan_hdd_cfg80211_extscan_start_rsp(void *ctx, void *pMsg)
+{
+    tpSirExtScanStartRspParams pData = (tpSirExtScanStartRspParams) pMsg;
+    hdd_context_t *pHddCtx         = (hdd_context_t *)ctx;
+    struct sk_buff *skb            = NULL;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                                 EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                                 QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_START_INDEX,
+                                 GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+static void wlan_hdd_cfg80211_extscan_stop_rsp(void *ctx, void *pMsg)
+{
+    tpSirExtScanStopRspParams pData = (tpSirExtScanStopRspParams) pMsg;
+    hdd_context_t *pHddCtx        = (hdd_context_t *)ctx;
+    struct sk_buff *skb           = NULL;
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                                 EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                                 QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_STOP_INDEX,
+                                 GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+static void wlan_hdd_cfg80211_extscan_set_bss_hotlist_rsp(void *ctx,
+                                                        void *pMsg)
+{
+    hdd_context_t *pHddCtx    = (hdd_context_t *)ctx;
+    struct sk_buff *skb       = NULL;
+    tpSirExtScanSetBssidHotListRspParams pData =
+                    (tpSirExtScanSetBssidHotListRspParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                     EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                     QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_BSSID_HOTLIST_INDEX,
+                     GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Status (%u)", pData->status);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+static void wlan_hdd_cfg80211_extscan_reset_bss_hotlist_rsp(void *ctx,
+                                                          void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanResetBssidHotlistRspParams pData =
+                    (tpSirExtScanResetBssidHotlistRspParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                   EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                   QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_BSSID_HOTLIST_INDEX,
+                   GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+static void wlan_hdd_cfg80211_extscan_set_signf_wifi_change_rsp(void *ctx,
+                                                              void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanSetSignificantChangeRspParams pData =
+                    (tpSirExtScanSetSignificantChangeRspParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SET_SIGNIFICANT_CHANGE_INDEX,
+                GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Status (%u)", pData->status);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+static void wlan_hdd_cfg80211_extscan_reset_signf_wifi_change_rsp(void *ctx,
+                                                                void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanResetSignificantChangeRspParams pData =
+                    (tpSirExtScanResetSignificantChangeRspParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+              EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+              QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_RESET_SIGNIFICANT_CHANGE_INDEX,
+              GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Status (%u)", pData->status);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_STATUS, pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+static void wlan_hdd_cfg80211_extscan_cached_results_ind(void *ctx,
+                                                       void *pMsg)
+{
+    hdd_context_t *pHddCtx = (hdd_context_t *)ctx;
+    struct sk_buff *skb    = NULL;
+    tANI_U32 i;
+    tpSirWifiScanResultEvent pData = (tpSirWifiScanResultEvent) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                    EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_GET_CACHED_RESULTS_INDEX,
+                    GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Num results (%u)", pData->numOfAps);
+    hddLog(VOS_TRACE_LEVEL_INFO, "More Data (%u)", pData->moreData);
+
+    for (i = 0; i < pData->numOfAps; i++) {
+        hddLog(VOS_TRACE_LEVEL_INFO, "[index=%d] Timestamp(0x%llX) "
+                              "Ssid (%s) "
+                              "Bssid (" MAC_ADDRESS_STR ") "
+                              "Channel (%u) "
+                              "Rssi (%u) "
+                              "RTT (%u) "
+                              "RTT_SD (%u) "
+                              "Beacon Period (%u) "
+                              "Capability (0x%x) "
+                              "Ie length (%d)",
+                              i,
+                              pData->ap[i].ts,
+                              pData->ap[i].ssid,
+                              MAC_ADDR_ARRAY(pData->ap[i].bssid),
+                              pData->ap[i].channel,
+                              pData->ap[i].rssi,
+                              pData->ap[i].rtt,
+                              pData->ap[i].rtt_sd,
+                              pData->ap[i].beaconPeriod,
+                              pData->ap[i].capability,
+                              pData->ap[i].ieLength);
+    }
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                    pData->requestId) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE,
+                    pData->numOfAps)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("put fail"));
+        goto fail;
+    }
+
+    if (pData->numOfAps) {
+        struct nlattr *aps;
+
+        aps = nla_nest_start(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_LIST);
+        if (!aps)
+            goto fail;
+
+        for (i = 0; i < pData->numOfAps; i++) {
+            struct nlattr *ap;
+
+            ap = nla_nest_start(skb, i);
+            if (!ap)
+                goto fail;
+
+            if (nla_put_u64(skb,
+                 QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_TIME_STAMP,
+                 pData->ap[i].ts) ||
+                nla_put(skb,
+                 QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_SSID,
+                 sizeof(pData->ap[i].ssid),
+                 pData->ap[i].ssid) ||
+                nla_put(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BSSID,
+                  sizeof(pData->ap[i].bssid),
+                  pData->ap[i].bssid) ||
+                nla_put_u32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CHANNEL,
+                  pData->ap[i].channel) ||
+                nla_put_s32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RSSI,
+                  pData->ap[i].rssi) ||
+                nla_put_u32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT,
+                  pData->ap[i].rtt) ||
+                nla_put_u32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT_SD,
+                  pData->ap[i].rtt_sd) ||
+                nla_put_u16(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BEACON_PERIOD,
+                  pData->ap[i].beaconPeriod) ||
+                nla_put_u16(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CAPABILITY,
+                  pData->ap[i].capability) ||
+                nla_put_u16(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_LENGTH,
+                  pData->ap[i].ieLength))
+                goto fail;
+
+                if (pData->ap[i].ieLength)
+                    if (nla_put(skb,
+                      QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_DATA,
+                      pData->ap[i].ieLength, pData->ap[i].ieData))
+                        goto fail;
+
+              nla_nest_end(skb, ap);
+        }
+        nla_nest_end(skb, aps);
+
+        if (nla_put_u8(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_MORE_DATA,
+                    pData->moreData))
+            goto fail;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+fail:
+    kfree_skb(skb);
+    return;
+
+}
+static void wlan_hdd_cfg80211_extscan_hotlist_match_ind(void *ctx,
+                                                      void *pMsg)
+{
+    tpSirWifiScanResultEvent pData = (tpSirWifiScanResultEvent) pMsg;
+    hdd_context_t *pHddCtx         = (hdd_context_t *)ctx;
+    struct sk_buff *skb            = NULL;
+    tANI_U32 i;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                      EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                      QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_AP_FOUND_INDEX,
+                      GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Num results (%u)", pData->numOfAps);
+    hddLog(VOS_TRACE_LEVEL_INFO, "More Data (%u)", pData->moreData);
+
+    for (i = 0; i < pData->numOfAps; i++) {
+        hddLog(VOS_TRACE_LEVEL_INFO, "[index=%d] Timestamp(0x%llX) "
+                              "Ssid (%s) "
+                              "Bssid (" MAC_ADDRESS_STR ") "
+                              "Channel (%u) "
+                              "Rssi (%d) "
+                              "RTT (%u) "
+                              "RTT_SD (%u)",
+                              i,
+                              pData->ap[i].ts,
+                              pData->ap[i].ssid,
+                              MAC_ADDR_ARRAY(pData->ap[i].bssid),
+                              pData->ap[i].channel,
+                              pData->ap[i].rssi,
+                              pData->ap[i].rtt,
+                              pData->ap[i].rtt_sd);
+    }
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                    pData->requestId) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE,
+                    pData->numOfAps)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("put fail"));
+        goto fail;
+    }
+
+    if (pData->numOfAps) {
+        struct nlattr *aps;
+
+        aps = nla_nest_start(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_LIST);
+        if (!aps)
+            goto fail;
+
+        for (i = 0; i < pData->numOfAps; i++) {
+            struct nlattr *ap;
+
+            ap = nla_nest_start(skb, i);
+            if (!ap)
+                goto fail;
+
+            if (nla_put_u64(skb,
+                   QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_TIME_STAMP,
+                    pData->ap[i].ts) ||
+                nla_put(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_SSID,
+                     sizeof(pData->ap[i].ssid),
+                     pData->ap[i].ssid) ||
+                nla_put(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BSSID,
+                     sizeof(pData->ap[i].bssid),
+                     pData->ap[i].bssid) ||
+                nla_put_u32(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CHANNEL,
+                     pData->ap[i].channel) ||
+                nla_put_s32(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RSSI,
+                     pData->ap[i].rssi) ||
+                nla_put_u32(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT,
+                     pData->ap[i].rtt) ||
+                nla_put_u32(skb,
+                     QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT_SD,
+                     pData->ap[i].rtt_sd))
+                goto fail;
+
+              nla_nest_end(skb, ap);
+        }
+        nla_nest_end(skb, aps);
+
+        if (nla_put_u8(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_MORE_DATA,
+                    pData->moreData))
+            goto fail;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+fail:
+    kfree_skb(skb);
+    return;
+
+}
+
+static void wlan_hdd_cfg80211_extscan_signif_wifi_change_results_ind(void *ctx,
+                                                                   void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tANI_U32 i, j;
+    tpSirWifiSignificantChangeEvent pData =
+                                     (tpSirWifiSignificantChangeEvent) pMsg;
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                    EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                    QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SIGNIFICANT_CHANGE_INDEX,
+                    GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Num results (%u)", pData->numResults);
+    hddLog(VOS_TRACE_LEVEL_INFO, "More Data (%u)", pData->moreData);
+
+    for (i = 0; i < pData->numResults; i++) {
+        hddLog(VOS_TRACE_LEVEL_INFO, "[index=%d] "
+                              "Bssid (" MAC_ADDRESS_STR ") "
+                              "Channel (%u) "
+                              "numOfRssi (%d)",
+                              i,
+                              MAC_ADDR_ARRAY(pData->ap[i]->bssid),
+                              pData->ap[i]->channel,
+                              pData->ap[i]->numOfRssi);
+        for (j = 0; j < pData->ap[i]->numOfRssi; j++)
+            hddLog(VOS_TRACE_LEVEL_INFO, "Rssi (%d)", pData->ap[i]->rssi[j]);
+    }
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                         pData->requestId) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE,
+                    pData->numResults)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("put fail"));
+        goto fail;
+    }
+
+    if (pData->numResults) {
+        struct nlattr *aps;
+
+        aps = nla_nest_start(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_LIST);
+        if (!aps)
+            goto fail;
+
+        for (i = 0; i < pData->numResults; i++) {
+            struct nlattr *ap;
+
+            ap = nla_nest_start(skb, i);
+            if (!ap)
+                goto fail;
+
+            if (nla_put(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_BSSID,
+                sizeof(tSirMacAddr), pData->ap[i]->bssid) ||
+                nla_put_u32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_CHANNEL,
+                pData->ap[i]->channel) ||
+                nla_put_u32(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_NUM_RSSI,
+                pData->ap[i]->numOfRssi) ||
+                nla_put(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SIGNIFICANT_CHANGE_RESULT_RSSI_LIST,
+                  sizeof(s32) * pData->ap[i]->numOfRssi, pData->ap[i]->rssi))
+                goto fail;
+
+              nla_nest_end(skb, ap);
+        }
+        nla_nest_end(skb, aps);
+
+        if (nla_put_u8(skb,
+                      QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_MORE_DATA,
+                      pData->moreData))
+            goto fail;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+fail:
+    kfree_skb(skb);
+    return;
+
+}
+
+static void wlan_hdd_cfg80211_extscan_full_scan_result_event(void *ctx,
+                                                           void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirWifiFullScanResultEvent pData =
+                    (tpSirWifiFullScanResultEvent) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                  EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                  QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_FULL_SCAN_RESULT_INDEX,
+                  GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "More Data (%u)", pData->moreData);
+    hddLog(VOS_TRACE_LEVEL_INFO, "AP Info: Timestamp(0x%llX) "
+                          "Ssid (%s) "
+                          "Bssid (" MAC_ADDRESS_STR ") "
+                          "Channel (%u) "
+                          "Rssi (%u) "
+                          "RTT (%u) "
+                          "RTT_SD (%u)",
+                          pData->ap.ts,
+                          pData->ap.ssid,
+                          MAC_ADDR_ARRAY(pData->ap.bssid),
+                          pData->ap.channel,
+                          pData->ap.rssi,
+                          pData->ap.rtt,
+                          pData->ap.rtt_sd);
+
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                    pData->requestId) ||
+        nla_put_u64(skb,
+                   QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_TIME_STAMP,
+                   pData->ap.ts) ||
+        nla_put(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_SSID,
+                    sizeof(pData->ap.ssid),
+                    pData->ap.ssid) ||
+        nla_put(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BSSID,
+                    sizeof(pData->ap.bssid),
+                    pData->ap.bssid) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CHANNEL,
+                    pData->ap.channel) ||
+        nla_put_s32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RSSI,
+                    pData->ap.rssi) ||
+        nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT,
+                    pData->ap.rtt) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_RTT_SD,
+                    pData->ap.rtt_sd) ||
+        nla_put_u16(skb,
+                QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_BEACON_PERIOD,
+                pData->ap.beaconPeriod) ||
+        nla_put_u16(skb,
+                  QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_CAPABILITY,
+                  pData->ap.capability) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_LENGTH,
+                    pData->ap.ieLength) ||
+        nla_put_u8(skb,
+                   QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_MORE_DATA,
+                   pData->moreData)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    if (pData->ap.ieLength) {
+        if (nla_put(skb,
+            QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_RESULT_IE_DATA,
+            pData->ap.ieLength, pData->ap.ieData))
+            goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+static void wlan_hdd_cfg80211_extscan_scan_res_available_event(void *ctx,
+                                                             void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanResultsAvailableIndParams pData =
+                    (tpSirExtScanResultsAvailableIndParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_RESULTS_AVAILABLE_INDEX,
+                GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+
+    hddLog(VOS_TRACE_LEVEL_INFO, "Req Id (%u)", pData->requestId);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Num results (%u)",
+                                  pData->numResultsAvailable);
+    if (nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_REQUEST_ID,
+                    pData->requestId) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_NUM_RESULTS_AVAILABLE,
+                    pData->numResultsAvailable)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+static void wlan_hdd_cfg80211_extscan_scan_progress_event(void *ctx,
+                                                          void *pMsg)
+{
+    hdd_context_t *pHddCtx  = (hdd_context_t *)ctx;
+    struct sk_buff *skb     = NULL;
+    tpSirExtScanOnScanEventIndParams pData =
+                                   (tpSirExtScanOnScanEventIndParams) pMsg;
+
+    ENTER();
+
+    if (wlan_hdd_validate_context(pHddCtx) || !pData) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid "
+                                         "or pData(%p) is null"), pData);
+        return;
+    }
+
+    skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
+                            EXTSCAN_EVENT_BUF_SIZE + NLMSG_HDRLEN,
+                            QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_SCAN_EVENT_INDEX,
+                            GFP_KERNEL);
+
+    if (!skb) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+                  FL("cfg80211_vendor_event_alloc failed"));
+        return;
+    }
+    hddLog(VOS_TRACE_LEVEL_INFO, "Scan event type (%u)", pData->scanEventType);
+    hddLog(VOS_TRACE_LEVEL_INFO, "Scan event status (%u)", pData->status);
+
+    if (nla_put_u8(skb, QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_EVENT_TYPE,
+                   pData->scanEventType) ||
+        nla_put_u32(skb,
+                    QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_SCAN_EVENT_STATUS,
+                    pData->status)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("nla put fail"));
+        goto nla_put_failure;
+    }
+
+    cfg80211_vendor_event(skb, GFP_KERNEL);
+    return;
+
+nla_put_failure:
+    kfree_skb(skb);
+    return;
+}
+
+
+void wlan_hdd_cfg80211_extscan_callback(void *ctx, const tANI_U16 evType,
+                                      void *pMsg)
+{
+    hdd_context_t *pHddCtx = (hdd_context_t *)ctx;
+
+    if (wlan_hdd_validate_context(pHddCtx)) {
+        hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is invalid"
+                                         "Received event (%d)"), evType);
+        return;
+    }
+
+    hddLog(VOS_TRACE_LEVEL_INFO, FL("Rcvd Event (%d)"), evType);
+
+    switch (evType) {
+    case eSIR_EXTSCAN_START_RSP:
+            wlan_hdd_cfg80211_extscan_start_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_STOP_RSP:
+            wlan_hdd_cfg80211_extscan_stop_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_CACHED_RESULTS_RSP:
+             /* There is no need to send this response to upper layer
+                Just log the message */
+             hddLog(VOS_TRACE_LEVEL_INFO,
+                   FL("Rcvd eSIR_EXTSCAN_CACHED_RESULTS_RSP"));
+            break;
+
+    case eSIR_EXTSCAN_SET_BSSID_HOTLIST_RSP:
+            wlan_hdd_cfg80211_extscan_set_bss_hotlist_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_RESET_BSSID_HOTLIST_RSP:
+            wlan_hdd_cfg80211_extscan_reset_bss_hotlist_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_SET_SIGNIFICANT_WIFI_CHANGE_RSP:
+            wlan_hdd_cfg80211_extscan_set_signf_wifi_change_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_RESET_SIGNIFICANT_WIFI_CHANGE_RSP:
+            wlan_hdd_cfg80211_extscan_reset_signf_wifi_change_rsp(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_GET_CAPABILITIES_IND:
+            wlan_hdd_cfg80211_extscan_get_capabilities_ind(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_HOTLIST_MATCH_IND:
+            wlan_hdd_cfg80211_extscan_hotlist_match_ind(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_SIGNIFICANT_WIFI_CHANGE_RESULTS_IND:
+            wlan_hdd_cfg80211_extscan_signif_wifi_change_results_ind(ctx,
+                                                                     pMsg);
+            break;
+
+    case eSIR_EXTSCAN_CACHED_RESULTS_IND:
+            wlan_hdd_cfg80211_extscan_cached_results_ind(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_SCAN_RES_AVAILABLE_IND:
+            wlan_hdd_cfg80211_extscan_scan_res_available_event(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_FULL_SCAN_RESULT_IND:
+            wlan_hdd_cfg80211_extscan_full_scan_result_event(ctx, pMsg);
+            break;
+
+    case eSIR_EXTSCAN_SCAN_PROGRESS_EVENT_IND:
+            wlan_hdd_cfg80211_extscan_scan_progress_event(ctx, pMsg);
+            break;
+
+    default:
+            hddLog(VOS_TRACE_LEVEL_ERROR,
+                   FL("Unknown event type (%u)"), evType);
+            break;
+    }
+}
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 /* cfg80211_ops */
 static struct cfg80211_ops wlan_hdd_cfg80211_ops =
 {
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index f48713aa9434..8a41158b8f77 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -803,6 +803,25 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
                       "The value of dfs_cac_block_tx[%d] for ApCtx[%p]",
                       pHddApCtx->dfs_cac_block_tx, pHddApCtx);
 
+            if ((NV_CHANNEL_DFS ==
+                vos_nv_getChannelEnabledState(pHddApCtx->operatingChannel)) &&
+                (pHddCtx->cfg_ini->IsSapDfsChSifsBurstEnabled == 0))
+            {
+
+                VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
+                           "%s: Setting SIFS Burst disable for DFS channel %d",
+                            __func__, pHddApCtx->operatingChannel);
+
+                if (process_wma_set_command((int)pHostapdAdapter->sessionId,
+                                            (int)WMI_PDEV_PARAM_BURST_ENABLE,
+                                             0, PDEV_CMD))
+                {
+                    VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                               "%s: Failed to Set SIFS Burst for DFS channel %d",
+                                __func__, pHddApCtx->operatingChannel);
+                }
+            }
+
             //Fill the params for sending IWEVCUSTOM Event with SOFTAP.enabled
             startBssEvent = "SOFTAP.enabled";
             memset(&we_custom_start_event, '\0', sizeof(we_custom_start_event));
@@ -2912,227 +2931,6 @@ static iw_softap_ap_stats(struct net_device *dev,
     return 0;
 }
 
-int
-static iw_softap_commit(struct net_device *dev,
-                        struct iw_request_info *info,
-                        union iwreq_data *wrqu, char *extra)
-{
-    VOS_STATUS vos_status = VOS_STATUS_SUCCESS;
-    hdd_adapter_t *pHostapdAdapter = (netdev_priv(dev));
-    hdd_hostapd_state_t *pHostapdState;
-    v_CONTEXT_t pVosContext = (WLAN_HDD_GET_CTX(pHostapdAdapter))->pvosContext;
-    tpWLAN_SAPEventCB pSapEventCallback;
-    tsap_Config_t *pConfig;
-    s_CommitConfig_t *pCommitConfig;
-    struct qc_mac_acl_entry *acl_entry = NULL;
-    v_SINT_t i = 0, num_mac = 0;
-    v_U32_t status = 0;
-    eCsrAuthType RSNAuthType;
-    eCsrEncryptionType RSNEncryptType;
-    eCsrEncryptionType mcRSNEncryptType;
-    v_BOOL_t MFPCapable = VOS_FALSE;
-    v_BOOL_t MFPRequired = VOS_FALSE;
-
-    pHostapdState = WLAN_HDD_GET_HOSTAP_STATE_PTR(pHostapdAdapter);
-    pCommitConfig = (s_CommitConfig_t *)extra;
-
-    pConfig = kmalloc(sizeof(tsap_Config_t), GFP_KERNEL);
-    if(NULL == pConfig) {
-        hddLog(LOGE, FL("VOS unable to allocate memory"));
-        return -ENOMEM;
-    }
-    pConfig->beacon_int =  pCommitConfig->beacon_int;
-    pConfig->channel = pCommitConfig->channel;
-
-    /*Protection parameter to enable or disable*/
-    pConfig->protEnabled = (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->apProtEnabled;
-    pConfig->dtim_period = pCommitConfig->dtim_period;
-    switch(pCommitConfig->hw_mode )
-    {
-        case eQC_DOT11_MODE_11A:
-        pConfig->SapHw_mode = eSAP_DOT11_MODE_11a;
-            break;
-        case eQC_DOT11_MODE_11B:
-        pConfig->SapHw_mode = eSAP_DOT11_MODE_11b;
-            break;
-        case eQC_DOT11_MODE_11G:
-        pConfig->SapHw_mode = eSAP_DOT11_MODE_11g;
-            break;
-
-        case eQC_DOT11_MODE_11N:
-        pConfig->SapHw_mode = eSAP_DOT11_MODE_11n;
-            break;
-        case eQC_DOT11_MODE_11G_ONLY:
-            pConfig->SapHw_mode = eSAP_DOT11_MODE_11g_ONLY;
-            break;
-        case eQC_DOT11_MODE_11N_ONLY:
-            pConfig->SapHw_mode = eSAP_DOT11_MODE_11n_ONLY;
-            break;
-        default:
-        pConfig->SapHw_mode = eSAP_DOT11_MODE_11n;
-            break;
-
-    }
-
-    pConfig->ieee80211d = pCommitConfig->qcsap80211d;
-    vos_mem_copy(pConfig->countryCode, pCommitConfig->countryCode, 3);
-    if(pCommitConfig->authType == eQC_AUTH_TYPE_SHARED_KEY)
-        pConfig->authType = eSAP_SHARED_KEY;
-    else if(pCommitConfig->authType == eQC_AUTH_TYPE_OPEN_SYSTEM)
-        pConfig->authType = eSAP_OPEN_SYSTEM;
-    else
-        pConfig->authType = eSAP_AUTO_SWITCH;
-
-    pConfig->privacy = pCommitConfig->privacy;
-    (WLAN_HDD_GET_AP_CTX_PTR(pHostapdAdapter))->uPrivacy = pCommitConfig->privacy;
-    pConfig->wps_state = pCommitConfig->wps_state;
-    pConfig->fwdWPSPBCProbeReq  = 1; // Forward WPS PBC probe request frame up
-    pConfig->RSNWPAReqIELength = pCommitConfig->RSNWPAReqIELength;
-    if(pConfig->RSNWPAReqIELength < sizeof(pConfig->RSNWPAReqIE)){
-        memcpy(&pConfig->RSNWPAReqIE[0], &pCommitConfig->RSNWPAReqIE[0],
-                                            pConfig->RSNWPAReqIELength);
-        if ((pConfig->RSNWPAReqIE[0] == DOT11F_EID_RSN) ||
-            (pConfig->RSNWPAReqIE[0] == DOT11F_EID_WPA)) {
-            // The actual processing may eventually be more extensive than this.
-            // Right now, just consume any PMKIDs that are  sent in by the app.
-            status = hdd_softap_unpackIE(
-                                  vos_get_context( VOS_MODULE_ID_PE, pVosContext),
-                                  &RSNEncryptType,
-                                  &mcRSNEncryptType,
-                                  &RSNAuthType,
-                                  &MFPCapable,
-                                  &MFPRequired,
-                                  pConfig->RSNWPAReqIE[1]+2,
-                                  pConfig->RSNWPAReqIE );
-
-            if( VOS_STATUS_SUCCESS == status )
-            {
-                 // Now copy over all the security attributes you have parsed out
-                 //TODO: Need to handle mixed mode
-                 pConfig->RSNEncryptType = RSNEncryptType; // Use the cipher type in the RSN IE
-                 pConfig->mcRSNEncryptType = mcRSNEncryptType;
-                 hddLog( LOG1, FL("CSR AuthType = %d, EncryptionType = %d mcEncryptionType = %d"),
-                                  RSNAuthType, RSNEncryptType, mcRSNEncryptType);
-             }
-        }
-    }
-    else
-    {
-        /* If no RSNIE, set encrypt type to NONE*/
-        pConfig->RSNEncryptType = eCSR_ENCRYPT_TYPE_NONE;
-        pConfig->mcRSNEncryptType =  eCSR_ENCRYPT_TYPE_NONE;
-        hddLog( LOG1, FL("EncryptionType = %d mcEncryptionType = %d"),
-                         pConfig->RSNEncryptType, pConfig->mcRSNEncryptType);
-    }
-
-    if (pConfig->RSNWPAReqIELength > QCSAP_MAX_OPT_IE) {
-        hddLog(LOGE, FL("RSNWPAReqIELength: %d too large"), pConfig->RSNWPAReqIELength);
-        kfree(pConfig);
-        return -EIO;
-    }
-
-    pConfig->SSIDinfo.ssidHidden = pCommitConfig->SSIDinfo.ssidHidden;
-    pConfig->SSIDinfo.ssid.length = pCommitConfig->SSIDinfo.ssid.length;
-    vos_mem_copy(pConfig->SSIDinfo.ssid.ssId, pCommitConfig->SSIDinfo.ssid.ssId, pConfig->SSIDinfo.ssid.length);
-    vos_mem_copy(pConfig->self_macaddr.bytes, pHostapdAdapter->macAddressCurrent.bytes, sizeof(v_MACADDR_t));
-
-    pConfig->SapMacaddr_acl = pCommitConfig->qc_macaddr_acl;
-
-    // ht_capab is not what the name conveys,this is used for protection bitmap
-    pConfig->ht_capab = (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->apProtection;
-
-    if (pCommitConfig->num_accept_mac > MAX_ACL_MAC_ADDRESS)
-        num_mac = pConfig->num_accept_mac = MAX_ACL_MAC_ADDRESS;
-    else
-        num_mac = pConfig->num_accept_mac = pCommitConfig->num_accept_mac;
-    acl_entry = pCommitConfig->accept_mac;
-    for (i = 0; i < num_mac; i++)
-    {
-        vos_mem_copy(&pConfig->accept_mac[i], acl_entry->addr, sizeof(v_MACADDR_t));
-        acl_entry++;
-    }
-    if (pCommitConfig->num_deny_mac > MAX_ACL_MAC_ADDRESS)
-        num_mac = pConfig->num_deny_mac = MAX_ACL_MAC_ADDRESS;
-    else
-        num_mac = pConfig->num_deny_mac = pCommitConfig->num_deny_mac;
-    acl_entry = pCommitConfig->deny_mac;
-    for (i = 0; i < num_mac; i++)
-    {
-        vos_mem_copy(&pConfig->deny_mac[i], acl_entry->addr, sizeof(v_MACADDR_t));
-        acl_entry++;
-    }
-    //Uapsd Enabled Bit
-    pConfig->UapsdEnable =  (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->apUapsdEnabled;
-    //Enable OBSS protection
-    pConfig->obssProtEnabled = (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->apOBSSProtEnabled;
-    (WLAN_HDD_GET_AP_CTX_PTR(pHostapdAdapter))->apDisableIntraBssFwd = (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->apDisableIntraBssFwd;
-
-    hddLog(LOGW, FL("SOftAP macaddress : "MAC_ADDRESS_STR), MAC_ADDR_ARRAY(pHostapdAdapter->macAddressCurrent.bytes));
-    hddLog(LOGW,FL("ssid =%s, beaconint=%d, channel=%d"),
-                    pConfig->SSIDinfo.ssid.ssId,
-                    (int)pConfig->beacon_int, (int)pConfig->channel);
-    hddLog(LOGW,FL("hw_mode=%x, privacy=%d, authType=%d"),
-                    pConfig->SapHw_mode, pConfig->privacy, pConfig->authType);
-    hddLog(LOGW,FL("RSN/WPALen=%d, Uapsd = %d"),
-                    (int)pConfig->RSNWPAReqIELength, pConfig->UapsdEnable);
-    hddLog(LOGW,FL("ProtEnabled = %d, OBSSProtEnabled = %d, DisableIntraBssFwd = %d"),
-                    pConfig->protEnabled, pConfig->obssProtEnabled,
-                    (WLAN_HDD_GET_AP_CTX_PTR(pHostapdAdapter))->apDisableIntraBssFwd);
-
-    pSapEventCallback = hdd_hostapd_SAPEventCB;
-    pConfig->persona = pHostapdAdapter->device_mode;
-
-#ifdef WLAN_FEATURE_MBSSID
-    vos_status = WLANSAP_StartBss(WLAN_HDD_GET_SAP_CTX_PTR(pHostapdAdapter), pSapEventCallback, pConfig,(v_PVOID_t)dev);
-#else
-    vos_status = WLANSAP_StartBss(pVosContext, pSapEventCallback, pConfig,(v_PVOID_t)dev);
-#endif
-    if (!VOS_IS_STATUS_SUCCESS(vos_status))
-    {
-           hddLog(LOGE,FL("SAP Start Bss fail"));
-    }
-
-    kfree(pConfig);
-
-    hddLog(LOG1, FL("Waiting for Scan to complete(auto mode) and BSS to start"));
-    vos_status = vos_wait_single_event(&pHostapdState->vosEvent, 10000);
-
-    if (!VOS_IS_STATUS_SUCCESS(vos_status))
-    {
-       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, ("ERROR: HDD vos wait for single_event failed!!"));
-       VOS_ASSERT(0);
-    }
-
-    pHostapdState->bCommit = TRUE;
-    if(pHostapdState->vosStatus)
-    {
-       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-                 FL("pHostapdState->vosStatus: %d"), pHostapdState->vosStatus);
-       return -EIO;
-    }
-    else
-    {
-        hdd_context_t     *pHddCtx = NULL;
-        VOS_STATUS         status  = VOS_STATUS_SUCCESS;
-
-        pHddCtx = WLAN_HDD_GET_CTX(pHostapdAdapter);
-        status = wlan_hdd_validate_context(pHddCtx);
-
-        if (0 != status) {
-            hddLog(VOS_TRACE_LEVEL_ERROR, FL("HDD context is not valid"));
-            return status;
-        }
-
-        set_bit(SOFTAP_BSS_STARTED, &pHostapdAdapter->event_flags);
-        wlan_hdd_incr_active_session(pHddCtx, pHostapdAdapter->device_mode);
-#ifdef WLAN_FEATURE_MBSSID
-        WLANSAP_Update_WpsIe ( WLAN_HDD_GET_SAP_CTX_PTR(pHostapdAdapter) );
-#else
-        WLANSAP_Update_WpsIe ( pVosContext );
-#endif
-        return 0;
-    }
-}
 static
 int iw_softap_setmlme(struct net_device *dev,
                         struct iw_request_info *info,
@@ -4748,8 +4546,6 @@ static const struct iw_priv_args hostapd_private_args[] = {
   { QCASAP_GET_DFS_NOL, 0,
       IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,    "getdfsnol" },
 
-  { QCSAP_IOCTL_COMMIT,
-      IW_PRIV_TYPE_BYTE | sizeof(struct s_CommitConfig) | IW_PRIV_SIZE_FIXED, 0, "commit" },
   { QCSAP_IOCTL_SETMLME,
       IW_PRIV_TYPE_BYTE | sizeof(struct sQcSapreq_mlme)| IW_PRIV_SIZE_FIXED, 0, "setmlme" },
   { QCSAP_IOCTL_GET_STAWPAIE,
@@ -4862,7 +4658,6 @@ static const struct iw_priv_args hostapd_private_args[] = {
 static const iw_handler hostapd_private[] = {
    [QCSAP_IOCTL_SETPARAM - SIOCIWFIRSTPRIV] = iw_softap_setparam,  //set priv ioctl
    [QCSAP_IOCTL_GETPARAM - SIOCIWFIRSTPRIV] = iw_softap_getparam,  //get priv ioctl
-   [QCSAP_IOCTL_COMMIT   - SIOCIWFIRSTPRIV] = iw_softap_commit, //get priv ioctl
    [QCSAP_IOCTL_SETMLME  - SIOCIWFIRSTPRIV] = iw_softap_setmlme,
    [QCSAP_IOCTL_GET_STAWPAIE - SIOCIWFIRSTPRIV] = iw_get_genie, //get station genIE
    [QCSAP_IOCTL_SETWPAIE - SIOCIWFIRSTPRIV] = iw_softap_setwpsie,
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 3360e2808441..9a4fa0671534 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -12007,6 +12007,10 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
 #ifdef WLAN_FEATURE_STATS_EXT
    wlan_hdd_cfg80211_stats_ext_init(pHddCtx);
 #endif
+#ifdef FEATURE_WLAN_EXTSCAN
+    sme_ExtScanRegisterCallback(pHddCtx->hHal,
+                                wlan_hdd_cfg80211_extscan_callback);
+#endif /* FEATURE_WLAN_EXTSCAN */
 
 #ifdef WLAN_FEATURE_LPSS
    wlan_hdd_send_status_pkg(pAdapter, NULL, 1, 0);
diff --git a/CORE/HDD/src/wlan_hdd_p2p.c b/CORE/HDD/src/wlan_hdd_p2p.c
index 64572fb0480e..6a556257a130 100644
--- a/CORE/HDD/src/wlan_hdd_p2p.c
+++ b/CORE/HDD/src/wlan_hdd_p2p.c
@@ -985,10 +985,6 @@ int wlan_hdd_mgmt_tx( struct wiphy *wiphy, struct net_device *dev,
     tActionFrmType actionFrmType;
     bool noack = 0;
     int status;
-#ifdef WLAN_FEATURE_11W
-    tANI_U8 *pTxFrmBuf = (tANI_U8 *) buf; // For SA Query, we have to set protect bit
-#endif
-
     hdd_adapter_t *goAdapter;
 
      MTRACE(vos_trace(VOS_MODULE_ID_HDD,
@@ -1274,17 +1270,7 @@ int wlan_hdd_mgmt_tx( struct wiphy *wiphy, struct net_device *dev,
                 hddLog(LOG1, "%s: HDD_GO_NEG_REQ_ACK_PENDING", __func__);
             }
         }
-#ifdef WLAN_FEATURE_11W
-        if ((type == SIR_MAC_MGMT_FRAME) &&
-                (subType == SIR_MAC_MGMT_ACTION) &&
-                (buf[WLAN_HDD_PUBLIC_ACTION_FRAME_OFFSET] == WLAN_HDD_SA_QUERY_ACTION_FRAME))
-        {
-            VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-                     "%s: Calling sme_sendAction. For Category %s", __func__, "SA Query");
-            // Since this is an SA Query Action Frame, we have to protect it
-            WLAN_HDD_SET_WEP_FRM_FC(pTxFrmBuf[1]);
-        }
-#endif
+
         if (eHAL_STATUS_SUCCESS !=
                sme_sendAction( WLAN_HDD_GET_HAL_CTX(pAdapter),
                                sessionId, buf, len, extendedWait, noack))
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 9b694085c035..046a3aea9a3b 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -7412,14 +7412,16 @@ static int iw_setnone_getnone(struct net_device *dev, struct iw_request_info *in
             WLANTL_TLDebugMessage(VOS_TRUE);
             break;
         }
-        case  WE_SET_REASSOC_TRIGGER:
+        case WE_SET_REASSOC_TRIGGER:
         {
             hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
-            tpAniSirGlobal pMac = WLAN_HDD_GET_HAL_CTX(pAdapter);
+            tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
             v_U32_t roamId = 0;
             tCsrRoamModifyProfileFields modProfileFields;
-            sme_GetModifyProfileFields(pMac, pAdapter->sessionId, &modProfileFields);
-            sme_RoamReassoc(pMac, pAdapter->sessionId, NULL, modProfileFields, &roamId, 1);
+            sme_GetModifyProfileFields(hHal, pAdapter->sessionId,
+                                       &modProfileFields);
+            sme_RoamReassoc(hHal, pAdapter->sessionId,
+                            NULL, modProfileFields, &roamId, 1);
             return 0;
         }
 
diff --git a/CORE/MAC/inc/qwlan_version.h b/CORE/MAC/inc/qwlan_version.h
index 6f1f70b0c4a9..3ae792a3c5bb 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            131
+#define QWLAN_VERSION_BUILD            132
 
-#define QWLAN_VERSIONSTR               "1.0.0.131"
+#define QWLAN_VERSIONSTR               "1.0.0.132"
 
 #ifdef QCA_WIFI_2_0
 
diff --git a/CORE/MAC/inc/sirApi.h b/CORE/MAC/inc/sirApi.h
index 56f3e46a3901..35e44230876b 100644
--- a/CORE/MAC/inc/sirApi.h
+++ b/CORE/MAC/inc/sirApi.h
@@ -139,6 +139,40 @@ typedef tANI_U8 tSirVersionString[SIR_VERSION_STRING_LEN];
 #define PERIODIC_TX_PTRN_MAX_SIZE 1536
 #define MAXNUM_PERIODIC_TX_PTRNS 6
 
+
+#ifdef FEATURE_WLAN_EXTSCAN
+
+#define WLAN_EXTSCAN_MAX_CHANNELS                 16
+#define WLAN_EXTSCAN_MAX_BUCKETS                  16
+#define WLAN_EXTSCAN_MAX_HOTLIST_APS              128
+#define WLAN_EXTSCAN_MAX_SIGNIFICANT_CHANGE_APS   64
+
+typedef enum
+{
+    eSIR_EXTSCAN_INVALID,
+    eSIR_EXTSCAN_START_RSP,
+    eSIR_EXTSCAN_STOP_RSP,
+    eSIR_EXTSCAN_CACHED_RESULTS_RSP,
+    eSIR_EXTSCAN_SET_BSSID_HOTLIST_RSP,
+    eSIR_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
+    eSIR_EXTSCAN_SET_SIGNIFICANT_WIFI_CHANGE_RSP,
+    eSIR_EXTSCAN_RESET_SIGNIFICANT_WIFI_CHANGE_RSP,
+
+    eSIR_EXTSCAN_GET_CAPABILITIES_IND,
+    eSIR_EXTSCAN_HOTLIST_MATCH_IND,
+    eSIR_EXTSCAN_SIGNIFICANT_WIFI_CHANGE_RESULTS_IND,
+    eSIR_EXTSCAN_CACHED_RESULTS_IND,
+    eSIR_EXTSCAN_SCAN_RES_AVAILABLE_IND,
+    eSIR_EXTSCAN_SCAN_PROGRESS_EVENT_IND,
+    eSIR_EXTSCAN_FULL_SCAN_RESULT_IND,
+
+    /* Keep this last */
+    eSIR_EXTSCAN_CALLBACK_TYPE_MAX,
+} tSirExtScanCallbackType;
+
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 enum eSirHostMsgTypes
 {
     SIR_HAL_APP_SETUP_NTF = SIR_HAL_HOST_MSG_START,
@@ -5001,4 +5035,335 @@ typedef struct
 
 #endif
 
+#ifdef FEATURE_WLAN_EXTSCAN
+
+typedef enum
+{
+    WIFI_BAND_UNSPECIFIED,
+    WIFI_BAND_BG             = 1,    /* 2.4 GHz */
+    WIFI_BAND_A              = 2,    /* 5 GHz without DFS */
+    WIFI_BAND_ABG            = 3,    /* 2.4 GHz + 5 GHz; no DFS */
+    WIFI_BAND_A_DFS_ONLY     = 4,    /* 5 GHz DFS only */
+    /* 5 is reserved */
+    WIFI_BAND_A_WITH_DFS     = 6,    /* 5 GHz with DFS */
+    WIFI_BAND_ABG_WITH_DFS   = 7,    /* 2.4 GHz + 5 GHz with DFS */
+
+    /* Keep it last */
+    WIFI_BAND_MAX
+} tWifiBand;
+
+/* wifi scan related events */
+typedef enum
+{
+   WIFI_SCAN_BUFFER_FULL,
+   WIFI_SCAN_COMPLETE,
+} tWifiScanEventType;
+
+typedef struct
+{
+   tSirMacAddr    bssid;
+
+   /* Low threshold */
+   tANI_S32       low;
+
+   /* High threshold */
+   tANI_S32       high;
+
+   /* Frequency in MHz*/
+   tANI_U32       channel;
+} tSirAPThresholdParam, *tpSirAPThresholdParam;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U8     sessionId;
+} tSirGetExtScanCapabilitiesReqParams, *tpSirGetExtScanCapabilitiesReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+
+    tANI_U32    scanCacheSize;
+    tANI_U32    scanBuckets;
+    tANI_U32    maxApPerScan;
+    tANI_U32    maxRssiSampleSize;
+    tANI_U32    maxScanReportingThreshold;
+
+    tANI_U32    maxHotlistAPs;
+    tANI_U32    maxSignificantWifiChangeAPs;
+
+    tANI_U32    maxBsidHistoryEntries;
+} tSirExtScanCapabilitiesEvent, *tpSirExtScanCapabilitiesEvent;
+
+
+typedef struct
+{
+    tANI_U32      requestId;
+    tANI_U8       sessionId;
+
+    /*
+     * 1 - return cached results and flush it
+     * 0 - return cached results and do not flush
+     */
+    tANI_BOOLEAN  flush;
+} tSirExtScanGetCachedResultsReqParams, *tpSirExtScanGetCachedResultsReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanGetCachedResultsRspParams, *tpSirExtScanGetCachedResultsRspParams;
+
+typedef struct
+{
+    /* Time of discovery */
+    tANI_U64      ts;
+
+    /* Null terminated SSID */
+    tANI_U8       ssid[SIR_MAC_MAX_SSID_LENGTH+1];
+
+    tSirMacAddr   bssid;
+
+    /* Frequency in MHz*/
+    tANI_U32      channel;
+
+    /* RSSI in dBm */
+    tANI_S32      rssi;
+
+    /* RTT in nanoseconds */
+    tANI_U32      rtt;
+
+    /* Standard deviation in rtt */
+    tANI_U32      rtt_sd;
+
+    /* Period advertised in the beacon */
+    tANI_U16      beaconPeriod;
+
+    /* Capabilities advertised in the beacon */
+    tANI_U16      capability;
+
+    tANI_U16      ieLength;
+
+    tANI_U8       ieData[];
+} tSirWifiScanResult, *tpSirWifiScanResult;
+
+typedef struct
+{
+    tANI_U32             requestId;
+
+    tANI_U32             numOfAps;
+
+    /*
+     * 0 - for last fragment
+     * 1 - still more fragment(s) coming
+     */
+    tANI_BOOLEAN         moreData;
+    tSirWifiScanResult   ap[];
+} tSirWifiScanResultEvent, *tpSirWifiScanResultEvent;
+
+/*
+ * Reported when each probe response is received, if reportEvents
+ * enabled in tSirWifiScanCmdReqParams
+ */
+typedef struct
+{
+    tANI_U32               requestId;
+
+    /*
+     * 0 - for last fragment
+     * 1 - still more fragment(s) coming
+     */
+    tANI_BOOLEAN           moreData;
+    tSirWifiScanResult     ap;
+} tSirWifiFullScanResultEvent, *tpSirWifiFullScanResultEvent;
+
+
+typedef struct
+{
+    /* Frequency in MHz*/
+    tANI_U32      channel;
+
+    tANI_U32      dwellTimeMs;
+
+    /* 0 => active
+       1 => passive scan; ignored for DFS */
+    tANI_BOOLEAN  passive;
+
+    tANI_U8       chnlClass;
+} tSirWifiScanChannelSpec, *tpSirWifiScanChannelSpec;
+
+typedef struct
+{
+    /* Bucket index, 0 based */
+    tANI_U8       bucket;
+
+    /* when UNSPECIFIED, use channel list */
+    tWifiBand     band;
+
+    /*
+     * Desired period, in millisecond; if this is too
+     * low, the firmware should choose to generate results as fast as
+     * it can instead of failing the command byte
+     */
+    tANI_U32      period;
+
+    /*
+     * 0 => normal reporting (reporting rssi history
+     * only, when rssi history buffer is % full)
+     * 1 => same as 0 + report a scan completion event after scanning
+     * this bucket
+     * 2 => same as 1 + forward scan results (beacons/probe responses + IEs)
+     * in real time to HAL
+     */
+    tANI_U32      reportEvents;
+
+    tANI_U32      numChannels;
+
+    /*
+     * Channels to scan; these may include DFS channels
+     */
+    tSirWifiScanChannelSpec channels[WLAN_EXTSCAN_MAX_CHANNELS];
+} tSirWifiScanBucketSpec, *tpSirWifiScanBucketSpec;
+
+typedef struct
+{
+    /* Base timer period */
+    tANI_U32                basePeriod;
+    tANI_U32                maxAPperScan;
+
+    /* in %, when buffer is this much full, wake up host */
+    tANI_U32                reportThreshold;
+    tANI_U32                requestId;
+    tANI_U8                 sessionId;
+
+    tANI_U32                numBuckets;
+    tSirWifiScanBucketSpec  buckets[WLAN_EXTSCAN_MAX_BUCKETS];
+} tSirWifiScanCmdReqParams, *tpSirWifiScanCmdReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanStartRspParams, *tpSirExtScanStartRspParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U8     sessionId;
+} tSirExtScanStopReqParams, *tpSirExtScanStopReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanStopRspParams, *tpSirExtScanStopRspParams;
+
+typedef struct
+{
+    tANI_U32               requestId;
+    tANI_U8                sessionId;
+
+    /* Number of hotlist APs */
+    tANI_U32               numAp;
+    tSirAPThresholdParam   ap[WLAN_EXTSCAN_MAX_HOTLIST_APS];
+} tSirExtScanSetBssidHotListReqParams, *tpSirExtScanSetBssidHotListReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanSetBssidHotListRspParams, *tpSirExtScanSetBssidHotListRspParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U8     sessionId;
+} tSirExtScanResetBssidHotlistReqParams,
+  *tpSirExtScanResetBssidHotlistReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanResetBssidHotlistRspParams,
+  *tpSirExtScanResetBssidHotlistRspParams;
+
+typedef struct
+{
+    tANI_U32              requestId;
+    tANI_U8               sessionId;
+
+    /* Number of samples for averaging RSSI */
+    tANI_U32              rssiSampleSize;
+
+    /* Number of missed samples to confirm AP loss */
+    tANI_U32              lostApSampleSize;
+
+    /* Number of APs breaching threshold required for firmware
+     * to generate event
+     */
+    tANI_U32              minBreaching;
+
+    tANI_U32              numAp;
+    tSirAPThresholdParam  ap[WLAN_EXTSCAN_MAX_SIGNIFICANT_CHANGE_APS];
+} tSirExtScanSetSigChangeReqParams,
+ *tpSirExtScanSetSigChangeReqParams;
+
+typedef struct
+{
+    tANI_U32      requestId;
+    tANI_U32      status;
+} tSirExtScanSetSignificantChangeRspParams,
+  *tpSirExtScanSetSignificantChangeRspParams;
+
+typedef struct
+{
+    tSirMacAddr  bssid;
+    tANI_U32     channel;
+    tANI_U32     numOfRssi;
+
+    /* Rssi history in db */
+    tANI_S32     *rssi;
+} tSirWifiSignificantChange, *tpSirWifiSignificantChange;
+
+typedef struct
+{
+    tANI_U32                      requestId;
+
+    tANI_BOOLEAN                  moreData;
+    tANI_U32                      numResults;
+    tSirWifiSignificantChange     **ap;
+} tSirWifiSignificantChangeEvent, *tpSirWifiSignificantChangeEvent;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U8     sessionId;
+} tSirExtScanResetSignificantChangeReqParams,
+  *tpSirExtScanResetSignificantChangeReqParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    status;
+} tSirExtScanResetSignificantChangeRspParams,
+  *tpSirExtScanResetSignificantChangeRspParams;
+
+typedef struct
+{
+    tANI_U32    requestId;
+    tANI_U32    numResultsAvailable;
+} tSirExtScanResultsAvailableIndParams,
+  *tpSirExtScanResultsAvailableIndParams;
+
+typedef struct
+{
+    tANI_U8    scanEventType;
+    tANI_U32   status;
+} tSirExtScanOnScanEventIndParams,
+  *tpSirExtScanOnScanEventIndParams;
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 #endif /* __SIR_API_H */
diff --git a/CORE/MAC/src/include/sirParams.h b/CORE/MAC/src/include/sirParams.h
index ebb0099c4845..9bf86e8481ff 100644
--- a/CORE/MAC/src/include/sirParams.h
+++ b/CORE/MAC/src/include/sirParams.h
@@ -684,6 +684,18 @@ typedef struct sSirMbMsgP2p
 #define SIR_HAL_ROAM_PREAUTH_IND           (SIR_HAL_ITC_MSG_TYPES_BEGIN + 264)
 
 #define SIR_HAL_TBTT_UPDATE_IND            (SIR_HAL_ITC_MSG_TYPES_BEGIN + 265)
+
+#ifdef FEATURE_WLAN_EXTSCAN
+#define SIR_HAL_EXTSCAN_GET_CAPABILITIES_REQ  (SIR_HAL_ITC_MSG_TYPES_BEGIN + 266)
+#define SIR_HAL_EXTSCAN_START_REQ             (SIR_HAL_ITC_MSG_TYPES_BEGIN + 267)
+#define SIR_HAL_EXTSCAN_STOP_REQ              (SIR_HAL_ITC_MSG_TYPES_BEGIN + 268)
+#define SIR_HAL_EXTSCAN_SET_BSS_HOTLIST_REQ   (SIR_HAL_ITC_MSG_TYPES_BEGIN + 269)
+#define SIR_HAL_EXTSCAN_RESET_BSS_HOTLIST_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 270)
+#define SIR_HAL_EXTSCAN_SET_SIGNF_CHANGE_REQ  (SIR_HAL_ITC_MSG_TYPES_BEGIN + 271)
+#define SIR_HAL_EXTSCAN_RESET_SIGNF_CHANGE_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 272)
+#define SIR_HAL_EXTSCAN_GET_CACHED_RESULTS_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 273)
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 #define SIR_HAL_MSG_TYPES_END              (SIR_HAL_MSG_TYPES_BEGIN + 0x1FF)
 
 // CFG message types
diff --git a/CORE/MAC/src/pe/lim/limP2P.c b/CORE/MAC/src/pe/lim/limP2P.c
index b237b85654dd..fedcd1074f51 100644
--- a/CORE/MAC/src/pe/lim/limP2P.c
+++ b/CORE/MAC/src/pe/lim/limP2P.c
@@ -890,6 +890,10 @@ void limSendP2PActionFrame(tpAniSirGlobal pMac, tpSirMsgQ pMsg)
     v_U8_t              *pNewP2PIe = NULL;
     v_U16_t             remainLen = 0;
     tANI_U8             smeSessionId = 0;
+#ifdef WLAN_FEATURE_11W
+    tpSirMacMgmtHdr        pMacHdr;
+    tpSirMacActionFrameHdr pActionHdr;
+#endif
 
     nBytes = pMbMsg->msgLen - sizeof(tSirMbMsg);
 
@@ -1140,6 +1144,63 @@ send_frame1:
         vos_mem_copy(pFrame, pMbMsg->data, nBytes);
     }
 
+#ifdef WLAN_FEATURE_11W
+    pActionHdr = (tpSirMacActionFrameHdr) (pFrame + sizeof(tSirMacMgmtHdr));
+
+    /*
+     * Setting Protected bit for SA_QUERY Action Frame
+     * This has to be based on the current Connection with the station
+     * limSetProtectedBit API will set the protected bit if connection if PMF
+     */
+
+    if ((SIR_MAC_MGMT_ACTION == pFc->subType) &&
+        (SIR_MAC_ACTION_SA_QUERY == pActionHdr->category))
+    {
+        pMacHdr    = (tpSirMacMgmtHdr ) pFrame;
+        psessionEntry = peFindSessionByBssid(pMac,
+                        (tANI_U8*)pMbMsg->data + BSSID_OFFSET, &sessionId);
+
+        /* Check for session corresponding to ADDR2 ss supplicant is filling
+           ADDR2  with BSSID */
+        if(NULL == psessionEntry)
+        {
+            psessionEntry = peFindSessionByBssid(pMac,
+                       (tANI_U8*)pMbMsg->data + ADDR2_OFFSET, &sessionId);
+        }
+
+        if(NULL != psessionEntry)
+        {
+            limSetProtectedBit(pMac, psessionEntry, pMacHdr->da, pMacHdr);
+        }
+        else
+        {
+            limLog(pMac, LOGE,
+                FL("Dropping SA Query frame - Unable to find PE Session \n"));
+            limSendSmeRsp(pMac, eWNI_SME_ACTION_FRAME_SEND_CNF,
+                    eHAL_STATUS_FAILURE, pMbMsg->sessionId, 0);
+            palPktFree( pMac->hHdd, HAL_TXRX_FRM_802_11_MGMT,
+                    ( void* ) pFrame, ( void* ) pPacket );
+            return;
+        }
+
+        /*
+         * If wep bit is not set in MAC header then we are trying to
+         * send SA Query via non PMF connection. Drop the packet.
+         */
+
+        if(0 ==  pMacHdr->fc.wep)
+        {
+            limLog(pMac, LOGE,
+                FL("Dropping SA Query frame due to non PMF connection\n"));
+            limSendSmeRsp(pMac, eWNI_SME_ACTION_FRAME_SEND_CNF,
+                    eHAL_STATUS_FAILURE, pMbMsg->sessionId, 0);
+            palPktFree( pMac->hHdd, HAL_TXRX_FRM_802_11_MGMT,
+                    ( void* ) pFrame, ( void* ) pPacket );
+            return;
+        }
+    }
+#endif
+
     /* Use BD rate 2 for all P2P related frames. As these frames need to go
      * at OFDM rates. And BD rate2 we configured at 6Mbps.
      */
diff --git a/CORE/MAC/src/pe/lim/limSendManagementFrames.c b/CORE/MAC/src/pe/lim/limSendManagementFrames.c
index 4fc07a054d99..e9b49b44fcc6 100644
--- a/CORE/MAC/src/pe/lim/limSendManagementFrames.c
+++ b/CORE/MAC/src/pe/lim/limSendManagementFrames.c
@@ -347,48 +347,6 @@ tSirRetStatus limPopulateMacHeader( tpAniSirGlobal pMac,
     return statusCode;
 } /*** end limPopulateMacHeader() ***/
 
-#ifdef WLAN_FEATURE_11W
-/**
- *
- * \brief This function is called by various LIM modules to correctly set
- * the Protected bit in the Frame Control Field of the 802.11 frame MAC header
- *
- *
- * \param  pMac Pointer to Global MAC structure
- *
- * \param psessionEntry Pointer to session corresponding to the connection
- *
- * \param peer Peer address of the STA to which the frame is to be sent
- *
- * \param pMacHdr Pointer to the frame MAC header
- *
- * \return nothing
- *
- *
- */
-void
-limSetProtectedBit(tpAniSirGlobal  pMac,
-                   tpPESession     psessionEntry,
-                   tSirMacAddr     peer,
-                   tpSirMacMgmtHdr pMacHdr)
-{
-    tANI_U16 aid;
-    tpDphHashNode pStaDs;
-
-    if( (psessionEntry->limSystemRole == eLIM_AP_ROLE) ||
-         (psessionEntry->limSystemRole == eLIM_BT_AMP_AP_ROLE) )
-    {
-
-        pStaDs = dphLookupHashEntry( pMac, peer, &aid, &psessionEntry->dph.dphHashTable );
-        if( pStaDs != NULL )
-            if( pStaDs->rmfEnabled )
-                pMacHdr->fc.wep = 1;
-    }
-    else if ( psessionEntry->limRmfEnabled )
-        pMacHdr->fc.wep = 1;
-} /*** end limSetProtectedBit() ***/
-#endif
-
 /**
  * \brief limSendProbeReqMgmtFrame
  *
diff --git a/CORE/MAC/src/pe/lim/limUtils.c b/CORE/MAC/src/pe/lim/limUtils.c
index e6569173de96..26db8b57be45 100644
--- a/CORE/MAC/src/pe/lim/limUtils.c
+++ b/CORE/MAC/src/pe/lim/limUtils.c
@@ -7966,3 +7966,47 @@ void limUtilsframeshtonl(tpAniSirGlobal    pCtx,
     }
 #endif
 }
+
+#ifdef WLAN_FEATURE_11W
+/**
+ *
+ * \brief This function is called by various LIM modules to correctly set
+ * the Protected bit in the Frame Control Field of the 802.11 frame MAC header
+ *
+ *
+ * \param  pMac Pointer to Global MAC structure
+ *
+ * \param psessionEntry Pointer to session corresponding to the connection
+ *
+ * \param peer Peer address of the STA to which the frame is to be sent
+ *
+ * \param pMacHdr Pointer to the frame MAC header
+ *
+ * \return nothing
+ *
+ *
+ */
+void
+limSetProtectedBit(tpAniSirGlobal  pMac,
+                   tpPESession     psessionEntry,
+                   tSirMacAddr     peer,
+                   tpSirMacMgmtHdr pMacHdr)
+{
+    tANI_U16 aid;
+    tpDphHashNode pStaDs;
+
+    if( (psessionEntry->limSystemRole == eLIM_AP_ROLE) ||
+         (psessionEntry->limSystemRole == eLIM_BT_AMP_AP_ROLE) )
+    {
+
+        pStaDs = dphLookupHashEntry( pMac, peer, &aid,
+                                     &psessionEntry->dph.dphHashTable );
+        if( pStaDs != NULL )
+            if( pStaDs->rmfEnabled )
+                pMacHdr->fc.wep = 1;
+    }
+    else if ( psessionEntry->limRmfEnabled )
+        pMacHdr->fc.wep = 1;
+} /*** end limSetProtectedBit() ***/
+#endif
+
diff --git a/CORE/MAC/src/pe/lim/limUtils.h b/CORE/MAC/src/pe/lim/limUtils.h
index 38c28c9e6464..0aa8eacf5d08 100644
--- a/CORE/MAC/src/pe/lim/limUtils.h
+++ b/CORE/MAC/src/pe/lim/limUtils.h
@@ -585,4 +585,10 @@ void limUtilsframeshtonl(tpAniSirGlobal  pCtx,
                             tANI_U8  *pOut,
                             tANI_U32  pIn,
                             tANI_U8  fMsb);
+
+void limSetProtectedBit(tpAniSirGlobal  pMac,
+                           tpPESession     psessionEntry,
+                           tSirMacAddr     peer,
+                           tpSirMacMgmtHdr pMacHdr);
+
 #endif /* __LIM_UTILS_H */
diff --git a/CORE/SERVICES/COMMON/dbglog_id.h b/CORE/SERVICES/COMMON/dbglog_id.h
index d2afa8ccc72b..b7cd2daaf188 100644
--- a/CORE/SERVICES/COMMON/dbglog_id.h
+++ b/CORE/SERVICES/COMMON/dbglog_id.h
@@ -1208,16 +1208,16 @@ extern "C" {
 #define NAN_DBGID_ROLE_CHANGE                       (NAN_DBGID_EVT_BASE + 60)
 /* args: TBD */
 #define NAN_DBGID_SYNC_BEACON_DW_STATS              (NAN_DBGID_EVT_BASE + 61)
+/* args: attrId */
+#define NAN_DBGID_RX_UNSUPPORTED_SDF_ATTR_ID        (NAN_DBGID_EVT_BASE + 62)
+/* args: handle, sid1, sid2, svcCtrl, length */
+#define NAN_DBGID_PUBSUB_MATCHED_SKIPPED_SSI        (NAN_DBGID_EVT_BASE + 63)
+/* args: offset */
+#define NAN_DBGID_MATCH_FILTER_OFFSET               (NAN_DBGID_EVT_BASE + 64)
+/* args: twSize, n, twIndex */
+#define NAN_DBGID_TW_PARAMS                         (NAN_DBGID_EVT_BASE + 65)
 /* args: */
-#define NAN_DBGID_SPARE_62                          (NAN_DBGID_EVT_BASE + 62)
-/* args: */
-#define NAN_DBGID_SPARE_63                          (NAN_DBGID_EVT_BASE + 63)
-/* args: */
-#define NAN_DBGID_SPARE_64                          (NAN_DBGID_EVT_BASE + 64)
-/* args: */
-#define NAN_DBGID_SPARE_65                          (NAN_DBGID_EVT_BASE + 65)
-/* args: */
-#define NAN_DBGID_SPARE_66                          (NAN_DBGID_EVT_BASE + 66)
+#define NAN_DBGID_BEACON_SENDER                     (NAN_DBGID_EVT_BASE + 66)
 /* args: */
 #define NAN_DBGID_SPARE_67                          (NAN_DBGID_EVT_BASE + 67)
 /* args: */
@@ -1226,8 +1226,18 @@ extern "C" {
 #define NAN_DBGID_SPARE_69                          (NAN_DBGID_EVT_BASE + 69)
 /* args: */
 #define NAN_DBGID_SPARE_70                          (NAN_DBGID_EVT_BASE + 70)
+/* args: */
+#define NAN_DBGID_SPARE_71                          (NAN_DBGID_EVT_BASE + 71)
+/* args: */
+#define NAN_DBGID_SPARE_72                          (NAN_DBGID_EVT_BASE + 72)
+/* args: */
+#define NAN_DBGID_SPARE_73                          (NAN_DBGID_EVT_BASE + 73)
+/* args: */
+#define NAN_DBGID_SPARE_74                          (NAN_DBGID_EVT_BASE + 74)
+/* args: */
+#define NAN_DBGID_SPARE_75                          (NAN_DBGID_EVT_BASE + 75)
 /* PLEASE KEEP THIS ONE AT THE END */
-#define NAN_DBGID_EVT_LOG_LAST                      (NAN_DBGID_EVT_BASE + 71)
+#define NAN_DBGID_EVT_LOG_LAST                      (NAN_DBGID_EVT_BASE + 76)
 
 /* Debug IDs for message logs. */
 #define NAN_DBGID_API_MSG_BASE                      NAN_DBGID_EVT_LOG_LAST
diff --git a/CORE/SERVICES/COMMON/wlan_module_ids.h b/CORE/SERVICES/COMMON/wlan_module_ids.h
index 5246b704a8d6..7d8ca1d8914e 100644
--- a/CORE/SERVICES/COMMON/wlan_module_ids.h
+++ b/CORE/SERVICES/COMMON/wlan_module_ids.h
@@ -80,6 +80,8 @@ typedef enum {
   WLAN_MODULE_STATS,
   WLAN_MODULE_NAN,
   WLAN_MODULE_IBSS_PWRSAVE,
+  WLAN_MODULE_HIF_UART,
+  WLAN_MODULE_LPI,
   WLAN_MODULE_ID_MAX,
   WLAN_MODULE_ID_INVALID = WLAN_MODULE_ID_MAX,
 } WLAN_MODULE_ID;
diff --git a/CORE/SERVICES/COMMON/wmi.h b/CORE/SERVICES/COMMON/wmi.h
index f2df8907e9f1..2a7d095fcc84 100644
--- a/CORE/SERVICES/COMMON/wmi.h
+++ b/CORE/SERVICES/COMMON/wmi.h
@@ -91,18 +91,23 @@ PREPACK struct host_app_area_s {
 #define WMI_SET_FIELD(_msg_buf, _msg_type, _f, _val) \
     SET_FIELD(_msg_buf, _msg_type ## _ ## _f, _val)
 
+#define WMI_EP_APASS           0x0
+#define WMI_EP_LPASS           0x1
+
 /*
  * Control Path
  */
 typedef PREPACK struct {
     A_UINT32    commandId : 24,
-                reserved  : 2, /* reserved for future WMI  */
+                reserved  : 2, /* used for WMI endpoint ID */
                 plt_priv  : 6; /* platform private */
 } POSTPACK WMI_CMD_HDR;        /* used for commands and events */
 
 #define WMI_CMD_HDR_COMMANDID_LSB           0
 #define WMI_CMD_HDR_COMMANDID_MASK          0x00ffffff
 #define WMI_CMD_HDR_COMMANDID_OFFSET        0x00000000
+#define WMI_CMD_HDR_WMI_ENDPOINTID_MASK     0x03000000
+#define WMI_CMD_HDR_WMI_ENDPOINTID_OFFSET   24
 #define WMI_CMD_HDR_PLT_PRIV_LSB            24
 #define WMI_CMD_HDR_PLT_PRIV_MASK           0xff000000
 #define WMI_CMD_HDR_PLT_PRIV_OFFSET         0x00000000
diff --git a/CORE/SERVICES/COMMON/wmi_services.h b/CORE/SERVICES/COMMON/wmi_services.h
index 31d1d534e69b..fd6e9b274eac 100644
--- a/CORE/SERVICES/COMMON/wmi_services.h
+++ b/CORE/SERVICES/COMMON/wmi_services.h
@@ -105,6 +105,7 @@ typedef  enum  {
     WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, /* TDLS UAPSD Buffer STA support */
     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_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 4feaa72e83ce..6f6bef686855 100644
--- a/CORE/SERVICES/COMMON/wmi_tlv_defs.h
+++ b/CORE/SERVICES/COMMON/wmi_tlv_defs.h
@@ -457,6 +457,11 @@ typedef enum {
     WMITLV_TAG_STRUC_wmi_peer_link_stats,
     WMITLV_TAG_STRUC_wmi_wmm_ac_stats,
     WMITLV_TAG_STRUC_wmi_iface_link_stats,
+    WMITLV_TAG_STRUC_wmi_lpi_mgmt_snooping_config_cmd_fixed_param,
+    WMITLV_TAG_STRUC_wmi_lpi_start_scan_cmd_fixed_param,
+    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_ID;
 
 /*
@@ -623,7 +628,10 @@ typedef enum {
     OP(WMI_WOW_ACER_IOAC_DEL_WAKE_PATTERN_CMDID) \
     OP(WMI_REQUEST_LINK_STATS_CMDID) \
     OP(WMI_START_LINK_STATS_CMDID) \
-    OP(WMI_CLEAR_LINK_STATS_CMDID)
+    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)
 
 /*
  * IMPORTANT: Please add _ALL_ WMI Events Here.
@@ -696,7 +704,9 @@ typedef enum {
     OP(WMI_UPDATE_WHAL_MIB_STATS_EVENTID) \
     OP(WMI_IFACE_LINK_STATS_EVENTID) \
     OP(WMI_PEER_LINK_STATS_EVENTID) \
-    OP(WMI_RADIO_LINK_STATS_EVENTID)
+    OP(WMI_RADIO_LINK_STATS_EVENTID) \
+    OP(WMI_LPI_RESULT_EVENTID) \
+    OP(WMI_PEER_STATE_EVENTID)
 
 /* TLV definitions of WMI commands */
 
@@ -1615,6 +1625,33 @@ WMITLV_CREATE_PARAM_STRUC(WMI_BATCH_SCAN_DISABLE_CMDID);
 
 WMITLV_CREATE_PARAM_STRUC(WMI_BATCH_SCAN_TRIGGER_RESULT_CMDID);
 
+/* LPI mgmt snooping config Cmd */
+#define WMITLV_TABLE_WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_lpi_mgmt_snooping_config_cmd_fixed_param, wmi_lpi_mgmt_snooping_config_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID);
+
+/* LPI start scan Cmd */
+#define WMITLV_TABLE_WMI_LPI_START_SCAN_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_lpi_start_scan_cmd_fixed_param, wmi_lpi_start_scan_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_UINT32, A_UINT32, channel_list, WMITLV_SIZE_VAR) \
+    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_CREATE_PARAM_STRUC(WMI_LPI_START_SCAN_CMDID);
+
+/* LPI stop scan Cmd */
+#define WMITLV_TABLE_WMI_LPI_STOP_SCAN_CMDID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_lpi_stop_scan_cmd_fixed_param, wmi_lpi_stop_scan_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+
+WMITLV_CREATE_PARAM_STRUC(WMI_LPI_STOP_SCAN_CMDID);
+
+#define WMITLV_TABLE_WMI_LPI_RESULT_EVENTID(id,op,buf,len) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_lpi_result_event_fixed_param, wmi_lpi_result_event_fixed_param, fixed_param, WMITLV_SIZE_FIX) \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_ARRAY_BYTE, A_UINT8, data, WMITLV_SIZE_VAR)
+WMITLV_CREATE_PARAM_STRUC(WMI_LPI_RESULT_EVENTID);
+
 /* Thermal Manager Params*/
 #define WMITLV_TABLE_WMI_THERMAL_MGMT_CMDID(id,op,buf,len) \
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_thermal_mgmt_cmd_fixed_param, wmi_thermal_mgmt_cmd_fixed_param, fixed_param, WMITLV_SIZE_FIX)
@@ -2049,7 +2086,10 @@ WMITLV_CREATE_PARAM_STRUC(WMI_OFFLOAD_PROB_RESP_TX_STATUS_EVENTID);
     WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_host_auto_shutdown_event_fixed_param, wmi_host_auto_shutdown_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
 WMITLV_CREATE_PARAM_STRUC(WMI_HOST_AUTO_SHUTDOWN_EVENTID);
 
-
+/* peer state Event */
+#define WMITLV_TABLE_WMI_PEER_STATE_EVENTID(id,op,buf,len)                                     \
+    WMITLV_ELEM(id,op,buf,len, WMITLV_TAG_STRUC_wmi_peer_state_event_fixed_param, wmi_peer_state_event_fixed_param, fixed_param, WMITLV_SIZE_FIX)
+WMITLV_CREATE_PARAM_STRUC(WMI_PEER_STATE_EVENTID);
 
 #ifdef __cplusplus
 }
diff --git a/CORE/SERVICES/COMMON/wmi_unified.h b/CORE/SERVICES/COMMON/wmi_unified.h
index 70e35ab942c4..6ae00301d51d 100644
--- a/CORE/SERVICES/COMMON/wmi_unified.h
+++ b/CORE/SERVICES/COMMON/wmi_unified.h
@@ -173,6 +173,7 @@ typedef enum {
     WMI_GRP_NAN,
     WMI_GRP_COEX,
     WMI_GRP_OBSS_OFL,
+    WMI_GRP_LPI,
 } WMI_GRP_ID;
 
 #define WMI_CMD_GRP_START_ID(grp_id) (((grp_id) << 12) | 0x1)
@@ -636,6 +637,15 @@ typedef enum {
      */
     WMI_OBSS_SCAN_ENABLE_CMDID = WMI_CMD_GRP_START_ID(WMI_GRP_OBSS_OFL),
     WMI_OBSS_SCAN_DISABLE_CMDID,
+
+    /**LPI commands*/
+    /**LPI mgmt snooping config command*/
+    WMI_LPI_MGMT_SNOOPING_CONFIG_CMDID = WMI_CMD_GRP_START_ID(WMI_GRP_LPI),
+    /**LPI scan start command*/
+    WMI_LPI_START_SCAN_CMDID,
+    /**LPI scan stop command*/
+    WMI_LPI_STOP_SCAN_CMDID,
+
 } WMI_CMD_ID;
 
 typedef enum {
@@ -696,6 +706,10 @@ typedef enum {
      * WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID command.
      */
     WMI_PEER_ESTIMATED_LINKSPEED_EVENTID,
+    /* Return the peer state
+     * WMI_PEER_SET_PARAM_CMDID, WMI_PEER_AUTHORIZE
+     */
+    WMI_PEER_STATE_EVENTID,
 
     /* beacon/mgmt specific events */
     /** RX management frame. the entire frame is carried along with the event.  */
@@ -855,6 +869,10 @@ typedef enum {
 
     /* NAN Event */
     WMI_NAN_EVENTID = WMI_EVT_GRP_START_ID(WMI_GRP_NAN),
+
+    /* LPI Event */
+    WMI_LPI_RESULT_EVENTID = WMI_EVT_GRP_START_ID(WMI_GRP_LPI),
+
 } WMI_EVT_ID;
 
 /* defines for OEM message sub-types */
@@ -6777,6 +6795,115 @@ typedef struct
     A_UINT32 netWorkStartIndex;  /* indicate the start index of network info*/
 } wmi_batch_scan_result_scan_list;
 
+#define LPI_IE_BITMAP_BSSID              0x0001
+#define LPI_IE_BITMAP_SSID               0x0002
+#define LPI_IE_BITMAP_RSSI               0x0004
+#define LPI_IE_BITMAP_CHAN               0x0008
+
+typedef struct {
+    A_UINT32 tlv_header;
+    /**A_BOOL indicates LPI mgmt snooping enable/disable*/
+    A_UINT32 enable;
+    /**LPI snooping mode*/
+    A_UINT32 snooping_mode;
+    /** LPI interested IEs in snooping context */
+    A_UINT32 ie_bitmap;
+} wmi_lpi_mgmt_snooping_config_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32 tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param */
+    /** Scan ID */
+    A_UINT32 scan_id;
+    /** Scan requestor ID */
+    A_UINT32 scan_req_id;
+    /** VDEV id(interface) that is requesting scan */
+    A_UINT32 vdev_id;
+    /** LPI interested IEs in scan context */
+    A_UINT32 ie_bitmap;
+    /** Scan Priority, input to scan scheduler */
+    A_UINT32 scan_priority;
+    /** dwell time in msec on active channels */
+    A_UINT32 dwell_time_active;
+    /** dwell time in msec on passive channels */
+    A_UINT32 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
+     */
+    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;
+
+    /** # if channels to scan. In the TLV channel_list[] */
+    A_UINT32 num_chan;
+    /** 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 ie data. In the TLV ie_data[] */
+    A_UINT32 ie_len;
+
+/**
+ * TLV (tag length value ) parameters follow the scan_cmd
+ * structure. The TLV's are:
+ *     A_UINT32 channel_list[];
+ *     wmi_ssid ssid_list[];
+ *     wmi_mac_addr bssid_list[];
+ *     A_UINT8 ie_data[];
+ */
+} wmi_lpi_start_scan_cmd_fixed_param;
+
+typedef struct {
+    A_UINT32 tlv_header; /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param */
+    /** requestor requesting cancel  */
+    A_UINT32 requestor;
+    /** Scan ID */
+    A_UINT32 scan_id;
+    /**
+     * Req Type
+     * req_type should be WMI_SCAN_STOP_ONE, WMI_SCN_STOP_VAP_ALL or WMI_SCAN_STOP_ALL
+     * WMI_SCAN_STOP_ONE indicates to stop a specific scan with scan_id
+     * WMI_SCN_STOP_VAP_ALL indicates to stop all scan requests on a specific vDev with vdev_id
+     * WMI_SCAN_STOP_ALL indicates to stop all scan requests in both Scheduler's queue and Scan Engine
+     */
+    A_UINT32 req_type;
+    /**
+     * vDev ID
+     * used when req_type equals to WMI_SCN_STOP_VAP_ALL, it indexed the vDev on which to stop the scan
+     */
+    A_UINT32 vdev_id;
+} wmi_lpi_stop_scan_cmd_fixed_param;
+
+typedef struct
+{
+    A_UINT32 tlv_header;
+    A_UINT32 ie_bitmap;
+    A_UINT32 data_len;
+    /* This buffer is used to send lpi scan result data
+      *  A_UINT8 data[];	 // length in byte given by field data_len.
+      */
+} wmi_lpi_result_event_fixed_param;
+
 typedef struct
 {
     A_UINT32 tlv_header;
@@ -7008,6 +7135,8 @@ typedef struct {
     /** TLV tag and len; tag equals
      *  WMITLV_TAG_STRUC_wmi_mhf_offload_plumb_routing_table_cmd_fixed_param */
     A_UINT32 tlv_header;
+    /** vdev id*/
+    A_UINT32 vdev_id;
     /** action corresponds to values from enum
      *  wmi_mhf_ofl_table_action */
     A_UINT32 action;
@@ -7238,6 +7367,15 @@ typedef struct {
      */
 } wmi_stats_ext_event_fixed_param;
 
+typedef struct {
+    /* TLV tag and len; tag equals WMITLV_TAG_STRUC_ wmi_peer_state_event_fixed_param */
+    A_UINT32 tlv_header;
+    A_UINT32 vdev_id; /* vdev ID */
+    /* MAC address of the peer for which the estimated link speed is required.*/
+    wmi_mac_addr peer_macaddr;
+    A_UINT32 state; /* peer state */
+} wmi_peer_state_event_fixed_param;
+
 enum {
     WMI_2G4_HT40_OBSS_SCAN_PASSIVE = 0,    /** scan_type: passive */
     WMI_2G4_HT40_OBSS_SCAN_ACTIVE, /** scan_type: active */
diff --git a/CORE/SERVICES/COMMON/wmi_version.h b/CORE/SERVICES/COMMON/wmi_version.h
index c7d4f8b3f6f3..3a1d8b0c2b18 100644
--- a/CORE/SERVICES/COMMON/wmi_version.h
+++ b/CORE/SERVICES/COMMON/wmi_version.h
@@ -36,7 +36,7 @@
 #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_ 52
+#define __WMI_REVISION_ 54
 
 /** 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 dd32c4b6215b..1d003478c779 100644
--- a/CORE/SERVICES/WMA/wma.c
+++ b/CORE/SERVICES/WMA/wma.c
@@ -19629,7 +19629,10 @@ static void wma_update_hdd_cfg(tp_wma_handle wma_handle)
 #endif	/* #ifdef WLAN_FEATURE_11AC */
 
 #ifndef QCA_WIFI_ISOC
- hdd_tgt_cfg.target_fw_version = wma_handle->target_fw_version;
+	hdd_tgt_cfg.target_fw_version = wma_handle->target_fw_version;
+#ifdef WLAN_FEATURE_LPSS
+	hdd_tgt_cfg.lpss_support = wma_handle->lpss_support;
+#endif
 	wma_handle->tgt_cfg_update_cb(hdd_ctx, &hdd_tgt_cfg);
 #endif
 }
@@ -19818,6 +19821,12 @@ v_VOID_t wma_rx_service_ready_event(WMA_HANDLE handle, void *cmd_param_info)
 	}
 #endif
 
+#ifdef WLAN_FEATURE_LPSS
+	wma_handle->lpss_support =
+		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
+				       WMI_SERVICE_LPASS);
+#endif
+
 	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
 				WMI_SERVICE_CSA_OFFLOAD)) {
 		WMA_LOGD("%s: FW support CSA offload capability", __func__);
diff --git a/CORE/SERVICES/WMA/wma.h b/CORE/SERVICES/WMA/wma.h
index a818295874ad..9d34c2f637ff 100644
--- a/CORE/SERVICES/WMA/wma.h
+++ b/CORE/SERVICES/WMA/wma.h
@@ -557,6 +557,9 @@ typedef struct {
 	/* The final negotiated ABI version to be used for communicating */
 	wmi_abi_version final_abi_vers;
 	v_U32_t target_fw_version; /* Target f/w build version */
+#ifdef WLAN_FEATURE_LPSS
+	v_U8_t lpss_support; /* LPSS feature is supported in target or not */
+#endif
 	bool wmi_ready;
 	u_int32_t wlan_init_status;
 	adf_os_device_t adf_dev;
diff --git a/CORE/SERVICES/WMI/wmi_unified.c b/CORE/SERVICES/WMI/wmi_unified.c
index 9ba48a9edc47..a241117f75fe 100644
--- a/CORE/SERVICES/WMI/wmi_unified.c
+++ b/CORE/SERVICES/WMI/wmi_unified.c
@@ -537,6 +537,9 @@ static u_int8_t* get_wmi_cmd_string(WMI_CMD_ID wmi_command)
 		CASE_RETURN_STRING(WMI_REQUEST_LINK_STATS_CMDID);
 		CASE_RETURN_STRING(WMI_START_LINK_STATS_CMDID);
 		CASE_RETURN_STRING(WMI_CLEAR_LINK_STATS_CMDID);
+		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);
 	}
 	return "Invalid WMI cmd";
 }
diff --git a/CORE/SME/inc/smeInternal.h b/CORE/SME/inc/smeInternal.h
index 7044351d8ea9..f0bb2744ede5 100644
--- a/CORE/SME/inc/smeInternal.h
+++ b/CORE/SME/inc/smeInternal.h
@@ -155,6 +155,9 @@ typedef struct tagSmeStruct
     /* linkspeed callback */
     void (*pLinkSpeedIndCb) (tSirLinkSpeedInfo *indParam, void *pDevContext);
     void *pLinkSpeedCbContext;
+#ifdef FEATURE_WLAN_EXTSCAN
+    void (*pExtScanIndCb) (void *, const tANI_U16, void *);
+#endif /* FEATURE_WLAN_EXTSCAN */
 } tSmeStruct, *tpSmeStruct;
 
 
diff --git a/CORE/SME/inc/sme_Api.h b/CORE/SME/inc/sme_Api.h
index 4f8c59c340e9..95a50df27ece 100644
--- a/CORE/SME/inc/sme_Api.h
+++ b/CORE/SME/inc/sme_Api.h
@@ -3657,6 +3657,110 @@ v_BOOL_t sme_GetDFSScanMode(tHalHandle hHal);
     -------------------------------------------------------------------------*/
 tANI_BOOLEAN sme_staInMiddleOfRoaming(tHalHandle hHal);
 
+#ifdef FEATURE_WLAN_EXTSCAN
+/* ---------------------------------------------------------------------------
+    \fn sme_GetValidChannelsByBand
+    \brief  SME API to fetch all valid channel filtered by band
+    \param  hHal
+    \param  wifiBand: RF band information
+    \param  aValidChannels: Array to store channel info
+    \param  len: number of channels
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_GetValidChannelsByBand (tHalHandle hHal, tANI_U8 wifiBand,
+                              tANI_U32 *aValidChannels, tANI_U8 *pNumChannels);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanGetCapabilities
+    \brief  SME API to fetch extscan capabilities
+    \param  hHal
+    \param  pReq: extscan capabilities structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanGetCapabilities (tHalHandle hHal,
+                                    tSirGetExtScanCapabilitiesReqParams *pReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanStart
+    \brief  SME API to issue extscan start
+    \param  hHal
+    \param  pStartCmd: extscan start structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanStart (tHalHandle hHal,
+                          tSirWifiScanCmdReqParams *pStartCmd);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanStop
+    \brief  SME API to issue extscan stop
+    \param  hHal
+    \param  pStopReq: extscan stop structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanStop(tHalHandle hHal,
+                           tSirExtScanStopReqParams *pStopReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_SetBssHotlist
+    \brief  SME API to set BSSID hotlist
+    \param  hHal
+    \param  pSetHotListReq: extscan set hotlist structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_SetBssHotlist (tHalHandle hHal,
+                          tSirExtScanSetBssidHotListReqParams *pSetHotListReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ResetBssHotlist
+    \brief  SME API to reset BSSID hotlist
+    \param  hHal
+    \param  pSetHotListReq: extscan set hotlist structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ResetBssHotlist (tHalHandle hHal,
+                             tSirExtScanResetBssidHotlistReqParams *pResetReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_SetSignificantChange
+    \brief  SME API to set significant change
+    \param  hHal
+    \param  pSetSignificantChangeReq: extscan set significant change structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_SetSignificantChange (tHalHandle hHal,
+                   tSirExtScanSetSigChangeReqParams* pSetSignificantChangeReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ResetSignificantChange
+    \brief  SME API to reset significant change
+    \param  hHal
+    \param  pResetReq: extscan reset significant change structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ResetSignificantChange (tHalHandle hHal,
+                        tSirExtScanResetSignificantChangeReqParams *pResetReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_getCachedResults
+    \brief  SME API to get cached results
+    \param  hHal
+    \param  pCachedResultsReq: extscan get cached results structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_getCachedResults (tHalHandle hHal,
+                      tSirExtScanGetCachedResultsReqParams *pCachedResultsReq);
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanRegisterCallback
+    \brief  SME API to register extscan notification callback
+    \param  pExtScanIndCb
+    \- return void
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanRegisterCallback (tHalHandle hHal,
+                        void (*pExtScanIndCb)(void *, const tANI_U16, void *));
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 #ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
 /* ---------------------------------------------------------------------------
     \fn sme_abortRoamScan
diff --git a/CORE/SME/src/sme_common/sme_Api.c b/CORE/SME/src/sme_common/sme_Api.c
index 0378ef1fd807..ffc5637eb2e1 100644
--- a/CORE/SME/src/sme_common/sme_Api.c
+++ b/CORE/SME/src/sme_common/sme_Api.c
@@ -2680,6 +2680,7 @@ eHalStatus sme_ProcessMsg(tHalHandle hHal, vos_msg_t* pMsg)
                    vos_mem_free(pMsg->bodyptr);
                }
                break;
+
           default:
 
              if ( ( pMsg->type >= eWNI_SME_MSG_TYPES_BEGIN )
@@ -12701,3 +12702,374 @@ eHalStatus sme_abortRoamScan(tHalHandle hHal)
     return(status);
 }
 #endif //#if WLAN_FEATURE_ROAM_SCAN_OFFLOAD
+
+#ifdef FEATURE_WLAN_EXTSCAN
+/* ---------------------------------------------------------------------------
+    \fn sme_GetValidChannelsByBand
+    \brief  SME API to fetch all valid channels filtered by band
+    \param  hHal
+    \param  wifiBand: RF band information
+    \param  aValidChannels: output array to store channel info
+    \param  pNumChannels: output number of channels
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_GetValidChannelsByBand(tHalHandle hHal,
+                                      tANI_U8 wifiBand,
+                                      tANI_U32 *aValidChannels,
+                                      tANI_U8 *pNumChannels)
+{
+    eHalStatus status                                = eHAL_STATUS_SUCCESS;
+    tANI_U8 chanList[WNI_CFG_VALID_CHANNEL_LIST_LEN] = {0};
+    tpAniSirGlobal pMac                              = PMAC_STRUCT(hHal);
+    tANI_U8 numChannels                              = 0;
+    tANI_U8 i                                        = 0;
+    tANI_U32 totValidChannels                 = WNI_CFG_VALID_CHANNEL_LIST_LEN;
+
+    if (!aValidChannels || !pNumChannels) {
+        smsLog(pMac, VOS_TRACE_LEVEL_ERROR,
+               FL("Output channel list/NumChannels is NULL"));
+        return eHAL_STATUS_INVALID_PARAMETER;
+    }
+
+    if ((wifiBand < WIFI_BAND_UNSPECIFIED) || (wifiBand >= WIFI_BAND_MAX)) {
+        smsLog(pMac, VOS_TRACE_LEVEL_ERROR,
+                     FL("Invalid wifiBand (%d)"), wifiBand);
+        return eHAL_STATUS_INVALID_PARAMETER;
+    }
+
+    status = sme_GetCfgValidChannels(hHal, &chanList[0],
+                                     &totValidChannels);
+    if (!HAL_STATUS_SUCCESS(status)) {
+        smsLog(pMac, VOS_TRACE_LEVEL_ERROR,
+               FL("Failed to get valid channel list (err=%d)"), status);
+        return status;
+    }
+
+    switch (wifiBand) {
+    case WIFI_BAND_UNSPECIFIED:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO, FL("Unspecified wifiBand, "
+                         "return all (%d) valid channels"), totValidChannels);
+            numChannels = totValidChannels;
+            for (i = 0; i < totValidChannels; i++) {
+                aValidChannels[i] = vos_chan_to_freq(chanList[i]);
+            }
+            break;
+
+    case WIFI_BAND_BG:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO, FL("WIFI_BAND_BG (2.4 GHz)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if (CSR_IS_CHANNEL_24GHZ(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    case WIFI_BAND_A:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO,
+                          FL("WIFI_BAND_A (5 GHz without DFS)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if (CSR_IS_CHANNEL_5GHZ(chanList[i]) &&
+                             !CSR_IS_CHANNEL_DFS(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    case WIFI_BAND_ABG:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO,
+                          FL("WIFI_BAND_ABG (2.4 GHz + 5 GHz; no DFS)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if ((CSR_IS_CHANNEL_24GHZ(chanList[i]) ||
+                             CSR_IS_CHANNEL_5GHZ(chanList[i])) &&
+                             !CSR_IS_CHANNEL_DFS(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    case WIFI_BAND_A_DFS_ONLY:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO,
+                          FL("WIFI_BAND_A_DFS (5 GHz DFS only)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if (CSR_IS_CHANNEL_5GHZ(chanList[i]) &&
+                             CSR_IS_CHANNEL_DFS(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    case WIFI_BAND_A_WITH_DFS:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO,
+                          FL("WIFI_BAND_A_WITH_DFS (5 GHz with DFS)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if (CSR_IS_CHANNEL_5GHZ(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    case WIFI_BAND_ABG_WITH_DFS:
+            smsLog(pMac, VOS_TRACE_LEVEL_INFO,
+                     FL("WIFI_BAND_ABG_WITH_DFS (2.4 GHz + 5 GHz with DFS)"));
+            for (i = 0; i < totValidChannels; i++) {
+                if (CSR_IS_CHANNEL_24GHZ(chanList[i]) ||
+                             CSR_IS_CHANNEL_5GHZ(chanList[i])) {
+                    aValidChannels[numChannels++] =
+                                                 vos_chan_to_freq(chanList[i]);
+                }
+            }
+            break;
+
+    default:
+            smsLog(pMac, VOS_TRACE_LEVEL_ERROR,
+                    FL("Unknown wifiBand (%d))"), wifiBand);
+            return eHAL_STATUS_INVALID_PARAMETER;
+            break;
+    }
+    *pNumChannels = numChannels;
+
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanGetCapabilities
+    \brief  SME API to fetch extscan capabilities
+    \param  hHal
+    \param  pReq: extscan capabilities structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanGetCapabilities (tHalHandle hHal,
+                                     tSirGetExtScanCapabilitiesReqParams *pReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pReq;
+        vosMessage.type    = WDA_EXTSCAN_GET_CAPABILITIES_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanStart
+    \brief  SME API to issue extscan start
+    \param  hHal
+    \param  pStartCmd: extscan start structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanStart (tHalHandle hHal,
+                           tSirWifiScanCmdReqParams *pStartCmd)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pStartCmd;
+        vosMessage.type    = WDA_EXTSCAN_START_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ExtScanStop
+    \brief  SME API to issue extscan stop
+    \param  hHal
+    \param  pStopReq: extscan stop structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ExtScanStop(tHalHandle hHal, tSirExtScanStopReqParams *pStopReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pStopReq;
+        vosMessage.type    = WDA_EXTSCAN_STOP_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_SetBssHotlist
+    \brief  SME API to set BSSID hotlist
+    \param  hHal
+    \param  pSetHotListReq: extscan set hotlist structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_SetBssHotlist (tHalHandle hHal,
+                          tSirExtScanSetBssidHotListReqParams *pSetHotListReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pSetHotListReq;
+        vosMessage.type    = WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ResetBssHotlist
+    \brief  SME API to reset BSSID hotlist
+    \param  hHal
+    \param  pSetHotListReq: extscan set hotlist structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ResetBssHotlist (tHalHandle hHal,
+                              tSirExtScanResetBssidHotlistReqParams *pResetReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pResetReq;
+        vosMessage.type    = WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_SetSignificantChange
+    \brief  SME API to set significant change
+    \param  hHal
+    \param  pSetSignificantChangeReq: extscan set significant change structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_SetSignificantChange (tHalHandle hHal,
+                    tSirExtScanSetSigChangeReqParams *pSetSignificantChangeReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pSetSignificantChangeReq;
+        vosMessage.type    = WDA_EXTSCAN_SET_SIGNF_CHANGE_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_ResetSignificantChange
+    \brief  SME API to reset significant change
+    \param  hHal
+    \param  pResetReq: extscan reset significant change structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_ResetSignificantChange (tHalHandle hHal,
+                        tSirExtScanResetSignificantChangeReqParams *pResetReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pResetReq;
+        vosMessage.type    = WDA_EXTSCAN_RESET_SIGNF_CHANGE_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+/* ---------------------------------------------------------------------------
+    \fn sme_getCachedResults
+    \brief  SME API to get cached results
+    \param  hHal
+    \param  pCachedResultsReq: extscan get cached results structure
+    \- return eHalStatus
+    -------------------------------------------------------------------------*/
+eHalStatus sme_getCachedResults (tHalHandle hHal,
+                      tSirExtScanGetCachedResultsReqParams *pCachedResultsReq)
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+    vos_msg_t vosMessage;
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        /* Serialize the req through MC thread */
+        vosMessage.bodyptr = pCachedResultsReq;
+        vosMessage.type    = WDA_EXTSCAN_GET_CACHED_RESULTS_REQ;
+        vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+           status = eHAL_STATUS_FAILURE;
+
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+eHalStatus sme_ExtScanRegisterCallback (tHalHandle hHal,
+                         void (*pExtScanIndCb)(void *, const tANI_U16, void *))
+{
+    eHalStatus status    = eHAL_STATUS_SUCCESS;
+    tpAniSirGlobal pMac  = PMAC_STRUCT(hHal);
+
+    if (eHAL_STATUS_SUCCESS == (status = sme_AcquireGlobalLock(&pMac->sme))) {
+        pMac->sme.pExtScanIndCb = pExtScanIndCb;
+        sme_ReleaseGlobalLock(&pMac->sme);
+    }
+    return status;
+}
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
diff --git a/CORE/WDA/inc/wlan_qct_wda.h b/CORE/WDA/inc/wlan_qct_wda.h
index 61ce84a4d6d6..f084a773e95a 100644
--- a/CORE/WDA/inc/wlan_qct_wda.h
+++ b/CORE/WDA/inc/wlan_qct_wda.h
@@ -1353,6 +1353,19 @@ tSirRetStatus uMacPostCtrlMsg(void* pSirGlobal, tSirMbMsg* pMb);
 #define WDA_ROAM_PREAUTH_IND        SIR_HAL_ROAM_PREAUTH_IND
 
 #define WDA_TBTT_UPDATE_IND         SIR_HAL_TBTT_UPDATE_IND
+
+#ifdef FEATURE_WLAN_EXTSCAN
+#define WDA_EXTSCAN_GET_CAPABILITIES_REQ    SIR_HAL_EXTSCAN_GET_CAPABILITIES_REQ
+#define WDA_EXTSCAN_START_REQ               SIR_HAL_EXTSCAN_START_REQ
+#define WDA_EXTSCAN_STOP_REQ                SIR_HAL_EXTSCAN_STOP_REQ
+#define WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ   SIR_HAL_EXTSCAN_SET_BSS_HOTLIST_REQ
+#define WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ SIR_HAL_EXTSCAN_RESET_BSS_HOTLIST_REQ
+#define WDA_EXTSCAN_SET_SIGNF_CHANGE_REQ    SIR_HAL_EXTSCAN_SET_SIGNF_CHANGE_REQ
+#define WDA_EXTSCAN_RESET_SIGNF_CHANGE_REQ  SIR_HAL_EXTSCAN_RESET_SIGNF_CHANGE_REQ
+#define WDA_EXTSCAN_GET_CACHED_RESULTS_REQ  SIR_HAL_EXTSCAN_GET_CACHED_RESULTS_REQ
+
+#endif /* FEATURE_WLAN_EXTSCAN */
+
 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 ea107822465f..f1adc044d033 100644
--- a/Kbuild
+++ b/Kbuild
@@ -993,8 +993,9 @@ CDEFINES :=	-DANI_LITTLE_BYTE_ENDIAN \
 		-DFEATURE_WLAN_PAL_MEM_DISABLE \
                 -DQCA_SUPPORT_TXRX_VDEV_PAUSE_LL \
 		-DQCA_SUPPORT_TX_THROTTLE_LL \
-		-DWMI_INTERFACE_EVENT_LOGGING\
-		-DATH_SUPPORT_WAPI\
+		-DWMI_INTERFACE_EVENT_LOGGING \
+		-DATH_SUPPORT_WAPI \
+		-DFEATURE_WLAN_EXTSCAN
 
 ifeq ($(CONFIG_QCA_WIFI_SDIO), 1)
 CDEFINES +=     -DCONFIG_HL_SUPPORT \