qcacmn: Refining connection handling for specific vendor

Currently, on host-side connection handling, it persisted
with the same candidate until it achieved SLO. Host driver
selection process factored in scores, with subsequent attempts
exploring all combinations until SLO, bypassing score
considerations.

When vendor roam score algorithm is enabled and association failure
happens while trying MLO connection with multiple link, then
retry with candidate having better etp score.

Logic :- Create all possible valid unique combination of candidate
	 Apply additional boost to 3 link candidate [20%]
	 Apply additional boost to 2 link DBS candidate [10%]
	 Retry with candidate based on etp score

Ex1:
Single AP1 3 link  6 GHz etp > 5 GHz etp > 2 GHz etp
AP1 6 GHz + 2 GHz + 5 GHz [link boost 20%]
AP1 6 GHz + 2 GHz         [DBS boost 10%]
AP1 6 GHz + 5 GHz
AP1 6 GHz
AP1 5 GHz + 2 GHz         [DBS boost 10%]
AP1 5 GHz
AP1 2 GHz

Ex2:
AP1 3link  6 GHz etp > 5 GHz etp > 2 GHz etp
AP2 SLO 2 GHz AP2 2 GHz etp > AP1 5 GHz etp

AP1 6 GHz + 2 GHz + 5 GHz [link boost 20%]
AP1 6 GHz + 2 GHz         [DBS boost 10%]
AP1 6 GHz + 5 GHz
AP1 6 GHz
AP1 5 GHz + 2 GHz         [DBS boost 10%]
AP2 2 GHz
AP1 5 GHz
AP1 2 GHz

Change-Id: I73edf31f9dd82cf82c8516e19df1538404f96435
CRs-Fixed: 3625114

umac/mlme/connection_mgr/core/src/wlan_cm_bss_scoring.c

@@ -38,6 +38,10 @@
 
 #define CM_PCL_RSSI_THRESHOLD -75
 
+#define TWO_LINK_BOOST 20
+#define ONE_LINK_MLMR_BOOST 10
+#define CANDIDATE_DUMP_MAX_LEN 255
+
 #define LINK_SCORE                     BIT(0)
 #define ASSOC_LINK                     BIT(1)
 
