qcacld-3.0: Enable vdev PCL for SBS mode to avoid roaming to MCC

When dual sta connected as SBS mode instead of dbs mode, driver didn't set
pcl per vdev, so dual sta had same PCL in firmware, MCC may happened after
roaming.

Fix:
1. Host pass roaming MCC disallow flag to F/W by checking primary vdev id.

2. For platform SBS supported, when doing dbs or sbs, send PCL from table
to F/W directly, allow SCC and SBS<->DBS roaming, don't limit to intra
band, only avoid mcc case if no primary vdev.

3. Use policy_mgr_concurrent_sta_on_different_mac to replace
policy_mgr_concurrent_sta_doing_dbs, add logic to consider SBS when set
PCL to F/W.

4. Change dual sta PCL table to remove mcc channels.

5. When STA channel switch, also update PCL to F/W.

6. For roaming case, do vdev level PCL update for all sta after connection
update in policy mgr, or wrong PCL is got.

Change-Id: I631c84c96da2bba4011b69e4c076db174205c874
CRs-Fixed: 3336768

components/cmn_services/policy_mgr/inc/wlan_policy_mgr_api.h

@@ -2782,14 +2782,14 @@ bool policy_mgr_current_concurrency_is_scc(struct wlan_objmgr_psoc *psoc);
 bool policy_mgr_current_concurrency_is_mcc(struct wlan_objmgr_psoc *psoc);
 
 /**
- * policy_mgr_concurrent_sta_doing_dbs() - To check the current
- * concurrency STA combination if it is doing DBS
+ * policy_mgr_concurrent_sta_on_different_mac() - To check if
+ * sta concurrency on different mac
  * @psoc: PSOC object information
- * This routine is called to check if it is doing DBS
+ * This routine is called to check if sta concurrency on different mac
  *
- * Return: True - DBS, False - Otherwise
+ * Return: True - sta concurrency on different mac, False - Otherwise
  */
-bool policy_mgr_concurrent_sta_doing_dbs(struct wlan_objmgr_psoc *psoc);
+bool policy_mgr_concurrent_sta_on_different_mac(struct wlan_objmgr_psoc *psoc);
 
 /**
  * policy_mgr_is_sap_p2pgo_on_dfs() - check if there is a P2PGO or SAP

components/cmn_services/policy_mgr/src/wlan_policy_mgr_core.c

@@ -1800,7 +1800,7 @@ void policy_mgr_set_pcl_for_connected_vdev(struct wlan_objmgr_psoc *psoc,
 	struct policy_mgr_pcl_list msg = { {0} };
 	struct wlan_objmgr_vdev *vdev;
 	uint8_t roam_enabled_vdev_id;
-	bool sta_concurrency_is_dbs, dual_sta_roam_enabled;
+	bool sta_concurrency_is_with_different_mac, dual_sta_roam_enabled;
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_POLICY_MGR_ID);
@@ -1825,10 +1825,12 @@ void policy_mgr_set_pcl_for_connected_vdev(struct wlan_objmgr_psoc *psoc,
 	if (roam_enabled_vdev_id == WLAN_UMAC_VDEV_ID_MAX)
 		return;
 
-	sta_concurrency_is_dbs = policy_mgr_concurrent_sta_doing_dbs(psoc);
+	sta_concurrency_is_with_different_mac =
+		policy_mgr_concurrent_sta_on_different_mac(psoc);
 	dual_sta_roam_enabled = wlan_mlme_get_dual_sta_roaming_enabled(psoc);
-	policy_mgr_debug("dual_sta_roam:%d, is_dbs:%d, clear_pcl:%d",
-			 dual_sta_roam_enabled, sta_concurrency_is_dbs,
+	policy_mgr_debug("dual_sta_roam:%d, sta concurrency on different mac:%d, clear_pcl:%d",
+			 dual_sta_roam_enabled,
+			 sta_concurrency_is_with_different_mac,
 			 clear_pcl);
 
 	if (dual_sta_roam_enabled) {
@@ -1844,7 +1846,7 @@ void policy_mgr_set_pcl_for_connected_vdev(struct wlan_objmgr_psoc *psoc,
 			wlan_cm_roam_activate_pcl_per_vdev(psoc,
 							   roam_enabled_vdev_id,
 							   false);
-		} else if (sta_concurrency_is_dbs) {
+		} else if (sta_concurrency_is_with_different_mac) {
 			wlan_cm_roam_activate_pcl_per_vdev(psoc,
 							   roam_enabled_vdev_id,
 							   true);
@@ -1942,6 +1944,10 @@ policy_mgr_get_connected_roaming_vdev_band_mask(struct wlan_objmgr_psoc *psoc,
 	uint32_t band_mask = 0, roam_band_mask, band_mask_for_vdev;
 	struct wlan_objmgr_vdev *vdev;
 	bool dual_sta_roam_active, is_pcl_per_vdev;
+	bool is_sbs_capable = false;
+
+	is_sbs_capable =
+		policy_mgr_is_hw_sbs_capable(psoc);
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_POLICY_MGR_ID);
@@ -1950,6 +1956,16 @@ policy_mgr_get_connected_roaming_vdev_band_mask(struct wlan_objmgr_psoc *psoc,
 		return 0;
 	}
 
+	roam_band_mask = wlan_cm_get_roam_band_value(psoc, vdev);
+
+	/*
+	 * If sbs is enabled, just send PCL to F/W directly,  allow SBS<->DBS
+	 * roaming,  not just limit intra band.
+	 */
+	if (is_sbs_capable) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_POLICY_MGR_ID);
+		return roam_band_mask;
+	}
 	band_mask_for_vdev = policy_mgr_get_connected_vdev_band_mask(vdev);
 
 	is_pcl_per_vdev = wlan_cm_roam_is_pcl_per_vdev_active(psoc, vdev_id);
@@ -1972,7 +1988,6 @@ policy_mgr_get_connected_roaming_vdev_band_mask(struct wlan_objmgr_psoc *psoc,
 	 * active connection band.
 	 */
 	ucfg_reg_get_band(wlan_vdev_get_pdev(vdev), &band_mask);
-	roam_band_mask = wlan_cm_get_roam_band_value(psoc, vdev);
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_POLICY_MGR_ID);
 
 	if (roam_band_mask != band_mask) {

components/cmn_services/policy_mgr/src/wlan_policy_mgr_get_set_utils.c

@@ -4389,7 +4389,7 @@ void policy_mgr_get_ml_and_non_ml_sta_count(struct wlan_objmgr_psoc *psoc,
 	}
 }
 
-bool policy_mgr_concurrent_sta_doing_dbs(struct wlan_objmgr_psoc *psoc)
+bool policy_mgr_concurrent_sta_on_different_mac(struct wlan_objmgr_psoc *psoc)
 {
 	uint8_t num_ml = 0, num_non_ml = 0;
 	uint8_t ml_idx[MAX_NUMBER_OF_CONC_CONNECTIONS] = {0};
@@ -4397,7 +4397,7 @@ bool policy_mgr_concurrent_sta_doing_dbs(struct wlan_objmgr_psoc *psoc)
 	qdf_freq_t freq_list[MAX_NUMBER_OF_CONC_CONNECTIONS] = {0};
 	uint8_t vdev_id_list[MAX_NUMBER_OF_CONC_CONNECTIONS] = {0};
 	struct policy_mgr_psoc_priv_obj *pm_ctx;
-	bool doing_dbs = false, is_1st_non_ml_24ghz;
+	bool is_different_mac = false;
 	int i;
 
 	if (!policy_mgr_is_hw_dbs_capable(psoc))
@@ -4420,12 +4420,11 @@ bool policy_mgr_concurrent_sta_doing_dbs(struct wlan_objmgr_psoc *psoc)
 	 * If more than 1 Non-ML STA is present, check whether they are
 	 * within the same band.
 	 */
-	is_1st_non_ml_24ghz =
-		wlan_reg_is_24ghz_ch_freq(freq_list[non_ml_idx[0]]);
 	for (i = 1; i < num_non_ml; i++) {
-		if (wlan_reg_is_24ghz_ch_freq(freq_list[non_ml_idx[i]]) !=
-		    is_1st_non_ml_24ghz) {
-			doing_dbs = true;
+		if (!policy_mgr_2_freq_always_on_same_mac(psoc,
+							  freq_list[non_ml_idx[i]],
+							  freq_list[non_ml_idx[0]])) {
+			is_different_mac = true;
 			goto out;
 		}
 	}
@@ -4435,18 +4434,20 @@ bool policy_mgr_concurrent_sta_doing_dbs(struct wlan_objmgr_psoc *psoc)
 
 	/* ML STA + Non-ML STA */
 	for (i = 0; i < num_ml; i++) {
-		if (wlan_reg_is_24ghz_ch_freq(freq_list[ml_idx[i]]) !=
-		    is_1st_non_ml_24ghz) {
-			doing_dbs = true;
+		if (!policy_mgr_2_freq_always_on_same_mac(psoc,
+							  freq_list[ml_idx[i]],
+							  freq_list[non_ml_idx[0]])) {
+			is_different_mac = true;
 			goto out;
 		}
 	}
 
 out:
 	qdf_mutex_release(&pm_ctx->qdf_conc_list_lock);
-	policy_mgr_debug("Non-ML STA count %d, ML STA count %d, doing dbs %d",
-			 num_non_ml, num_ml, doing_dbs);
-	return doing_dbs;
+	policy_mgr_debug("Non-ML STA count %d, ML STA count %d, sta concurrency on different mac %d",
+			 num_non_ml, num_ml, is_different_mac);
+
+	return is_different_mac;
 }
 
 bool policy_mgr_max_concurrent_connections_reached(

components/cmn_services/policy_mgr/src/wlan_policy_mgr_pcl.c

@@ -3626,6 +3626,11 @@ QDF_STATUS policy_mgr_get_valid_chan_weights(struct wlan_objmgr_psoc *psoc,
 		 * allowing to detect the disallowed channels.
 		 */
 		if (mode == PM_STA_MODE) {
+			if (policy_mgr_concurrent_sta_on_different_mac(psoc) &&
+			    !wlan_cm_same_band_sta_allowed(psoc)) {
+				policy_mgr_debug("sta follow pcl strictly");
+				strict_follow_pcl = true;
+			}
 			if (vdev)
 				policy_mgr_store_and_del_conn_info_by_vdev_id(
 					psoc, wlan_vdev_get_id(vdev),

components/cmn_services/policy_mgr/src/wlan_policy_mgr_tables_2x2_dbs_sbs_i.h

@@ -48,8 +48,8 @@ pm_second_connection_pcl_dbs_sbs_2x2_table = {
 	[PM_NDI_MODE] = {PM_MAX_PCL_TYPE, PM_MAX_PCL_TYPE, PM_MAX_PCL_TYPE} },
 
 	[PM_STA_5_1x1] = {
-	[PM_STA_MODE] = {PM_SBS_CH_SCC_CH_5G_24G,
-		PM_SCC_CH_MCC_CH_SBS_CH_24G, PM_SBS_CH_24G_SCC_CH},
+	[PM_STA_MODE] = {PM_SBS_CH_SCC_CH_24G,
+		PM_SBS_CH_SCC_CH_24G, PM_SBS_CH_24G_SCC_CH},
 	[PM_SAP_MODE] = {PM_SBS_CH_SCC_CH_24G,
 		PM_SCC_CH_SBS_CH_24G, PM_SBS_CH_24G_SCC_CH},
 	[PM_P2P_CLIENT_MODE] =	{PM_SBS_CH_SCC_CH_5G_24G,
@@ -61,8 +61,8 @@ pm_second_connection_pcl_dbs_sbs_2x2_table = {
 	[PM_NDI_MODE] = {PM_MAX_PCL_TYPE, PM_MAX_PCL_TYPE, PM_MAX_PCL_TYPE} },
 
 	[PM_STA_5_2x2] = {
-	[PM_STA_MODE] = {PM_SBS_CH_SCC_CH_5G_24G,
-		PM_SCC_CH_MCC_CH_SBS_CH_24G, PM_SBS_CH_24G_SCC_CH},
+	[PM_STA_MODE] = {PM_SBS_CH_SCC_CH_24G,
+		PM_SBS_CH_SCC_CH_24G, PM_SBS_CH_24G_SCC_CH},
 	[PM_SAP_MODE] = {PM_SBS_CH_SCC_CH_24G,
 		PM_SCC_CH_SBS_CH_24G, PM_SBS_CH_24G_SCC_CH},
 	[PM_P2P_CLIENT_MODE] =	{PM_SBS_CH_SCC_CH_5G_24G,

components/target_if/connection_mgr/src/target_if_cm_roam_offload.c

@@ -185,6 +185,37 @@ target_if_cm_roam_rt_stats_config(struct wlan_objmgr_vdev *vdev,
 	return status;
 }
 
+/**
+ * target_if_cm_roam_mcc_disallow() - Send enable/disable roam mcc disallow
+ * commands to wmi
+ * @vdev: vdev object
+ * @vdev_id: vdev id
+ * @is_mcc_disallowed: is mcc disallowed
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+target_if_cm_roam_mcc_disallow(struct wlan_objmgr_vdev *vdev,
+			       uint8_t vdev_id, uint8_t is_mcc_disallowed)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	wmi_unified_t wmi_handle;
+
+	wmi_handle = target_if_cm_roam_get_wmi_handle_from_vdev(vdev);
+	if (!wmi_handle)
+		return status;
+
+	status = target_if_roam_set_param(wmi_handle,
+					  vdev_id,
+					  WMI_ROAM_PARAM_ROAM_MCC_DISALLOW,
+					  is_mcc_disallowed);
+
+	if (QDF_IS_STATUS_ERROR(status))
+		target_if_err("Failed to set roam mcc disallow");
+
+	return status;
+}
+
 #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER
 /**
  * target_if_cm_roam_linkspeed_state() - Send link speed state for roaming
@@ -330,6 +361,7 @@ target_if_cm_roam_register_lfr3_ops(struct wlan_cm_roam_tx_ops *tx_ops)
 	tx_ops->send_roam_sync_complete_cmd = target_if_cm_roam_send_roam_sync_complete;
 	tx_ops->send_roam_rt_stats_config = target_if_cm_roam_rt_stats_config;
 	tx_ops->send_roam_ho_delay_config = target_if_cm_roam_ho_delay_config;
+	tx_ops->send_roam_mcc_disallow = target_if_cm_roam_mcc_disallow;
 	target_if_cm_roam_register_vendor_handoff_ops(tx_ops);
 	target_if_cm_roam_register_linkspeed_state(tx_ops);
 }
@@ -351,6 +383,13 @@ target_if_cm_roam_ho_delay_config(struct wlan_objmgr_vdev *vdev,
 {
 	return QDF_STATUS_E_NOSUPPORT;
 }
+
+static QDF_STATUS
+target_if_cm_roam_mcc_disallow(struct wlan_objmgr_vdev *vdev,
+			       uint8_t vdev_id, uint8_t is_mcc_disallowed)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
 #endif
 
 /**
@@ -1214,6 +1253,7 @@ target_if_cm_roam_send_start(struct wlan_objmgr_vdev *vdev,
 	uint8_t vdev_id;
 	bool bss_load_enabled;
 	bool eht_capab = false;
+	bool is_mcc_disallowed;
 
 	wmi_handle = target_if_cm_roam_get_wmi_handle_from_vdev(vdev);
 	if (!wmi_handle)
@@ -1353,6 +1393,9 @@ target_if_cm_roam_send_start(struct wlan_objmgr_vdev *vdev,
 	if (req->wlan_roam_ho_delay_config)
 		target_if_cm_roam_ho_delay_config(
 				vdev, vdev_id, req->wlan_roam_ho_delay_config);
+
+	is_mcc_disallowed = !wlan_cm_same_band_sta_allowed(psoc);
+	target_if_cm_roam_mcc_disallow(vdev, vdev_id, is_mcc_disallowed);
 	/* add other wmi commands */
 end:
 	return status;
@@ -1637,6 +1680,7 @@ target_if_cm_roam_send_update_config(struct wlan_objmgr_vdev *vdev,
 	wmi_unified_t wmi_handle;
 	struct wlan_objmgr_psoc *psoc;
 	uint8_t vdev_id;
+	bool is_mcc_disallowed;
 
 	wmi_handle = target_if_cm_roam_get_wmi_handle_from_vdev(vdev);
 	if (!wmi_handle)
@@ -1736,6 +1780,10 @@ target_if_cm_roam_send_update_config(struct wlan_objmgr_vdev *vdev,
 			target_if_cm_roam_ho_delay_config(
 						vdev, vdev_id,
 						req->wlan_roam_ho_delay_config);
+
+		is_mcc_disallowed = !wlan_cm_same_band_sta_allowed(psoc);
+		target_if_cm_roam_mcc_disallow(vdev, vdev_id,
+					       is_mcc_disallowed);
 	}
 end:
 	return status;

components/umac/mlme/connection_mgr/core/src/wlan_cm_roam_fw_sync.c

@@ -938,8 +938,6 @@ cm_fw_roam_sync_propagation(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	 * Send only for legacy STA/MLO STA vdev.
 	 */
 	if (!wlan_vdev_mlme_is_mlo_link_vdev(vdev)) {
-		cm_if_mgr_inform_connect_complete(cm_ctx->vdev,
-						  connect_rsp->connect_status);
 		cm_inform_dlm_connect_complete(cm_ctx->vdev, connect_rsp);
 		wlan_tdls_notify_sta_connect(vdev_id,
 					mlme_get_tdls_chan_switch_prohibited(vdev),

components/umac/mlme/connection_mgr/core/src/wlan_cm_roam_offload.c

@@ -651,9 +651,12 @@ cm_roam_is_change_in_band_allowed(struct wlan_objmgr_psoc *psoc,
 				  uint8_t vdev_id, uint32_t roam_band_mask)
 {
 	struct wlan_objmgr_vdev *vdev;
-	bool concurrency_is_dbs;
+	bool sta_concurrency_is_with_different_mac;
 	struct wlan_channel *chan;
 
+	if (policy_mgr_is_hw_sbs_capable(psoc))
+		return true;
+
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_MLME_NB_ID);
 	if (!vdev) {
@@ -668,11 +671,12 @@ cm_roam_is_change_in_band_allowed(struct wlan_objmgr_psoc *psoc,
 		return false;
 	}
 
-	concurrency_is_dbs = policy_mgr_concurrent_sta_doing_dbs(psoc);
-	if (!concurrency_is_dbs)
+	sta_concurrency_is_with_different_mac =
+		policy_mgr_concurrent_sta_on_different_mac(psoc);
+	if (!sta_concurrency_is_with_different_mac)
 		return true;
 
-	mlme_debug("STA + STA concurrency is in DBS. ch freq %d, roam band:%d",
+	mlme_debug("sta concurrency on different mac, ch freq %d, roam band:%d",
 		   chan->ch_freq, roam_band_mask);
 
 	if (wlan_reg_freq_to_band(chan->ch_freq) == REG_BAND_2G &&
@@ -3654,20 +3658,19 @@ void cm_handle_sta_sta_roaming_enablement(struct wlan_objmgr_psoc *psoc,
 		goto rel_ref;
 	}
 
-	if (policy_mgr_concurrent_sta_doing_dbs(psoc)) {
-		mlme_debug("After roam on vdev_id:%d, STA + STA concurrency is in DBS:%d",
+	if (policy_mgr_concurrent_sta_on_different_mac(psoc)) {
+		mlme_debug("After roam on vdev_id:%d, sta concurrency on different mac:%d",
 			   curr_vdev_id, sta_count);
 		for (conn_idx = 0; conn_idx < sta_count; conn_idx++) {
 			temp_vdev_id = vdev_id_list[conn_idx];
-			if (temp_vdev_id == curr_vdev_id) {
 				wlan_cm_roam_activate_pcl_per_vdev(psoc,
-								   curr_vdev_id,
+								   temp_vdev_id,
 								   true);
 				/* Set PCL after sending roam complete */
 				policy_mgr_set_pcl_for_existing_combo(psoc,
 								PM_STA_MODE,
-								curr_vdev_id);
-			} else {
+								temp_vdev_id);
+			if (temp_vdev_id != curr_vdev_id) {
 				/* Enable roaming on secondary vdev */
 				if_mgr_enable_roaming(pdev, vdev, RSO_SET_PCL);
 			}
@@ -3881,7 +3884,8 @@ cm_roam_switch_to_init(struct wlan_objmgr_pdev *pdev,
 	enum roam_offload_state cur_state;
 	uint8_t temp_vdev_id, roam_enabled_vdev_id;
 	uint32_t roaming_bitmap;
-	bool dual_sta_roam_active, usr_disabled_roaming, sta_concurrency_is_dbs;
+	bool dual_sta_roam_active, usr_disabled_roaming;
+	bool sta_concurrency_is_with_different_mac;
 	QDF_STATUS status;
 	struct wlan_objmgr_psoc *psoc = wlan_pdev_get_psoc(pdev);
 	struct wlan_mlme_psoc_ext_obj *mlme_obj;
@@ -3897,11 +3901,12 @@ cm_roam_switch_to_init(struct wlan_objmgr_pdev *pdev,
 
 	dual_sta_policy = &mlme_obj->cfg.gen.dual_sta_policy;
 	dual_sta_roam_active = wlan_mlme_get_dual_sta_roaming_enabled(psoc);
-	sta_concurrency_is_dbs = policy_mgr_concurrent_sta_doing_dbs(psoc);
+	sta_concurrency_is_with_different_mac =
+			policy_mgr_concurrent_sta_on_different_mac(psoc);
 	cur_state = mlme_get_roam_state(psoc, vdev_id);
 
-	mlme_info("dual_sta_roam_active:%d, is_dbs:%d, state:%d",
-		  dual_sta_roam_active, sta_concurrency_is_dbs,
+	mlme_info("dual_sta_roam_active:%d, sta concurrency on different mac:%d, state:%d",
+		  dual_sta_roam_active, sta_concurrency_is_with_different_mac,
 		  cur_state);
 
 	switch (cur_state) {
@@ -3915,10 +3920,11 @@ cm_roam_switch_to_init(struct wlan_objmgr_pdev *pdev,
 
 		/*
 		 * Enable roaming on other interface only if STA + STA
-		 * concurrency is in DBS.
+		 * concurrency on different mac.
 		 */
-		if (dual_sta_roam_active && sta_concurrency_is_dbs) {
-			mlme_info("STA + STA concurrency is in DBS");
+		if (dual_sta_roam_active &&
+		    sta_concurrency_is_with_different_mac) {
+			mlme_info("sta concurrency on different mac");
 			break;
 		}
 
@@ -4017,7 +4023,7 @@ cm_roam_switch_to_init(struct wlan_objmgr_pdev *pdev,
 	 * PCL type to vdev level
 	 */
 	if (roam_enabled_vdev_id != WLAN_UMAC_VDEV_ID_MAX &&
-	    dual_sta_roam_active && sta_concurrency_is_dbs)
+	    dual_sta_roam_active && sta_concurrency_is_with_different_mac)
 		wlan_cm_roam_activate_pcl_per_vdev(psoc, vdev_id, true);
 
 	/* Set PCL before sending RSO start */

components/umac/mlme/connection_mgr/dispatcher/inc/wlan_cm_roam_public_struct.h

@@ -2374,6 +2374,8 @@ struct wlan_cm_roam_tx_ops {
 	QDF_STATUS (*send_roam_ho_delay_config)(struct wlan_objmgr_vdev *vdev,
 						uint8_t vdev_id,
 						uint16_t value);
+	QDF_STATUS (*send_roam_mcc_disallow)(struct wlan_objmgr_vdev *vdev,
+					     uint8_t vdev_id, uint8_t value);
 #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER
 	QDF_STATUS (*send_roam_linkspeed_state)(struct wlan_objmgr_vdev *vdev,
 						uint8_t vdev_id, bool value);

core/hdd/src/wlan_hdd_cfg80211.c

@@ -9843,16 +9843,17 @@ static int hdd_set_primary_interface(struct hdd_adapter *adapter,
 		return 0;
 	}
 
-	/* if dual sta roaming enabled and both sta in DBS then no need
-	 * to enable roaming on primary as both STA's have roaming enabled.
-	 * if dual sta roaming enabled and both sta in MCC or SCC then need
+	/* If dual sta roaming enabled and sta concurrency on different mac then
+	 * no need to enable roaming on primary as both STA's have roaming
+	 * enabled.
+	 * If dual sta roaming enabled and both sta in MCC or SCC then need
 	 * to enable roaming on primary vdev.
-	 * if dual sta roaming NOT enabled then need to enable roaming on
-	 * primary vdev for dual STA concurrency in MCC or DBS.
+	 * If dual sta roaming NOT enabled then need to enable roaming on
+	 * primary vdev for sta concurrency on different mac.
 	 */
 	if (primary_vdev_id !=  WLAN_UMAC_VDEV_ID_MAX)
 		if ((ucfg_mlme_get_dual_sta_roaming_enabled(hdd_ctx->psoc) &&
-		     !policy_mgr_concurrent_sta_doing_dbs(hdd_ctx->psoc)) ||
+		     !policy_mgr_concurrent_sta_on_different_mac(hdd_ctx->psoc)) ||
 		    !ucfg_mlme_get_dual_sta_roaming_enabled(hdd_ctx->psoc)) {
 			hdd_err("Enable roaming on requested interface: %d",
 				adapter->vdev_id);

core/mac/src/pe/lim/lim_process_mlm_rsp_messages.c

@@ -3170,9 +3170,12 @@ void lim_process_switch_channel_rsp(struct mac_context *mac,
 
 		/* If MCC upgrade/DBS downgrade happened during channel switch,
 		 * the policy manager connection table needs to be updated.
+		 * STA PCL to F/W need update after sta channel switch.
 		 */
 		policy_mgr_update_connection_info(mac->psoc,
 			pe_session->smeSessionId);
+		wlan_cm_handle_sta_sta_roaming_enablement(mac->psoc,
+							  pe_session->smeSessionId);
 		if (pe_session->opmode == QDF_P2P_CLIENT_MODE) {
 			pe_debug("Send p2p operating channel change conf action frame once first beacon is received on new channel");
 			pe_session->send_p2p_conf_frame = true;