qcacld-3.0: Move SAP to 2.4 GHz if GO is in 5 GHz

For mcc to scc switch config QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL,
if GO is on 5/6 GHz, SAP is not allowed to active on 5/6 GHz, SAP should
move to 2.4 GHz, If GO is not present on 5/6 GHz, SAP needs to move to
5/6 GHz user configured frequency.

Change-Id: I4ba99460fe5656440c6010afcb0ebbc9c0f4de76
CRs-Fixed: 3624311

components/cmn_services/interface_mgr/src/wlan_if_mgr_sap.c

@@ -135,6 +135,7 @@ if_mgr_ap_stop_bss_complete(struct wlan_objmgr_vdev *vdev,
 {
 	struct wlan_objmgr_psoc *psoc;
 	struct wlan_objmgr_pdev *pdev;
+	uint8_t mcc_scc_switch;
 
 	pdev = wlan_vdev_get_pdev(vdev);
 	if (!pdev)
@@ -160,6 +161,11 @@ if_mgr_ap_stop_bss_complete(struct wlan_objmgr_vdev *vdev,
 		if_mgr_enable_roaming(pdev, vdev, RSO_START_BSS);
 	}
 
+	policy_mgr_get_mcc_scc_switch(psoc, &mcc_scc_switch);
+	if (wlan_vdev_mlme_get_opmode(vdev) == QDF_P2P_GO_MODE &&
+	    mcc_scc_switch == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)
+		policy_mgr_check_concurrent_intf_and_restart_sap(psoc, false);
+
 	return QDF_STATUS_SUCCESS;
 }
 

components/cmn_services/policy_mgr/inc/wlan_policy_mgr_api.h

@@ -1565,6 +1565,25 @@ void policy_mgr_check_scc_channel(struct wlan_objmgr_psoc *psoc,
 				  qdf_freq_t sap_ch_freq,
 				  uint8_t vdev_id, uint8_t cc_mode);
 
+/**
+ * policy_mgr_handle_go_sap_fav_channel() - Get preferred force SCC
+ * channel frequency using favorite mandatory channel list for GO+SAP
+ * concurrency
+ * @psoc: Pointer to Psoc
+ * @vdev_id: vdev id
+ * @sap_ch_freq: sap/go channel starting channel frequency
+ * @intf_ch_freq: prefer force scc frequency
+ *
+ * SAP should move to 2.4 GHz if P2P GO is on 5G/6G. SAP should move to user
+ * configured channel after P2P GO is stopped
+ *
+ * Return: QDF_STATUS_SUCCESS if a valid favorite SAP channel is found
+ */
+QDF_STATUS
+policy_mgr_handle_go_sap_fav_channel(struct wlan_objmgr_psoc *psoc,
+				     uint8_t vdev_id, qdf_freq_t sap_ch_freq,
+				     qdf_freq_t *intf_ch_freq);
+
 /**
  * policy_mgr_nan_sap_pre_enable_conc_check() - Check if NAN+SAP SCC is
  *                                              allowed in given ch

components/cmn_services/policy_mgr/src/wlan_policy_mgr_action.c

@@ -1839,6 +1839,7 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 	uint8_t num_cxn_del = 0;
 	QDF_STATUS status;
 	uint32_t sta_gc_present = 0;
+	bool go_5g_present = 0;
 	qdf_freq_t user_config_freq = 0;
 	tQDF_MCC_TO_SCC_SWITCH_MODE cc_mode =
 				policy_mgr_get_mcc_to_scc_switch_mode(psoc);
@@ -1868,6 +1869,13 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 					psoc, &op_ch_freq_list[cc_count],
 					&vdev_id[cc_count], PM_P2P_GO_MODE);
 
+	for (i = go_index_start ; i < cc_count; i++) {
+		if (!WLAN_REG_IS_24GHZ_CH_FREQ(op_ch_freq_list[i])) {
+			go_5g_present = true;
+			break;
+		}
+	}
+
 	sta_gc_present =
 		policy_mgr_mode_specific_connection_count(psoc,
 							  PM_STA_MODE, NULL) +
@@ -1942,11 +1950,18 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 		 * currently not on the user configured frequency.
 		 * else move the SAP only when SAP is on 2.4 GHz band and user
 		 * configured frequency is on any other bands.
+		 * And for QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL, if GO
+		 * is on 5/6 GHz, SAP is not allowed to move back to 5/6 GHz.
+		 * If GO is not present on 5/6 GHz, SAP need to moved to
+		 * user configured frequency.
 		 */
 		if (!sta_gc_present && user_config_freq &&
 		    cc_mode == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL &&
 		    !wlan_reg_is_same_band_freqs(user_config_freq,
 						 op_ch_freq_list[i])) {
+			if (go_5g_present &&
+			    !WLAN_REG_IS_24GHZ_CH_FREQ(user_config_freq))
+				continue;
 			curr_sap_freq = op_ch_freq_list[i];
 			policy_mgr_debug("Move sap to user configured freq: %d",
 					 user_config_freq);
@@ -2023,7 +2038,7 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 		return true;
 
 	*intf_ch_freq = new_sap_freq;
-	policy_mgr_debug("Standalone SAP(vdev_id %d) is not allowed on DFS/Unsafe channel, Move it to channel %u",
+	policy_mgr_debug("Standalone SAP(vdev_id %d) will be moved to channel %u",
 			 sap_vdev_id, *intf_ch_freq);
 
 	return true;
@@ -2588,6 +2603,10 @@ policy_mgr_check_sap_go_force_scc(struct wlan_objmgr_psoc *psoc,
 		policy_mgr_err("Invalid Context");
 		return QDF_STATUS_E_INVAL;
 	}
+	if (pm_ctx->cfg.mcc_to_scc_switch ==
+		QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)
+		return QDF_STATUS_SUCCESS;
+
 	if (!vdev) {
 		policy_mgr_err("vdev is null");
 		return QDF_STATUS_E_INVAL;
@@ -2828,10 +2847,40 @@ end:
 void policy_mgr_check_sta_ap_concurrent_ch_intf(void *data)
 {
 	struct qdf_op_sync *op_sync;
+	struct policy_mgr_psoc_priv_obj *pm_ctx = data;
+	int ret;
 
-	if (qdf_op_protect(&op_sync))
+	if (!pm_ctx) {
+		policy_mgr_err("Invalid context");
 		return;
+	}
 
+	ret = qdf_op_protect(&op_sync);
+	if (ret) {
+		if (ret == -EAGAIN) {
+			if (qdf_is_driver_unloading() ||
+			    qdf_is_recovering() ||
+			    qdf_is_driver_state_module_stop()) {
+				policy_mgr_debug("driver not ready");
+				return;
+			}
+
+			if (!pm_ctx->sta_ap_intf_check_work_info)
+				return;
+
+			pm_ctx->work_fail_count++;
+			policy_mgr_debug("qdf_op start fail, ret %d, work_fail_count %d",
+					 ret, pm_ctx->work_fail_count);
+			if (pm_ctx->work_fail_count > 1) {
+				pm_ctx->work_fail_count = 0;
+				return;
+			}
+			qdf_delayed_work_start(&pm_ctx->sta_ap_intf_check_work,
+					       SAP_CONC_CHECK_DEFER_TIMEOUT_MS);
+		}
+		return;
+	}
+	pm_ctx->work_fail_count = 0;
 	__policy_mgr_check_sta_ap_concurrent_ch_intf(data);
 
 	qdf_op_unprotect(op_sync);

components/cmn_services/policy_mgr/src/wlan_policy_mgr_core.c

@@ -4124,7 +4124,8 @@ policy_mgr_get_pref_force_scc_freq(struct wlan_objmgr_psoc *psoc,
 
 /**
  * policy_mgr_handle_sta_sap_fav_channel() - Get preferred force SCC
- * channel frequency using favorite mandatory channel list
+ * channel frequency using favorite mandatory channel list for STA+SAP
+ * concurrency
  * @psoc: Pointer to Psoc
  * @pm_ctx: pm ctx
  * @vdev_id: vdev id
@@ -4201,6 +4202,101 @@ policy_mgr_handle_sta_sap_fav_channel(struct wlan_objmgr_psoc *psoc,
 	return status;
 }
 
+QDF_STATUS
+policy_mgr_handle_go_sap_fav_channel(struct wlan_objmgr_psoc *psoc,
+				     uint8_t vdev_id, qdf_freq_t sap_ch_freq,
+				     qdf_freq_t *intf_ch_freq)
+{
+	QDF_STATUS status;
+	uint8_t go_count;
+	uint32_t op_ch_freq_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	uint8_t vdev_id_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	struct policy_mgr_pcl_list pcl;
+	uint32_t i;
+
+	go_count = policy_mgr_get_mode_specific_conn_info(psoc,
+							  op_ch_freq_list,
+							  vdev_id_list,
+							  PM_P2P_GO_MODE);
+	if (!go_count)
+		return QDF_STATUS_E_FAILURE;
+
+	/* According to requirement, SAP should move to 2.4 GHz if P2P GO is
+	 * on 5G/6G.
+	 */
+	if (WLAN_REG_IS_24GHZ_CH_FREQ(op_ch_freq_list[0]) ||
+	    WLAN_REG_IS_24GHZ_CH_FREQ(sap_ch_freq))
+		return QDF_STATUS_E_FAILURE;
+
+	qdf_mem_zero(&pcl, sizeof(pcl));
+	status = policy_mgr_get_pcl_for_existing_conn(
+			psoc, PM_SAP_MODE, pcl.pcl_list, &pcl.pcl_len,
+			pcl.weight_list, QDF_ARRAY_SIZE(pcl.weight_list),
+			false, vdev_id);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		policy_mgr_err("Unable to get PCL for SAP");
+		return status;
+	}
+
+	for (i = 0; i < pcl.pcl_len; i++) {
+		if (WLAN_REG_IS_24GHZ_CH_FREQ(pcl.pcl_list[i])) {
+			*intf_ch_freq = pcl.pcl_list[i];
+			policy_mgr_debug("sap move to %d because GO on %d",
+					 *intf_ch_freq, op_ch_freq_list[0]);
+			return QDF_STATUS_SUCCESS;
+		}
+	}
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * policy_mgr_handle_sap_fav_channel() - Get preferred force SCC
+ * channel frequency using favorite mandatory channel list
+ * @psoc: Pointer to Psoc
+ * @pm_ctx: pm ctx
+ * @vdev_id: vdev id
+ * @intf_ch_freq: prefer force scc frequency
+ * @sap_ch_freq: sap/go channel starting channel frequency
+ * @acs_band: acs band
+ *
+ * Return: QDF_STATUS_SUCCESS if a valid favorite mandatory force scc channel
+ * is found.
+ */
+static QDF_STATUS
+policy_mgr_handle_sap_fav_channel(struct wlan_objmgr_psoc *psoc,
+				  struct policy_mgr_psoc_priv_obj *pm_ctx,
+				  uint8_t vdev_id, qdf_freq_t sap_ch_freq,
+				  qdf_freq_t *intf_ch_freq,
+				  uint32_t acs_band)
+{
+	QDF_STATUS status;
+	uint8_t sta_count, go_count;
+
+	go_count = policy_mgr_mode_specific_connection_count(psoc,
+							     PM_P2P_GO_MODE,
+							     NULL);
+	if (go_count) {
+		status = policy_mgr_handle_go_sap_fav_channel(
+					psoc, vdev_id,
+					sap_ch_freq, intf_ch_freq);
+		if (QDF_IS_STATUS_SUCCESS(status) &&
+		    *intf_ch_freq && *intf_ch_freq != sap_ch_freq)
+			return QDF_STATUS_SUCCESS;
+	}
+
+	sta_count = policy_mgr_mode_specific_connection_count(psoc,
+							      PM_STA_MODE,
+							      NULL);
+	if (sta_count && sta_count < 2)
+		return policy_mgr_handle_sta_sap_fav_channel(
+					psoc, pm_ctx, vdev_id,
+					sap_ch_freq, intf_ch_freq,
+					acs_band);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
 void policy_mgr_check_scc_channel(struct wlan_objmgr_psoc *psoc,
 				  qdf_freq_t *intf_ch_freq,
 				  qdf_freq_t sap_ch_freq,
@@ -4236,11 +4332,11 @@ void policy_mgr_check_scc_channel(struct wlan_objmgr_psoc *psoc,
 			policy_mgr_debug("acs_band: %d", acs_band);
 	}
 
-	/* Handle STA + SAP mandaory freq cases */
-	if (sta_count && sta_count < 2 &&
-	    cc_mode == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL) {
-		status = policy_mgr_handle_sta_sap_fav_channel(psoc, pm_ctx,
-				vdev_id, sap_ch_freq, intf_ch_freq, acs_band);
+	/* Handle STA/P2P + SAP mandaory freq cases */
+	if (cc_mode == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL) {
+		status = policy_mgr_handle_sap_fav_channel(
+				psoc, pm_ctx, vdev_id, sap_ch_freq,
+				intf_ch_freq, acs_band);
 		if (QDF_IS_STATUS_SUCCESS(status))
 			return;
 		policy_mgr_debug("no mandatory channels (%d, %d)", sap_ch_freq,

components/cmn_services/policy_mgr/src/wlan_policy_mgr_get_set_utils.c

@@ -11696,6 +11696,7 @@ bool policy_mgr_is_restart_sap_required(struct wlan_objmgr_psoc *psoc,
 	bool sap_found = false;
 	uint8_t num_mcc_conn = 0;
 	uint8_t num_scc_conn = 0;
+	uint8_t num_5_or_6_conn = 0;
 
 	pm_ctx = policy_mgr_get_context(psoc);
 	if (!pm_ctx) {
@@ -11718,10 +11719,14 @@ bool policy_mgr_is_restart_sap_required(struct wlan_objmgr_psoc *psoc,
 					      IEEE80211_CHAN_DFS_CFREQ2)))
 				sap_on_dfs = true;
 			sap_found = true;
-		} else if (connection[i].freq == freq) {
-			num_scc_conn++;
 		} else {
-			num_mcc_conn++;
+			if (connection[i].freq == freq)
+				num_scc_conn++;
+			else
+				num_mcc_conn++;
+
+			if (!WLAN_REG_IS_24GHZ_CH_FREQ(connection[i].freq))
+				num_5_or_6_conn++;
 		}
 	}
 	if (!sap_found) {
@@ -11751,10 +11756,23 @@ bool policy_mgr_is_restart_sap_required(struct wlan_objmgr_psoc *psoc,
 		policy_mgr_get_sta_sap_scc_allowed_on_indoor_chnl(psoc);
 
 	for (i = 0; i < MAX_NUMBER_OF_CONC_CONNECTIONS; i++) {
+		if (!connection[i].in_use)
+			continue;
+
+		if (scc_mode == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL &&
+		    connection[i].mode == PM_P2P_GO_MODE &&
+		    connection[i].vdev_id != vdev_id &&
+		    policy_mgr_2_freq_always_on_same_mac(psoc, freq,
+							 connection[i].freq)) {
+			policy_mgr_debug("SAP:%d and GO:%d on same mac. Restart SAP ",
+					 freq, connection[i].freq);
+			restart_required = true;
+			break;
+		}
+
 		is_sta_p2p_cli =
-			connection[i].in_use &&
 			(connection[i].mode == PM_STA_MODE ||
-			connection[i].mode == PM_P2P_CLIENT_MODE);
+			 connection[i].mode == PM_P2P_CLIENT_MODE);
 		if (!is_sta_p2p_cli)
 			continue;
 
@@ -11830,6 +11848,17 @@ bool policy_mgr_is_restart_sap_required(struct wlan_objmgr_psoc *psoc,
 					 connection[i].freq, freq);
 			restart_required = true;
 		}
+
+		if (scc_mode == QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL &&
+		    connection[i].freq == freq &&
+		    WLAN_REG_IS_24GHZ_CH_FREQ(freq) &&
+		    !num_5_or_6_conn &&
+		    user_config_freq &&
+		    !WLAN_REG_IS_24GHZ_CH_FREQ(user_config_freq)) {
+			policy_mgr_debug("SAP move to user configure %d from %d",
+					 user_config_freq, freq);
+			restart_required = true;
+		}
 	}
 
 	if (!restart_required &&

components/cmn_services/policy_mgr/src/wlan_policy_mgr_i.h

@@ -350,6 +350,7 @@ struct policy_mgr_cfg {
  * @no_of_open_sessions: Number of active vdevs
  * @no_of_active_sessions: Number of active connections
  * @sta_ap_intf_check_work: delayed sap restart work
+ * @work_fail_count: sta_ap work schedule fail count
  * @nan_sap_conc_work: Info related to nan sap conc work
  * @num_dbs_hw_modes: Number of different HW modes supported
  * @hw_mode: List of HW modes supported
@@ -403,6 +404,7 @@ struct policy_mgr_psoc_priv_obj {
 	uint8_t no_of_open_sessions[QDF_MAX_NO_OF_MODE];
 	uint8_t no_of_active_sessions[QDF_MAX_NO_OF_MODE];
 	struct qdf_delayed_work sta_ap_intf_check_work;
+	uint8_t work_fail_count;
 	qdf_work_t nan_sap_conc_work;
 	uint32_t num_dbs_hw_modes;
 	struct dbs_hw_mode_info hw_mode;

components/cmn_services/policy_mgr/src/wlan_policy_mgr_pcl.c

@@ -3822,6 +3822,10 @@ QDF_STATUS policy_mgr_modify_sap_pcl_based_on_mandatory_channel(
 	bool sta_sap_scc_on_5ghz_channel;
 	bool scc_on_indoor =
 		 policy_mgr_get_sta_sap_scc_allowed_on_indoor_chnl(psoc);
+	uint8_t go_count;
+	uint32_t go_op_ch_freq_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	uint8_t go_vdev_id_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	uint32_t go_op_ch_freq_5g = 0;
 
 	pm_ctx = policy_mgr_get_context(psoc);
 	if (!pm_ctx) {
@@ -3855,6 +3859,14 @@ QDF_STATUS policy_mgr_modify_sap_pcl_based_on_mandatory_channel(
 	sta_sap_scc_on_5ghz_channel =
 		policy_mgr_is_connected_sta_5g(psoc, &sta_5GHz_freq);
 
+	go_count = policy_mgr_get_mode_specific_conn_info(
+				psoc, go_op_ch_freq_list,
+				go_vdev_id_list, PM_P2P_GO_MODE);
+	if (go_count && !WLAN_REG_IS_24GHZ_CH_FREQ(go_op_ch_freq_list[0])) {
+		go_op_ch_freq_5g = go_op_ch_freq_list[0];
+		policy_mgr_debug("go 5/6G present, SAP exclude 5/6G channels");
+	}
+
 	for (i = 0; i < *pcl_len_org; i++) {
 		found = false;
 		if (i >= NUM_CHANNELS) {
@@ -3862,6 +3874,10 @@ QDF_STATUS policy_mgr_modify_sap_pcl_based_on_mandatory_channel(
 			break;
 		}
 
+		if (go_op_ch_freq_5g &&
+		    !WLAN_REG_IS_24GHZ_CH_FREQ(pcl_list_org[i]))
+			continue;
+
 		if (scc_on_indoor && policy_mgr_is_force_scc(psoc) &&
 		    pcl_list_org[i] == indoor_sta_freq) {
 			policy_mgr_debug("indoor chan:%d", pcl_list_org[i]);
@@ -3981,9 +3997,8 @@ policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
 	mcc_to_scc_switch =
 		policy_mgr_get_mcc_to_scc_switch_mode(psoc);
 
-	sta_count =
-		policy_mgr_mode_specific_connection_count(psoc, PM_STA_MODE,
-							  NULL);
+	sta_count = policy_mgr_mode_specific_connection_count(psoc, PM_STA_MODE,
+							      NULL);
 
 	if (!sta_count || mcc_to_scc_switch !=
 			QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)
@@ -4091,7 +4106,7 @@ policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
 		if (user_config_freq && (pcl.pcl_list[i] == user_config_freq)) {
 			sap_new_freq = pcl.pcl_list[i];
 			policy_mgr_debug("Prefer starting SAP on user configured channel:%d",
-					 sap_ch_freq);
+					 sap_new_freq);
 			goto update_freq;
 		}
 	}

core/hdd/src/wlan_hdd_hostapd.c

@@ -7892,7 +7892,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	if (QDF_STATUS_SUCCESS !=
 	    ucfg_policy_mgr_get_sap_mandt_chnl(hdd_ctx->psoc, &mandt_chnl_list))
 		hdd_err("can't get mandatory channel list");
-	if (mandt_chnl_list)
+	if (mandt_chnl_list && adapter->device_mode == QDF_SAP_MODE)
 		policy_mgr_init_sap_mandatory_chan(hdd_ctx->psoc,
 						   chandef->chan->center_freq);
 

core/sap/src/sap_fsm.c

@@ -1015,6 +1015,10 @@ sap_process_force_scc_with_go_start(struct wlan_objmgr_psoc *psoc,
 	uint32_t con_freq;
 	enum phy_ch_width ch_width;
 
+	if (sap_context->cc_switch_mode ==
+			QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)
+		return false;
+
 	existing_vdev_id =
 		policy_mgr_fetch_existing_con_info(psoc,
 						   sap_context->sessionId,

core/sme/src/csr/csr_util.c

@@ -555,7 +555,8 @@ static void csr_handle_conc_chnl_overlap_for_sap_go(
 		struct csr_roam_session *session,
 		uint32_t *sap_ch_freq, uint32_t *sap_hbw, uint32_t *sap_cfreq,
 		uint32_t *intf_ch_freq, uint32_t *intf_hbw,
-		uint32_t *intf_cfreq, enum QDF_OPMODE op_mode)
+		uint32_t *intf_cfreq, enum QDF_OPMODE op_mode,
+		uint8_t cc_switch_mode)
 {
 	qdf_freq_t op_chan_freq;
 	qdf_freq_t freq_seg_0;
@@ -577,7 +578,10 @@ static void csr_handle_conc_chnl_overlap_for_sap_go(
 			*sap_ch_freq = op_chan_freq;
 			*sap_cfreq = freq_seg_0;
 			*sap_hbw = csr_get_half_bw(ch_width);
-		} else if (*sap_ch_freq != op_chan_freq) {
+		} else if (*sap_ch_freq != op_chan_freq ||
+			   (cc_switch_mode ==
+				QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL &&
+			    op_mode == QDF_P2P_GO_MODE)) {
 			*intf_ch_freq = op_chan_freq;
 			*intf_cfreq = freq_seg_0;
 			*intf_hbw = csr_get_half_bw(ch_width);
@@ -665,7 +669,8 @@ uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx,
 			csr_handle_conc_chnl_overlap_for_sap_go(mac_ctx,
 					session, &sap_ch_freq, &sap_hbw,
 					&sap_cfreq, &intf_ch_freq, &intf_hbw,
-					&intf_cfreq, op_mode);
+					&intf_cfreq, op_mode,
+					cc_switch_mode);
 		}
 		if (intf_ch_freq &&
 		    ((intf_ch_freq <= wlan_reg_ch_to_freq(CHAN_ENUM_2484) &&
@@ -703,6 +708,13 @@ uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx,
 					     cc_switch_mode);
 	} else if ((intf_ch_freq == sap_ch_freq) && (cc_switch_mode ==
 				QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL)) {
+		status = policy_mgr_handle_go_sap_fav_channel(
+					mac_ctx->psoc, vdev_id,
+					sap_ch_freq, &intf_ch_freq);
+		if (QDF_IS_STATUS_SUCCESS(status) &&
+		    intf_ch_freq && intf_ch_freq != sap_ch_freq)
+			goto end;
+
 		if (WLAN_REG_IS_24GHZ_CH_FREQ(intf_ch_freq) ||
 		    WLAN_REG_IS_6GHZ_CHAN_FREQ(sap_ch_freq)) {
 			status =
@@ -713,7 +725,7 @@ uint16_t csr_check_concurrent_channel_overlap(struct mac_context *mac_ctx,
 				sme_err("no mandatory channel");
 		}
 	}
-
+end:
 	if (intf_ch_freq == sap_ch_freq)
 		intf_ch_freq = 0;