@@ -2172,21 +2176,6 @@ cm_sort_vendor_algo_mlo_bss_entry(struct wlan_objmgr_psoc *psoc,
 		else
 			freq[i] = link[i].freq;
 
-		if (policy_mgr_are_2_freq_on_same_mac(psoc, freq[i],
-						      freq_entry)) {
-			total_score[i] = 0;
-			mlme_nofl_debug("Partner("QDF_MAC_ADDR_FMT" freq %d): assoc freq %d can't be MLMR",
-					QDF_MAC_ADDR_REF(link[i].link_addr.bytes),
-					freq[i], freq_entry);
-
-			if (mlo_support_link_num <= WLAN_MAX_ML_DEFAULT_LINK ||
-			    entry->ml_info.num_links <
-						WLAN_MAX_ML_DEFAULT_LINK)
-				link[i].is_valid_link = false;
-
-			continue;
-		}
-
 		if (!entry_partner[i])
 			continue;
 
@@ -2334,6 +2323,42 @@ cm_check_and_update_bssid_hint_entry_bss_score(struct scan_cache_entry *entry,
 	return true;
 }
 
+#ifdef WLAN_FEATURE_11BE_MLO_ADV_FEATURE
+static void cm_vendor_specific_boost(struct wlan_objmgr_psoc *psoc,
+				     struct scan_cache_entry *entry,
+				     int32_t score)
+{
+	struct partner_link_info *link = NULL;
+	uint32_t freq = 0;
+	uint32_t freq_entry = 0;
+
+	/* Add boost of 20% for 2 link candidate */
+	if (entry->ml_info.num_links == TWO_LINK)
+		score = score  + (score * TWO_LINK_BOOST) / 100;
+
+	if (entry->ml_info.num_links == ONE_LINK) {
+		freq_entry = entry->channel.chan_freq;
+		link = &entry->ml_info.link_info[0];
+
+		freq = link[0].is_valid_link ? link[0].freq : link[1].freq;
+
+		/* Add boost of 10% for one link MLMR candidate  */
+		if (!policy_mgr_are_2_freq_on_same_mac(psoc,
+						       freq,
+						       freq_entry))
+			score = score + (score * ONE_LINK_MLMR_BOOST) / 100;
+		}
+
+	entry->bss_score = score;
+}
+#else
+static void cm_vendor_specific_boost(struct wlan_objmgr_psoc *psoc,
+				     struct scan_cache_entry *entry,
+				     int32_t score)
+{
+}
+#endif
+
 /**
  * cm_calculate_bss_score() - Calculate score of AP or 1 link of MLO AP
  * @psoc: Pointer to psoc object
@@ -2413,6 +2438,9 @@ static int cm_calculate_bss_score(struct wlan_objmgr_psoc *psoc,
 			cm_sort_vendor_algo_mlo_bss_entry(psoc, entry,
 							  phy_config, scan_list,
 							  bss_mlo_type);
+		/* vendor specific boost */
+		cm_vendor_specific_boost(psoc, entry, score);
+
 		if (cm_check_and_update_bssid_hint_entry_bss_score(entry,
 								   score_config,
 								   bssid_hint,
@@ -2700,6 +2728,300 @@ cm_update_bss_score_for_mac_addr_matching(struct scan_cache_node *scan_entry,
 }
 #endif
 
+#ifdef WLAN_FEATURE_11BE_MLO_ADV_FEATURE
+static void cm_print_candidate_list(qdf_list_t *candidate_list)
+{
+	struct scan_cache_node *scan_entry = NULL;
+	qdf_list_node_t *cur_node = NULL, *next_node = NULL;
+	uint32_t freq_entry = 0;
+	struct partner_link_info *link = NULL;
+	uint8_t i = 0;
+	uint32_t len = 0;
+	char log_str[CANDIDATE_DUMP_MAX_LEN] = {0};
+	uint32_t str_len = CANDIDATE_DUMP_MAX_LEN;
+
+	if (qdf_list_peek_front(candidate_list, &cur_node) !=
+	    QDF_STATUS_SUCCESS) {
+		mlme_err("failed to get front of candidate_list");
+		return;
+	}
+
+	while (cur_node) {
+		qdf_list_peek_next(candidate_list, cur_node, &next_node);
+
+		scan_entry = qdf_container_of(cur_node, struct scan_cache_node,
+					      node);
+		link = scan_entry->entry->ml_info.link_info;
+		freq_entry = scan_entry->entry->channel.chan_freq;
+
+		if (scan_entry->entry->ml_info.num_links)
+			len += qdf_scnprintf(log_str + len, str_len - len, "num_link %d partners ",
+					     scan_entry->entry->ml_info.num_links);
+		for (i = 0; i < scan_entry->entry->ml_info.num_links; i++)
+			len += qdf_scnprintf(log_str + len, str_len - len, QDF_MAC_ADDR_FMT " freq (%d) link_id %d ",
+					     QDF_MAC_ADDR_REF(link[i].link_addr.bytes),
+					     link[i].freq, link[i].link_id);
+		mlme_debug("Candidate(" QDF_MAC_ADDR_FMT " freq %d self_link_id %d): %s bss_score %d ",
+			   QDF_MAC_ADDR_REF(scan_entry->entry->bssid.bytes),
+			   scan_entry->entry->channel.chan_freq,
+			   scan_entry->entry->ml_info.self_link_id,
+			   log_str,
+			   scan_entry->entry->bss_score);
+		cur_node = next_node;
+		next_node = NULL;
+		memset(log_str, 0, sizeof(*log_str));
+		len = 0;
+	}
+}
+
+/**
+ * cm_find_and_remove_dup_candidate() - remove duplicate candidate
+ * @bss_entry: bss scan entry
+ * @next_can: next candidate
+ * @candidate_list: candidate list
+ *
+ * Ex1:
+ * Single AP1 3 link  6 GHz 2 GHz 5 GHz
+ *
+ * All possible combination of candidate[INPUT]
+ * AP1 6 GHz + 2 GHz + 5 GHz
+ * AP1 6 GHz + 2 GHz
+ * AP1 6 GHz + 5 GHz
+ * AP1 6 GHz
+ * AP1 2 GHz + 5 GHz + 6 GHz
+ * AP1 2 GHz + 5 GHz
+ * AP1 2 GHz + 6 GHz
+ * AP1 2 GHz
+ * AP1 5 GHz + 6 GHz + 2 GHz
+ * AP1 5 GHz + 6 GHz
+ * AP1 5 GHz + 2 GHz
+ * AP1 5 GHz
+ *
+ * All possible valid unique combination of candidate after applying [OUTPUT]
+ * filter.
+ * AP1 6 GHz + 2 GHz + 5 GHz
+ * AP1 6 GHz + 2 GHz
+ * AP1 6 GHz + 5 GHz
+ * AP1 6 GHz
+ * AP1 5 GHz + 2 GHz
+ * AP1 5 GHz
+ * AP1 2 GHz
+ *
+ * Return: none
+ */
+static void cm_find_and_remove_dup_candidate(struct scan_cache_node *bss_entry,
+					     qdf_list_node_t  *next_can,
+					     qdf_list_t *candidate_list)
+{
+	qdf_list_node_t *cur_node = NULL, *next_node = NULL;
+	struct scan_cache_node *scan_node;
+	uint8_t i = 0, j = 0;
+	int match = 0;
+	uint8_t bss_num_link = 0, curr_num_link = 0;
+	struct partner_link_info *cur_can = NULL, *bss_can = NULL;
+	uint32_t size = 0;
+
+	bss_num_link = bss_entry->entry->ml_info.num_links;
+
+	cur_node = next_can;
+	size = qdf_list_size(candidate_list);
+
+	while (cur_node && size > 0) {
+		qdf_list_peek_next(candidate_list, cur_node, &next_node);
+
+		scan_node  = qdf_container_of(cur_node, struct scan_cache_node,
+					      node);
+		curr_num_link = scan_node->entry->ml_info.num_links;
+		cur_can = scan_node->entry->ml_info.link_info;
+		bss_can = bss_entry->entry->ml_info.link_info;
+
+		if (scan_node->entry->ml_info.num_links !=
+		    bss_entry->entry->ml_info.num_links)
+			goto next;
+
+		match = 0;
+		for (i = 0; i < bss_num_link; i++)
+			if (qdf_is_macaddr_equal(&bss_entry->entry->bssid,
+						 &scan_node->entry->bssid) ||
+			    qdf_is_macaddr_equal(&bss_entry->entry->bssid,
+						 &cur_can[i].link_addr))
+				match++;
+		for (i = 0; i < bss_num_link; i++) {
+			for (j = 0; j < curr_num_link; j++) {
+				if (cur_can[j].is_valid_link &&
+				    (qdf_is_macaddr_equal(
+						&cur_can[j].link_addr,
+						&bss_can[i].link_addr) ||
+				    qdf_is_macaddr_equal(
+						&cur_can[j].link_addr,
+						&bss_can[i].link_addr) ||
+				    qdf_is_macaddr_equal(
+						&scan_node->entry->bssid,
+						&bss_can[i].link_addr))) {
+					match++;
+					if (match == bss_num_link + 1) {
+						qdf_list_remove_node(
+							candidate_list,
+							cur_node);
+						util_scan_free_cache_entry(
+							scan_node->entry);
+						qdf_mem_free(cur_node);
+						goto next;
+					}
+				}
+			}
+		}
+next:
+	cur_node = next_node;
+	next_node = NULL;
+	size--;
+	}
+}
+
+/**
+ * cm_update_candidate_list_for_vendor() - update candidate list
+ * @candidate_list: candidate list
+ *
+ * For any candidate list this api generates all possible unique
+ * candidates
+ * Input candidate list
+ * c1 6 GHz + 2 GHz + 5 GHz
+ * c2 2 GHz + 5 GHz + 6 GHz
+ * c3 5 GHz + 6 GHz + 2 GHz
+ *
+ * Output candidate list
+ * AP1 6 GHz + 2 GHz + 5 GHz
+ * AP1 6 GHz + 2 GHz
+ * AP1 6 GHz + 5 GHz
+ * AP1 6 GHz
+ * AP1 2 GHz + 5 GHz + 6 GHz
+ * AP1 2 GHz + 5 GHz
+ * AP1 2 GHz + 6 GHz
+ * AP1 2 GHz
+ * AP1 5 GHz + 6 GHz + 2 GHz
+ * AP1 5 GHz + 6 GHz
+ * AP1 5 GHz + 2 GHz
+ * AP1 5 GHz
+ *
+ * Return none
+ */
+static void cm_update_candidate_list_for_vendor(qdf_list_t *candidate_list)
+{
+	struct scan_cache_entry *tmp_scan_entry = NULL;
+	struct scan_cache_node *scan_entry = NULL, *scan_node = NULL;
+	qdf_list_node_t *cur_node = NULL, *next_node = NULL;
+	struct partner_link_info *link = NULL;
+	struct partner_link_info tmp = {0};
+	uint32_t num_link = 0;
+	uint32_t i = 0;
+	uint32_t j = 0;
+
+	if (qdf_list_peek_front(candidate_list, &cur_node) !=
+	    QDF_STATUS_SUCCESS) {
+		mlme_err("failed to get front of candidate_list");
+		return;
+	}
+	while (cur_node) {
+		qdf_list_peek_next(candidate_list, cur_node, &next_node);
+
+		scan_entry = qdf_container_of(cur_node, struct scan_cache_node,
+					      node);
+		num_link = scan_entry->entry->ml_info.num_links;
+
+		for (i = 0; i < num_link; i++) {
+			tmp_scan_entry = util_scan_copy_cache_entry(
+						scan_entry->entry);
+			scan_node = qdf_mem_malloc_atomic(sizeof(*scan_node));
+			if (!scan_node) {
+				util_scan_free_cache_entry(tmp_scan_entry);
+				goto next;
+			}
+
+			scan_node->entry = tmp_scan_entry;
+			scan_node->entry->ml_info.num_links = i;
+			link = scan_node->entry->ml_info.link_info;
+			for (j = i; j < num_link; j++)
+				link[j].is_valid_link = false;
+			qdf_list_insert_before(candidate_list,
+					       &scan_node->node,
+					       &scan_entry->node);
+
+			if (i == 1) {
+				tmp_scan_entry = util_scan_copy_cache_entry(
+							scan_entry->entry);
+				scan_node = qdf_mem_malloc_atomic(
+						sizeof(*scan_node));
+				if (!scan_node) {
+					util_scan_free_cache_entry(
+							tmp_scan_entry);
+					goto next;
+				}
+
+				scan_node->entry = tmp_scan_entry;
+				scan_node->entry->ml_info.num_links = i;
+				link = scan_node->entry->ml_info.link_info;
+				tmp  = link[1];
+				link[1] = link[0];
+				link[0] = tmp;
+				for (j = i; j < num_link; j++)
+					link[j].is_valid_link = false;
+				qdf_list_insert_before(candidate_list,
+						       &scan_node->node,
+						       &scan_entry->node);
+			}
+		}
+next:
+		cur_node = next_node;
+		next_node = NULL;
+	}
+}
+
+static void cm_eliminate_common_candidate(qdf_list_t *candidate_list)
+{
+	struct scan_cache_node *scan_entry = NULL;
+	qdf_list_node_t *cur_node = NULL, *next_node = NULL;
+	uint32_t size = 0;
+
+	size = qdf_list_size(candidate_list);
+
+	if (qdf_list_peek_front(candidate_list, &cur_node) !=
+		QDF_STATUS_SUCCESS) {
+		mlme_err("failed to get front of candidate_list");
+		return;
+	}
+
+	while (cur_node && size > 0) {
+		qdf_list_peek_next(candidate_list, cur_node, &next_node);
+
+		scan_entry = qdf_container_of(cur_node,
+					      struct scan_cache_node, node);
+
+		cm_find_and_remove_dup_candidate(scan_entry,
+						 next_node, candidate_list);
+
+		/* find next again as next entry might have deleted */
+		qdf_list_peek_next(candidate_list, cur_node, &next_node);
+
+		cur_node = next_node;
+		next_node = NULL;
+		size--;
+	}
+}
+#else
+
+static void cm_update_candidate_list_for_vendor(qdf_list_t *candidate_list)
+{
+}
+
+static void cm_eliminate_common_candidate(qdf_list_t *candidate_list)
+{
+}
+
+static void cm_print_candidate_list(qdf_list_t *candidate_list)
+{
+}
+
+#endif
 void wlan_cm_calculate_bss_score(struct wlan_objmgr_pdev *pdev,
 				 struct pcl_freq_weight_list *pcl_lst,
 				 qdf_list_t *scan_list,
@@ -2745,6 +3067,9 @@ void wlan_cm_calculate_bss_score(struct wlan_objmgr_pdev *pdev,
 			config->bw_above_20_5ghz, config->vdev_nss_24g,
 			config->vdev_nss_5g);
 
+	if (score_config->vendor_roam_score_algorithm)
+		cm_update_candidate_list_for_vendor(scan_list);
+
 	/* calculate score for each AP */
 	if (qdf_list_peek_front(scan_list, &cur_node) != QDF_STATUS_SUCCESS) {
 		mlme_err("failed to peer front of scan list");
@@ -2882,6 +3207,12 @@ void wlan_cm_calculate_bss_score(struct wlan_objmgr_pdev *pdev,
 		util_scan_free_cache_entry(force_connect_candidate->entry);
 		qdf_mem_free(force_connect_candidate);
 	}
+
+	if (score_config->vendor_roam_score_algorithm) {
+		cm_eliminate_common_candidate(scan_list);
+		/* print all vendor candidates*/
+		cm_print_candidate_list(scan_list);
+	}
 }
 
 #ifdef CONFIG_BAND_6GHZ

umac/mlme/connection_mgr/core/src/wlan_cm_connect.c

@@ -962,98 +962,6 @@ cm_inform_dlm_connect_complete(struct wlan_objmgr_vdev *vdev,
 	return QDF_STATUS_SUCCESS;
 }
 
-#ifdef WLAN_FEATURE_11BE_MLO
-static bool
-cm_update_mlo_links_for_retry_with_same_candidate(struct wlan_objmgr_psoc *psoc,
-						  struct cm_connect_req *cm_req)
-{
-	uint8_t mlo_link_num;
-	struct scan_cache_entry *entry;
-
-	if (!cm_req->req.ml_parnter_info.num_partner_links)
-		return false;
-
-	entry = cm_req->cur_candidate->entry;
-
-	mlo_link_num = wlan_mlme_get_sta_mlo_conn_max_num(psoc);
-	if (cm_req->req.ml_parnter_info.num_partner_links > mlo_link_num)
-		cm_req->req.ml_parnter_info.num_partner_links = mlo_link_num;
-
-	/*
-	 * Try next candidate for non-ML AP
-	 */
-	if (!entry->ie_list.multi_link_bv || !entry->ml_info.num_links) {
-		cm_req->req.ml_parnter_info.num_partner_links = NO_LINK;
-		return false;
-	}
-
-	if (cm_req->req.ml_parnter_info.num_partner_links > NO_LINK) {
-		/*
-		 * Try to same AP exhaustively till single link ML connection
-		 * is tried with the AP
-		 */
-		cm_req->req.ml_parnter_info.num_partner_links--;
-	}
-
-	mlme_debug(CM_PREFIX_FMT "try ML connection with %d partner links",
-		   CM_PREFIX_REF(cm_req->req.vdev_id, cm_req->cm_id),
-		   cm_req->req.ml_parnter_info.num_partner_links);
-
-	return true;
-}
-#else
-static inline bool
-cm_update_mlo_links_for_retry_with_same_candidate(struct wlan_objmgr_psoc *psoc,
-						  struct cm_connect_req *cm_req)
-{
-	return false;
-}
-#endif
-
-/**
- * cm_retry_with_same_candidate_for_sae_connection() - This API check if
- * reconnect attempt is required with the same candidate again or not based
- * on sae connection
- * @psoc: obj mgr psoc
- * @req: Connect request
- * @max_retry_count: pointer to hold max retry value
- * @is_mlo_vdev: MLO connection or not
- * @is_sae_con: SAE connection or not
- *
- * Return: void
- */
-static void
-cm_retry_with_same_candidate_for_sae_connection(
-			struct wlan_objmgr_psoc *psoc,
-			struct cm_connect_req *req,
-			uint8_t *max_retry_count, bool is_mlo_vdev,
-			bool is_sae_con)
-{
-	uint8_t sae_max_retry_count = CM_MAX_CANDIDATE_RETRIES;
-	struct scoring_cfg *score_config;
-	struct psoc_mlme_obj *mlme_psoc_obj;
-
-	mlme_psoc_obj = wlan_psoc_mlme_get_cmpt_obj(psoc);
-	if (!mlme_psoc_obj)
-		return;
-
-	score_config = &mlme_psoc_obj->psoc_cfg.score_config;
-
-	/* For SAE use max retry count from INI */
-	if (is_sae_con)
-		wlan_mlme_get_sae_assoc_retry_count(psoc, &sae_max_retry_count);
-
-	if (score_config->vendor_roam_score_algorithm) {
-		if (is_mlo_vdev)
-			sae_max_retry_count = QDF_MAX(sae_max_retry_count,
-						      *max_retry_count);
-
-		cm_update_mlo_links_for_retry_with_same_candidate(psoc, req);
-	}
-
-	*max_retry_count = sae_max_retry_count;
-}
-
 /**
  * cm_is_retry_with_same_candidate() - This API check if reconnect attempt is
  * required with the same candidate again
@@ -1077,27 +985,14 @@ static bool cm_is_retry_with_same_candidate(struct cnx_mgr *cm_ctx,
 	QDF_STATUS status;
 	uint8_t mlo_link_num;
 	qdf_freq_t freq;
-	struct scoring_cfg *score_config;
-	struct psoc_mlme_obj *mlme_psoc_obj;
 
 	psoc = wlan_pdev_get_psoc(wlan_vdev_get_pdev(cm_ctx->vdev));
-	mlme_psoc_obj = wlan_psoc_mlme_get_cmpt_obj(psoc);
-	if (!mlme_psoc_obj)
-		return false;
 
-	score_config = &mlme_psoc_obj->psoc_cfg.score_config;
 	key_mgmt = req->cur_candidate->entry->neg_sec_info.key_mgmt;
 	freq = req->cur_candidate->entry->channel.chan_freq;
 
 	is_mlo_vdev = wlan_vdev_mlme_is_mlo_vdev(cm_ctx->vdev);
 	mlo_link_num = wlan_mlme_get_sta_mlo_conn_max_num(psoc);
-	/*
-	 * Update no of retrials for n link MLO, so that connection can be
-	 * tried with all possible link combinations till SLO.
-	 */
-	if (score_config->vendor_roam_score_algorithm &&
-	    is_mlo_vdev && mlo_link_num > 1)
-		max_retry_count = mlo_link_num - 1;
 
 	/* Try once again for the invalid PMKID case without PMKID */
 	if (resp->status_code == STATUS_INVALID_PMKID)
@@ -1108,6 +1003,10 @@ static bool cm_is_retry_with_same_candidate(struct cnx_mgr *cm_ctx,
 				     1 << WLAN_CRYPTO_KEY_MGMT_SAE_EXT_KEY |
 				     1 << WLAN_CRYPTO_KEY_MGMT_FT_SAE_EXT_KEY);
 
+	/* For SAE use max retry count from INI */
+	if (sae_connection)
+		wlan_mlme_get_sae_assoc_retry_count(psoc, &max_retry_count);
+
 	/* Try again for the JOIN timeout if only one candidate */
 	if (resp->reason == CM_JOIN_TIMEOUT &&
 	    qdf_list_size(req->candidate_list) == 1) {
@@ -1120,10 +1019,6 @@ static bool cm_is_retry_with_same_candidate(struct cnx_mgr *cm_ctx,
 		if (policy_mgr_will_freq_lead_to_mcc(psoc, freq))
 			return false;
 
-		cm_retry_with_same_candidate_for_sae_connection(
-				psoc, req, &max_retry_count, is_mlo_vdev,
-				sae_connection);
-
 		goto use_same_candidate;
 	}
 
@@ -1134,29 +1029,9 @@ static bool cm_is_retry_with_same_candidate(struct cnx_mgr *cm_ctx,
 	if (resp->reason == CM_ASSOC_TIMEOUT && (sae_connection ||
 	    (mlme_get_reconn_after_assoc_timeout_flag(psoc, resp->vdev_id)))) {
 
-		cm_retry_with_same_candidate_for_sae_connection(
-				psoc, req, &max_retry_count, is_mlo_vdev,
-				sae_connection);
-
 		goto use_same_candidate;
 	}
 
-	/*
-	 * When vendor roam score algorithm is enabled and association failure
-	 * happens while trying MLO connection with multiple link, then
-	 * retry with same candidate with same primary link and other band as
-	 * secondary link. If still failure happens, then try standlone single
-	 * link MLO mode with the same candidate AP. Ex:
-	 * Priority 1(candidate AP’s 6 GHz case) – 6 GHz (Associating link) +
-	 *                                         5 GHz + 2.4 GHz
-	 * Priority 2(candidate AP’s 6 GHz case) – 6 GHz (Associating link) +
-	 *                                         2.4 GHz
-	 * Priority 3(AP’s 6 GHz case) – 6 GHz (single Link)
-	 */
-	if (resp->status_code && score_config->vendor_roam_score_algorithm &&
-	    cm_update_mlo_links_for_retry_with_same_candidate(psoc, req))
-		goto use_same_candidate;
-
 	return false;
 
 use_same_candidate: