qcacld: [HDD]Implementation of p2pgo restart for 3port concurrency

1) In 5Ghz band: if P2PGO is already started and STA comes
   up later then P2PGO will restart in STA's channel.
2) In 5Ghz band: if P2PGO will try to start after STA starts
   then P2PGO will pick STAs channel to start.

CRs-Fixed: 773311
Change-Id: I8a0365e2be2819f56529c7a1ba43ed078aa4af6b

10 files changed, 363 insertions, 68 deletions

diff --git a/CORE/HDD/inc/wlan_hdd_cfg.h b/CORE/HDD/inc/wlan_hdd_cfg.h
index 8fdea0c50ab7..eb8e88b1d716 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg.h
@@ -2609,14 +2609,19 @@ This feature requires the dependent cfg.ini "gRoamPrefer5GHz" set to 1 */
  * needs to follow STA's channel.
  */
 #define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME         "gEnableCustomConcRule1"
-#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MIN     ( 0 )
-#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MAX     ( 1 )
-#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_DEFAULT ( 0 )
+#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MIN     (0)
+#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MAX     (1)
+#define CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_DEFAULT (0)
+
+#define CFG_ENABLE_CUSTOM_CONC_RULE2_NAME         "gEnableCustomConcRule2"
+#define CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_MIN     (0)
+#define CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_MAX     (1)
+#define CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_DEFAULT (0)
 
 #define CFG_ENABLE_STA_CONNECTION_IN_5GHZ         "gEnableStaConnectionIn5Ghz"
-#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_MIN     ( 0 )
-#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_MAX     ( 1 )
-#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_DEFAULT ( 1 )
+#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_MIN     (0)
+#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_MAX     (1)
+#define CFG_ENABLE_STA_CONNECTION_IN_5GHZ_DEFAULT (1)
 
 #ifdef MDNS_OFFLOAD
 /*
@@ -3290,6 +3295,7 @@ typedef struct
    bool                        ipa_uc_sta_offload;
 #endif
    uint8_t                     conc_custom_rule1;
+   uint8_t                     conc_custom_rule2;
    uint8_t                     is_sta_connection_in_5gz_enabled;
 
 #ifdef MDNS_OFFLOAD
diff --git a/CORE/HDD/inc/wlan_hdd_hostapd.h b/CORE/HDD/inc/wlan_hdd_hostapd.h
index 5bbcb266bfc6..ff499bf9a912 100644
--- a/CORE/HDD/inc/wlan_hdd_hostapd.h
+++ b/CORE/HDD/inc/wlan_hdd_hostapd.h
@@ -112,4 +112,80 @@ hdd_set_sap_auth_offload(hdd_adapter_t *pHostapdAdapter, bool enabled)
 }
 #endif /* SAP_AUTH_OFFLOAD */
 
+/**
+ * hdd_is_sta_connection_pending() - This function will check if sta connection
+ *                                   is pending or not.
+ * @hdd_ctx: pointer to hdd context
+ *
+ * This function will return the status of flag is_sta_connection_pending
+ *
+ * Return: true or false
+ */
+static inline bool
+hdd_is_sta_connection_pending(hdd_context_t *hdd_ctx)
+{
+    bool status;
+    spin_lock(&hdd_ctx->sta_update_info_lock);
+    status = hdd_ctx->is_sta_connection_pending;
+    spin_unlock(&hdd_ctx->sta_update_info_lock);
+    return status;
+}
+
+/**
+ * hdd_change_sta_conn_pending_status() - This function will change the value
+ *                                        of is_sta_connection_pending
+ * @hdd_ctx: pointer to hdd context
+ * @value: value to set
+ *
+ * This function will change the value of is_sta_connection_pending
+ *
+ * Return: none
+ */
+static inline void
+hdd_change_sta_conn_pending_status(hdd_context_t *hdd_ctx,
+                                   bool value)
+{
+    spin_lock(&hdd_ctx->sta_update_info_lock);
+    hdd_ctx->is_sta_connection_pending = value;
+    spin_unlock(&hdd_ctx->sta_update_info_lock);
+}
+
+/**
+ * hdd_is_sap_restart_required() - This function will check if sap restart
+ *                                 is pending or not.
+ * @hdd_ctx: pointer to hdd context.
+ *
+ * This function will return the status of flag is_sap_restart_required.
+ *
+ * Return: true or false
+ */
+static inline bool
+hdd_is_sap_restart_required(hdd_context_t *hdd_ctx)
+{
+    bool status;
+    spin_lock(&hdd_ctx->sap_update_info_lock);
+    status = hdd_ctx->is_sap_restart_required;
+    spin_unlock(&hdd_ctx->sap_update_info_lock);
+    return status;
+}
+
+/**
+ * hdd_change_sap_restart_required_status() - This function will change the
+ *                                            value of is_sap_restart_required
+ * @hdd_ctx: pointer to hdd context
+ * @value: value to set
+ *
+ * This function will change the value of is_sap_restart_required
+ *
+ * Return: none
+ */
+static inline void
+hdd_change_sap_restart_required_status(hdd_context_t *hdd_ctx,
+                                       bool value)
+{
+    spin_lock(&hdd_ctx->sap_update_info_lock);
+    hdd_ctx->is_sap_restart_required = value;
+    spin_unlock(&hdd_ctx->sap_update_info_lock);
+}
+
 #endif    // end #if !defined( WLAN_HDD_HOSTAPD_H )
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 4ca42baa6609..0f1c1f37e090 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -1473,7 +1473,9 @@ struct hdd_context_s
 
     struct work_struct  sap_start_work;
     bool is_sap_restart_required;
+    bool is_sta_connection_pending;
     spinlock_t sap_update_info_lock;
+    spinlock_t sta_update_info_lock;
 
     v_U8_t dev_dfs_cac_status;
 
@@ -1723,9 +1725,10 @@ void wlan_hdd_disable_roaming(hdd_adapter_t *pAdapter);
 void wlan_hdd_enable_roaming(hdd_adapter_t *pAdapter);
 #endif
 int hdd_set_miracast_mode(hdd_adapter_t *pAdapter, tANI_U8 *command);
-VOS_STATUS wlan_hdd_check_con_channel_sap_and_sta(hdd_adapter_t *sta_adapter,
+VOS_STATUS wlan_hdd_check_custom_con_channel_rules(hdd_adapter_t *sta_adapter,
                                               hdd_adapter_t *ap_adapter,
                                               tCsrRoamProfile *roam_profile,
+                                              tScanResultHandle *scan_cache,
                                               bool *concurrent_chnl_same);
 #ifdef WLAN_FEATURE_MBSSID
 void wlan_hdd_stop_sap(hdd_adapter_t *ap_adapter);
diff --git a/CORE/HDD/inc/wlan_hdd_trace.h b/CORE/HDD/inc/wlan_hdd_trace.h
index 4208fdedc9e0..7ba56534e4c4 100644
--- a/CORE/HDD/inc/wlan_hdd_trace.h
+++ b/CORE/HDD/inc/wlan_hdd_trace.h
@@ -96,7 +96,10 @@ enum {
 	TRACE_CODE_HDD_CFG80211_SET_REKEY_DATA,
 	TRACE_CODE_HDD_UNSUPPORTED_IOCTL,
 	TRACE_CODE_HDD_SETROAMSCANCHANNELMINTIME_IOCTL,
-	TRACE_CODE_HDD_GETROAMSCANCHANNELMINTIME_IOCTL
+	TRACE_CODE_HDD_GETROAMSCANCHANNELMINTIME_IOCTL,
+	TRACE_CODE_HDD_STORE_JOIN_REQ,
+	TRACE_CODE_HDD_CLEAR_JOIN_REQ,
+	TRACE_CODE_HDD_ISSUE_JOIN_REQ,
 };
 
 extern void hddTraceDump(void *pMac, tpvosTraceRecord pRecord,
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index 1b75a1db83d0..6cbfb0d38157 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -63,9 +63,7 @@
 #include "wlan_hdd_tdls.h"
 #endif
 #include "sme_Api.h"
-#ifdef FEATURE_WLAN_FORCE_SAP_SCC
 #include "wlan_hdd_hostapd.h"
-#endif /* FEATURE_WLAN_FORCE_SAP_SCC */
 #ifdef IPA_OFFLOAD
 #include <wlan_hdd_ipa.h>
 #endif
@@ -1397,9 +1395,7 @@ static void hdd_sap_restart_handle(struct work_struct *work)
     }
     wlan_hdd_start_sap(sap_adapter);
 
-    spin_lock(&hdd_ctx->sap_update_info_lock);
-    hdd_ctx->is_sap_restart_required = false;
-    spin_unlock(&hdd_ctx->sap_update_info_lock);
+    hdd_change_sap_restart_required_status(hdd_ctx, false);
     vos_ssr_unprotect(__func__);
 }
 
@@ -1528,7 +1524,8 @@ static eHalStatus hdd_AssociationCompletionHandler( hdd_adapter_t *pAdapter, tCs
 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
         if ((pHddCtx->cfg_ini->WlanMccToSccSwitchMode
                 != VOS_MCC_TO_SCC_SWITCH_DISABLE) &&
-            (0 == pHddCtx->cfg_ini->conc_custom_rule1)
+            ((0 == pHddCtx->cfg_ini->conc_custom_rule1) &&
+             (0 == pHddCtx->cfg_ini->conc_custom_rule2))
 #ifdef FEATURE_WLAN_STA_AP_MODE_DFS_DISABLE
             && !VOS_IS_DFS_CH(pHddStaCtx->conn_info.operationChannel)
 #endif
@@ -1952,7 +1949,7 @@ static eHalStatus hdd_AssociationCompletionHandler( hdd_adapter_t *pAdapter, tCs
     }
 
     if (pHddCtx->cfg_ini->conc_custom_rule1 &&
-        (true == pHddCtx->is_sap_restart_required)) {
+        (true == hdd_is_sap_restart_required(pHddCtx))) {
         sap_adapter = hdd_get_adapter(pHddCtx, WLAN_HDD_SOFTAP);
         if (sap_adapter == NULL) {
             VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
diff --git a/CORE/HDD/src/wlan_hdd_cfg.c b/CORE/HDD/src/wlan_hdd_cfg.c
index 0260b03c6d96..86f466c7ffc8 100644
--- a/CORE/HDD/src/wlan_hdd_cfg.c
+++ b/CORE/HDD/src/wlan_hdd_cfg.c
@@ -3413,6 +3413,13 @@ REG_TABLE_ENTRY g_registry_table[] =
                  CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MIN,
                  CFG_ENABLE_CUSTOM_CONC_RULE1_NAME_MAX),
 
+   REG_VARIABLE( CFG_ENABLE_CUSTOM_CONC_RULE2_NAME,  WLAN_PARAM_Integer,
+                 hdd_config_t, conc_custom_rule2,
+                 VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK,
+                 CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_DEFAULT,
+                 CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_MIN,
+                 CFG_ENABLE_CUSTOM_CONC_RULE2_NAME_MAX),
+
    REG_VARIABLE( CFG_ENABLE_STA_CONNECTION_IN_5GHZ,  WLAN_PARAM_Integer,
                  hdd_config_t, is_sta_connection_in_5gz_enabled,
                  VAR_FLAGS_OPTIONAL | VAR_FLAGS_RANGE_CHECK,
@@ -5995,6 +6002,8 @@ VOS_STATUS hdd_set_sme_config( hdd_context_t *pHddCtx )
 #endif
    smeConfig->csrConfig.conc_custom_rule1 =
                         pHddCtx->cfg_ini->conc_custom_rule1;
+   smeConfig->csrConfig.conc_custom_rule2 =
+                        pHddCtx->cfg_ini->conc_custom_rule2;
    smeConfig->csrConfig.is_sta_connection_in_5gz_enabled =
                         pHddCtx->cfg_ini->is_sta_connection_in_5gz_enabled;
 #ifdef FEATURE_BUS_AUTO_SUSPEND
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 57305ffbf323..83fbbf2e3852 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -7571,9 +7571,7 @@ static int wlan_hdd_cfg80211_stop_ap (struct wiphy *wiphy,
         vos_flush_work(&pHddCtx->sap_start_work);
         VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,
                   FL("Canceled the pending restart work"));
-        spin_lock(&pHddCtx->sap_update_info_lock);
-        pHddCtx->is_sap_restart_required = false;
-        spin_unlock(&pHddCtx->sap_update_info_lock);
+        hdd_change_sap_restart_required_status(pHddCtx, false);
     }
 
     hdd_hostapd_stop(dev);
@@ -10629,6 +10627,155 @@ void hdd_select_cbmode( hdd_adapter_t *pAdapter,v_U8_t operationChannel)
                      WLAN_HDD_GET_CTX(pAdapter)->cfg_ini->vhtChannelWidth);
 }
 
+/**
+ * wlan_hdd_sta_sap_concur_handle() - This function will handle Station and sap
+ *                                    concurrency.
+ * @hdd_ctx: pointer to hdd context.
+ * @sta_adapter: pointer to station adapter.
+ * @roam_profile: pointer to station's roam profile.
+ *
+ * This function will find the AP to which station is likely to make the
+ * the connection, if that AP's channel happens to be different than
+ * SAP's channel then this function will stop the SAP.
+ *
+ * Return: true or false based on function's overall success.
+ */
+static bool wlan_hdd_sta_sap_concur_handle(hdd_context_t *hdd_ctx,
+                                           hdd_adapter_t *sta_adapter,
+                                           tCsrRoamProfile *roam_profile)
+{
+    hdd_adapter_t *ap_adapter = hdd_get_adapter(hdd_ctx,
+                                               WLAN_HDD_SOFTAP);
+    bool are_cc_channels_same = false;
+    tScanResultHandle scan_cache = NULL;
+    VOS_STATUS status;
+
+    if ((ap_adapter != NULL) &&
+        test_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags)) {
+        status =
+         wlan_hdd_check_custom_con_channel_rules(sta_adapter, ap_adapter,
+                                                 roam_profile, &scan_cache,
+                                                 &are_cc_channels_same);
+        sme_ScanResultPurge(WLAN_HDD_GET_HAL_CTX(sta_adapter),
+                            scan_cache);
+        /*
+         * are_cc_channels_same will be false incase if SAP and STA
+         * channel is different or STA channel is zero.
+         * incase if STA channel is zero then lets stop the AP and
+         * restart flag set, so later whenever STA channel is defined
+         * we can restart our SAP in that channel.
+         */
+        if (false == are_cc_channels_same) {
+            hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                   FL("Stop AP due to mismatch with STA channel"));
+            wlan_hdd_stop_sap(ap_adapter);
+            hdd_change_sap_restart_required_status(hdd_ctx, true);
+            return false;
+        } else {
+            hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                   FL("sap channels are same"));
+        }
+    }
+    return true;
+}
+
+#ifdef FEATURE_WLAN_CH_AVOID
+/**
+ * wlan_hdd_sta_p2pgo_concur_handle() - This function will handle Station and GO
+ *                                      concurrency.
+ * @hdd_ctx: pointer to hdd context.
+ * @sta_adapter: pointer to station adapter.
+ * @roam_profile: pointer to station's roam profile.
+ * @roam_id: reference to roam_id variable being passed.
+ *
+ * This function will find the AP to which station is likely to make the
+ * the connection, if that AP's channel happens to be different than our
+ * P2PGO's channel then this function will send avoid frequency event to
+ * framework to make P2PGO stop and also caches station's connect request.
+ *
+ * Return: true or false based on function's overall success.
+ */
+static bool wlan_hdd_sta_p2pgo_concur_handle(hdd_context_t *hdd_ctx,
+                                             hdd_adapter_t *sta_adapter,
+                                             tCsrRoamProfile *roam_profile,
+                                             uint32_t *roam_id)
+{
+    hdd_adapter_t *p2pgo_adapter = hdd_get_adapter(hdd_ctx,
+                                               WLAN_HDD_P2P_GO);
+    bool are_cc_channels_same = false;
+    tScanResultHandle scan_cache = NULL;
+    uint32_t p2pgo_channel_num, freq;
+    tHddAvoidFreqList   hdd_avoid_freq_list;
+    VOS_STATUS status;
+
+    if ((p2pgo_adapter != NULL) &&
+        test_bit(SOFTAP_BSS_STARTED, &p2pgo_adapter->event_flags)) {
+        status =
+         wlan_hdd_check_custom_con_channel_rules(sta_adapter, p2pgo_adapter,
+                                                 roam_profile, &scan_cache,
+                                                 &are_cc_channels_same);
+        /*
+         * are_cc_channels_same will be false incase if P2PGO and STA
+         * channel is different or STA channel is zero.
+         */
+        if (false == are_cc_channels_same) {
+            if (true == hdd_is_sta_connection_pending(hdd_ctx)) {
+                MTRACE(vos_trace(VOS_MODULE_ID_HDD,
+                       TRACE_CODE_HDD_CLEAR_JOIN_REQ,
+                       sta_adapter->sessionId, *roam_id));
+                sme_clear_joinreq_param(WLAN_HDD_GET_HAL_CTX(sta_adapter),
+                                        sta_adapter->sessionId);
+                hdd_change_sta_conn_pending_status(hdd_ctx, false);
+                hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                       FL("===>Clear pending join req"));
+            }
+            MTRACE(vos_trace(VOS_MODULE_ID_HDD,
+                   TRACE_CODE_HDD_STORE_JOIN_REQ,
+                   sta_adapter->sessionId, *roam_id));
+            /* store the scan cache here */
+            sme_store_joinreq_param(WLAN_HDD_GET_HAL_CTX(sta_adapter),
+                                    roam_profile,
+                                    scan_cache,
+                                    roam_id,
+                                    sta_adapter->sessionId);
+            hdd_change_sta_conn_pending_status(hdd_ctx, true);
+            /*
+             * fill frequency avoidance event and send it up
+             * so, p2pgo stop event should get trigger from upper layer
+             */
+            p2pgo_channel_num =
+              WLAN_HDD_GET_AP_CTX_PTR(p2pgo_adapter)->sapConfig.channel;
+            if (p2pgo_channel_num <= ARRAY_SIZE(hdd_channels_2_4_GHZ)) {
+                freq = ieee80211_channel_to_frequency(p2pgo_channel_num,
+                                                   IEEE80211_BAND_2GHZ);
+            } else {
+                freq = ieee80211_channel_to_frequency(p2pgo_channel_num,
+                                                   IEEE80211_BAND_5GHZ);
+            }
+            vos_mem_zero(&hdd_avoid_freq_list,
+                         sizeof(hdd_avoid_freq_list));
+            hdd_avoid_freq_list.avoidFreqRangeCount = 1;
+            hdd_avoid_freq_list.avoidFreqRange[0].startFreq = freq;
+            hdd_avoid_freq_list.avoidFreqRange[0].endFreq = freq;
+            wlan_hdd_send_avoid_freq_event(hdd_ctx,
+                                           &hdd_avoid_freq_list);
+            hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                   FL("===>Sending chnl_avoid ch[%d] freq[%d]"),
+                   p2pgo_channel_num, freq);
+            hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                   FL("===>Stop GO due to mismatch with STA channel"));
+            return false;
+        } else {
+            hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                   FL("===>p2pgo channels are same"));
+            sme_ScanResultPurge(WLAN_HDD_GET_HAL_CTX(sta_adapter),
+                                scan_cache);
+        }
+    }
+    return true;
+}
+#endif
+
 /*
  * FUNCTION: wlan_hdd_cfg80211_connect_start
  * This function is used to start the association process
@@ -10642,8 +10789,6 @@ int wlan_hdd_cfg80211_connect_start( hdd_adapter_t  *pAdapter,
     v_U32_t roamId;
     tCsrRoamProfile *pRoamProfile;
     eCsrAuthType RSNAuthType;
-    hdd_adapter_t *ap_adapter = NULL;
-    bool are_cc_channels_same = 0;
 
     ENTER();
 
@@ -10825,39 +10970,33 @@ int wlan_hdd_cfg80211_connect_start( hdd_adapter_t  *pAdapter,
             pRoamProfile->pAddIEScan = &pAdapter->scan_info.scanAddIE.addIEdata[0];
             pRoamProfile->nAddIEScanLength = pAdapter->scan_info.scanAddIE.length;
         }
+        /*
+         * Custom concurrency rule1: As per this rule if station is trying to
+         * connect to some AP in 2.4Ghz and SAP is already in started state then
+         * SAP should restart in station's channel.
+         */
         if (pHddCtx->cfg_ini->conc_custom_rule1 &&
             (WLAN_HDD_INFRA_STATION == pAdapter->device_mode)) {
-            ap_adapter = hdd_get_adapter(pHddCtx, WLAN_HDD_SOFTAP);
-
-            if ((ap_adapter != NULL) &&
-                test_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags)) {
-                status =
-                 wlan_hdd_check_con_channel_sap_and_sta(pAdapter, ap_adapter,
-                                                    pRoamProfile,
-                                                    &are_cc_channels_same);
-                /*
-                 * are_cc_channels_same will be false incase if SAP and STA
-                 * channel is different or STA channel is zero.
-                 * incase if STA channel is zero then lets stop the AP and
-                 * restart flag set, so later whenever STA channel is defined
-                 * we can restart our SAP in that channel.
-                 */
-                if (FALSE == are_cc_channels_same) {
-                    VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
-                              FL("Stop AP due to mismatch with STA channel"));
-                    wlan_hdd_stop_sap(ap_adapter);
-                    spin_lock(&pHddCtx->sap_update_info_lock);
-                    pHddCtx->is_sap_restart_required = true;
-                    spin_unlock(&pHddCtx->sap_update_info_lock);
-                } else {
-                    VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
-                              FL("channels are same"));
-                }
-            } else {
-                VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_LOW,
-                          FL("extracted ap adapter is null"));
+
+            wlan_hdd_sta_sap_concur_handle (pHddCtx, pAdapter, pRoamProfile);
+        }
+#ifdef FEATURE_WLAN_CH_AVOID
+        /*
+         * Custom concurrency rule2: As per this rule if station is trying to
+         * connect to some AP in 5Ghz and P2PGO is already in started state then
+         * P2PGO should restart in station's channel.
+         */
+        if (pHddCtx->cfg_ini->conc_custom_rule2 &&
+            (WLAN_HDD_INFRA_STATION == pAdapter->device_mode)) {
+            if (false ==
+                wlan_hdd_sta_p2pgo_concur_handle(pHddCtx, pAdapter,
+                                                 pRoamProfile, &roamId)) {
+                hddLog(VOS_TRACE_LEVEL_ERROR,
+                       FL("P2PGO - STA chnl diff, cached join req"));
+                return 0;
             }
         }
+#endif
         status = sme_RoamConnect( WLAN_HDD_GET_HAL_CTX(pAdapter),
                             pAdapter->sessionId, pRoamProfile, &roamId);
 
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index 3bd80a90479b..f89191f623e1 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -777,6 +777,46 @@ end:
 }
 #endif /* SAP_AUTH_OFFLOAD */
 
+/**
+ * hdd_issue_stored_joinreq() - This function will trigger stations's
+ *                              cached connect request to proceed.
+ * @hdd_ctx: pointer to hdd context.
+ * @sta_adapter: pointer to station adapter.
+ *
+ * This function will call SME to release station's stored/cached connect
+ * request to proceed.
+ *
+ * Return: none.
+ */
+static void hdd_issue_stored_joinreq(hdd_adapter_t *sta_adapter,
+                              hdd_context_t *hdd_ctx)
+{
+    tHalHandle hal_handle;
+    uint32_t roam_id;
+
+    if (NULL == sta_adapter) {
+        hddLog(VOS_TRACE_LEVEL_ERROR,
+               FL("Invalid station adapter, ignore issueing join req"));
+        return;
+    }
+    hal_handle = WLAN_HDD_GET_HAL_CTX(sta_adapter);
+
+    if (true ==  hdd_is_sta_connection_pending(hdd_ctx)) {
+        MTRACE(vos_trace(VOS_MODULE_ID_HDD,
+                         TRACE_CODE_HDD_ISSUE_JOIN_REQ,
+                         sta_adapter->sessionId, roam_id));
+        if (VOS_STATUS_SUCCESS !=
+              sme_issue_stored_joinreq(hal_handle,
+                                       &roam_id,
+                                       sta_adapter->sessionId)) {
+            /* change back to NotAssociated */
+            hdd_connSetConnectionState(sta_adapter,
+                                       eConnectionState_NotConnected);
+        }
+        hdd_change_sta_conn_pending_status(hdd_ctx, false);
+    }
+}
+
 VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCallback)
 {
     hdd_adapter_t *pHostapdAdapter;
@@ -1090,6 +1130,15 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
                 pHddApCtx->dfs_cac_block_tx = TRUE;
                 pHddCtx->dev_dfs_cac_status = DFS_CAC_NEVER_DONE;
             }
+            if (pHddCtx->cfg_ini->conc_custom_rule2 &&
+                (WLAN_HDD_P2P_GO == pHostapdAdapter->device_mode)) {
+
+                hdd_adapter_t *sta_adapter = hdd_get_adapter(pHddCtx,
+                                                WLAN_HDD_INFRA_STATION);
+                hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
+                       FL("P2PGO is going down now"));
+                hdd_issue_stored_joinreq(sta_adapter, pHddCtx);
+            }
             goto stopbss;
 
         case eSAP_DFS_CAC_START:
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index a980f4055935..6f2ed593e54d 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -10043,9 +10043,7 @@ VOS_STATUS hdd_stop_adapter( hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
              vos_flush_work(&pHddCtx->sap_start_work);
              VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
                         FL("Canceled the pending SAP restart work"));
-             spin_lock(&pHddCtx->sap_update_info_lock);
-             pHddCtx->is_sap_restart_required = false;
-             spin_unlock(&pHddCtx->sap_update_info_lock);
+             hdd_change_sap_restart_required_status(pHddCtx, false);
          }
          //Any softap specific cleanup here...
          if (pAdapter->device_mode == WLAN_HDD_P2P_GO) {
@@ -12084,8 +12082,10 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
    tSmeThermalParams thermalParam;
    tSirTxPowerLimit *hddtxlimit;
 #ifdef FEATURE_WLAN_CH_AVOID
+#ifdef CONFIG_CNSS
    int unsafeChannelIndex;
 #endif
+#endif
    tANI_U8 rtnl_lock_enable;
    tANI_U8 reg_netdev_notifier_done = FALSE;
    hdd_adapter_t *dot11_adapter = NULL;
@@ -12418,6 +12418,7 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
    }
 
 #ifdef FEATURE_WLAN_CH_AVOID
+#ifdef CONFIG_CNSS
    cnss_get_wlan_unsafe_channel(pHddCtx->unsafe_channel_list,
                                 &(pHddCtx->unsafe_channel_count),
                                 sizeof(v_U16_t) * NUM_20MHZ_RF_CHANNELS);
@@ -12433,10 +12434,10 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
               __func__, pHddCtx->unsafe_channel_list[unsafeChannelIndex]);
 
    }
-
    /* Plug in avoid channel notification callback */
    sme_AddChAvoidCallback(pHddCtx->hHal,
                           hdd_ch_avoid_cb);
+#endif
 #endif /* FEATURE_WLAN_CH_AVOID */
 
    status = hdd_post_voss_start_config( pHddCtx );
@@ -14635,8 +14636,8 @@ void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *data)
 #endif
 
 /**
- * wlan_hdd_check_con_channel_sap_and_sta() - This function checks the sap's
- *                                            and sta's operating channel.
+ * wlan_hdd_check_custom_con_channel_rules() - This function checks the sap's
+ *                                             and sta's operating channel.
  * @sta_adapter:  Describe the first argument to foobar.
  * @ap_adapter:   Describe the second argument to foobar.
  * @roam_profile: Roam profile of AP to which STA wants to connect.
@@ -14650,31 +14651,39 @@ void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *data)
  *
  * Return: VOS_STATUS_SUCCESS or VOS_STATUS_E_FAILURE.
  */
-VOS_STATUS wlan_hdd_check_con_channel_sap_and_sta(hdd_adapter_t *sta_adapter,
+VOS_STATUS wlan_hdd_check_custom_con_channel_rules(hdd_adapter_t *sta_adapter,
                                                   hdd_adapter_t *ap_adapter,
                                                   tCsrRoamProfile *roam_profile,
+                                                  tScanResultHandle *scan_cache,
                                                   bool *concurrent_chnl_same)
 {
     hdd_ap_ctx_t *hdd_ap_ctx;
     uint8_t channel_id;
     VOS_STATUS status;
+    device_mode_t device_mode = ap_adapter->device_mode;
+    *concurrent_chnl_same = true;
 
     hdd_ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(ap_adapter);
     status =
      sme_get_ap_channel_from_scan_cache(WLAN_HDD_GET_HAL_CTX(sta_adapter),
                                         roam_profile,
+                                        scan_cache,
                                         &channel_id);
     if ((VOS_STATUS_SUCCESS == status)) {
-        if (channel_id < SIR_11A_CHANNEL_BEGIN) {
-            if (hdd_ap_ctx->sapConfig.channel != channel_id) {
-                *concurrent_chnl_same = FALSE;
-                VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,
-                         FL("channels are different"));
-            }
-        } else {
-           *concurrent_chnl_same = TRUE;
-           VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_MED,
-                    FL("selected ap's channel in 5Ghz"));
+        if ((WLAN_HDD_SOFTAP == device_mode) &&
+            (channel_id < SIR_11A_CHANNEL_BEGIN)) {
+             if (hdd_ap_ctx->sapConfig.channel != channel_id) {
+                 *concurrent_chnl_same = false;
+                  hddLog(VOS_TRACE_LEVEL_INFO_MED,
+                            FL("channels are different"));
+             }
+        } else if ((WLAN_HDD_P2P_GO == device_mode) &&
+                   (channel_id >= SIR_11A_CHANNEL_BEGIN)) {
+             if (hdd_ap_ctx->sapConfig.channel != channel_id) {
+                 *concurrent_chnl_same = false;
+                 hddLog(VOS_TRACE_LEVEL_INFO_MED,
+                           FL("channels are different"));
+             }
         }
     } else {
         /*
@@ -14683,8 +14692,8 @@ VOS_STATUS wlan_hdd_check_con_channel_sap_and_sta(hdd_adapter_t *sta_adapter,
          * SAP's channel and STA's channel. Return the status as failure so
          * caller function could know that scan look up is failed.
          */
-        *concurrent_chnl_same = FALSE;
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+        *concurrent_chnl_same = false;
+        hddLog(VOS_TRACE_LEVEL_ERROR,
                     FL("Finding AP from scan cache failed"));
         return VOS_STATUS_E_FAILURE;
     }
diff --git a/CORE/HDD/src/wlan_hdd_trace.c b/CORE/HDD/src/wlan_hdd_trace.c
index f7d683e6522a..f4a25b49b50e 100644
--- a/CORE/HDD/src/wlan_hdd_trace.c
+++ b/CORE/HDD/src/wlan_hdd_trace.c
@@ -99,6 +99,10 @@ static tANI_U8 *hddTraceGetEventString(tANI_U32 code)
 		    (TRACE_CODE_HDD_SETROAMSCANCHANNELMINTIME_IOCTL);
 		CASE_RETURN_STRING
 		    (TRACE_CODE_HDD_GETROAMSCANCHANNELMINTIME_IOCTL);
+		CASE_RETURN_STRING(TRACE_CODE_HDD_STORE_JOIN_REQ);
+		CASE_RETURN_STRING(TRACE_CODE_HDD_CLEAR_JOIN_REQ);
+		CASE_RETURN_STRING(TRACE_CODE_HDD_ISSUE_JOIN_REQ);
+
 	default:
 		return ("UNKNOWN");
 		break;