diff --git a/Kbuild b/Kbuild
index 6638fd5a5e69..72e178911ad8 100644
--- a/Kbuild
+++ b/Kbuild
@@ -2726,8 +2726,6 @@ cppflags-$(CONFIG_WLAN_OBJMGR_DEBUG) += -DWLAN_OBJMGR_REF_ID_DEBUG
 
 cppflags-$(CONFIG_WLAN_FEATURE_SAE) += -DWLAN_FEATURE_SAE
 
-cppflags-y += -DWLAN_SCAN_SECURITY_FILTER_V1
-
 ifeq ($(BUILD_DIAG_VERSION), y)
 cppflags-y += -DFEATURE_WLAN_DIAG_SUPPORT
 cppflags-y += -DFEATURE_WLAN_DIAG_SUPPORT_CSR
diff --git a/core/sme/src/csr/csr_api_roam.c b/core/sme/src/csr/csr_api_roam.c
index 29f10e67949c..d5d8d8efa8ac 100644
--- a/core/sme/src/csr/csr_api_roam.c
+++ b/core/sme/src/csr/csr_api_roam.c
@@ -8263,19 +8263,11 @@ static void csr_roam_print_candidate_aps(tScanResultHandle results)
 	}
 }
 
-#ifdef WLAN_SCAN_SECURITY_FILTER_V1
 void csr_set_open_mode_in_scan_filter(struct scan_filter *filter)
 {
 	QDF_SET_PARAM(filter->authmodeset, WLAN_CRYPTO_AUTH_OPEN);
 }
-#else
-void csr_set_open_mode_in_scan_filter(struct scan_filter *filter)
-{
-	/* No encryption */
-	filter->num_of_enc_type = 1;
-	filter->enc_type[0] = WLAN_ENCRYPT_TYPE_NONE;
-}
-#endif
+
 QDF_STATUS csr_roam_connect(struct mac_context *mac, uint32_t sessionId,
 		struct csr_roam_profile *pProfile,
 		uint32_t *pRoamId)
@@ -10739,7 +10731,6 @@ void csr_update_pmf_cap_from_profile(struct csr_roam_profile *profile,
 {}
 #endif
 
-#ifdef WLAN_SCAN_SECURITY_FILTER_V1
 QDF_STATUS csr_fill_filter_from_vdev_crypto(struct mac_context *mac_ctx,
 					    struct scan_filter *filter,
 					    uint8_t vdev_id)
@@ -10782,53 +10773,6 @@ static QDF_STATUS csr_fill_crypto_params(struct mac_context *mac_ctx,
 
 	return csr_fill_filter_from_vdev_crypto(mac_ctx, filter, vdev_id);
 }
-#else
-static QDF_STATUS csr_fill_crypto_params(struct mac_context *mac_ctx,
-					 struct csr_roam_profile *profile,
-					 struct scan_filter *filter,
-					 uint8_t vdev_id)
-{
-	uint8_t i;
-
-	if (profile->force_rsne_override) {
-		sme_debug("force_rsne_override set auth type and enctype to any and ignore pmf cap");
-		filter->num_of_auth = 1;
-		filter->auth_type[0] = WLAN_AUTH_TYPE_ANY;
-		filter->num_of_enc_type = 1;
-		filter->enc_type[0] = WLAN_ENCRYPT_TYPE_ANY;
-		filter->num_of_mc_enc_type = 1;
-		filter->mc_enc_type[0] = WLAN_ENCRYPT_TYPE_ANY;
-		filter->ignore_pmf_cap = true;
-	} else {
-		filter->num_of_auth =
-			profile->AuthType.numEntries;
-		if (filter->num_of_auth > WLAN_NUM_OF_SUPPORT_AUTH_TYPE)
-			filter->num_of_auth = WLAN_NUM_OF_SUPPORT_AUTH_TYPE;
-		for (i = 0; i < filter->num_of_auth; i++)
-			filter->auth_type[i] =
-			  csr_covert_auth_type_new(
-			  profile->AuthType.authType[i]);
-		filter->num_of_enc_type =
-			profile->EncryptionType.numEntries;
-		if (filter->num_of_enc_type > WLAN_NUM_OF_ENCRYPT_TYPE)
-			filter->num_of_enc_type = WLAN_NUM_OF_ENCRYPT_TYPE;
-		for (i = 0; i < filter->num_of_enc_type; i++)
-			filter->enc_type[i] =
-			  csr_covert_enc_type_new(
-			  profile->EncryptionType.encryptionType[i]);
-		filter->num_of_mc_enc_type =
-				profile->mcEncryptionType.numEntries;
-		if (filter->num_of_mc_enc_type > WLAN_NUM_OF_ENCRYPT_TYPE)
-			filter->num_of_mc_enc_type = WLAN_NUM_OF_ENCRYPT_TYPE;
-		for (i = 0; i < filter->num_of_mc_enc_type; i++)
-			filter->mc_enc_type[i] =
-			  csr_covert_enc_type_new(
-			  profile->mcEncryptionType.encryptionType[i]);
-	}
-
-	return QDF_STATUS_SUCCESS;
-}
-#endif
 
 QDF_STATUS
 csr_roam_get_scan_filter_from_profile(struct mac_context *mac_ctx,
diff --git a/core/sme/src/csr/csr_api_scan.c b/core/sme/src/csr/csr_api_scan.c
index fe2965fc6273..40ba63c27a5b 100644
--- a/core/sme/src/csr/csr_api_scan.c
+++ b/core/sme/src/csr/csr_api_scan.c
@@ -1919,8 +1919,6 @@ csr_scan_get_channel_for_hw_mode_change(struct mac_context *mac_ctx,
 	return candidate_ch_freq;
 }
 
-#ifdef WLAN_SCAN_SECURITY_FILTER_V1
-
 static void csr_fill_rsn_auth_type(enum csr_akm_type *auth_type, uint32_t akm)
 {
 	/* Try the more preferred ones first. */
@@ -2093,222 +2091,6 @@ static void csr_fill_neg_crypto_info(struct tag_csrscan_result *bss,
 		  bss->authType, bss->ucEncryptionType, bss->mcEncryptionType);
 }
 
-#else
-
-enum wlan_auth_type csr_covert_auth_type_new(enum csr_akm_type auth)
-{
-	switch (auth) {
-	case eCSR_AUTH_TYPE_NONE:
-	case eCSR_AUTH_TYPE_OPEN_SYSTEM:
-		return WLAN_AUTH_TYPE_OPEN_SYSTEM;
-	case eCSR_AUTH_TYPE_SHARED_KEY:
-		return WLAN_AUTH_TYPE_SHARED_KEY;
-	case eCSR_AUTH_TYPE_AUTOSWITCH:
-		return WLAN_AUTH_TYPE_AUTOSWITCH;
-	case eCSR_AUTH_TYPE_WPA:
-		return WLAN_AUTH_TYPE_WPA;
-	case eCSR_AUTH_TYPE_WPA_PSK:
-		return WLAN_AUTH_TYPE_WPA_PSK;
-	case eCSR_AUTH_TYPE_WPA_NONE:
-		return WLAN_AUTH_TYPE_WPA_NONE;
-	case eCSR_AUTH_TYPE_RSN:
-		return WLAN_AUTH_TYPE_RSN;
-	case eCSR_AUTH_TYPE_RSN_PSK:
-		return WLAN_AUTH_TYPE_RSN_PSK;
-	case eCSR_AUTH_TYPE_FT_RSN:
-		return WLAN_AUTH_TYPE_FT_RSN;
-	case eCSR_AUTH_TYPE_FT_RSN_PSK:
-		return WLAN_AUTH_TYPE_FT_RSN_PSK;
-	case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
-		return WLAN_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
-	case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
-		return WLAN_AUTH_TYPE_WAPI_WAI_PSK;
-	case eCSR_AUTH_TYPE_CCKM_WPA:
-		return WLAN_AUTH_TYPE_CCKM_WPA;
-	case eCSR_AUTH_TYPE_CCKM_RSN:
-		return WLAN_AUTH_TYPE_CCKM_RSN;
-	case eCSR_AUTH_TYPE_RSN_PSK_SHA256:
-		return WLAN_AUTH_TYPE_RSN_PSK_SHA256;
-	case eCSR_AUTH_TYPE_RSN_8021X_SHA256:
-		return WLAN_AUTH_TYPE_RSN_8021X_SHA256;
-	case eCSR_AUTH_TYPE_FILS_SHA256:
-		return WLAN_AUTH_TYPE_FILS_SHA256;
-	case eCSR_AUTH_TYPE_FILS_SHA384:
-		return WLAN_AUTH_TYPE_FILS_SHA384;
-	case eCSR_AUTH_TYPE_FT_FILS_SHA256:
-		return WLAN_AUTH_TYPE_FT_FILS_SHA256;
-	case eCSR_AUTH_TYPE_FT_FILS_SHA384:
-		return WLAN_AUTH_TYPE_FT_FILS_SHA384;
-	case eCSR_AUTH_TYPE_DPP_RSN:
-		return WLAN_AUTH_TYPE_DPP_RSN;
-	case eCSR_AUTH_TYPE_OWE:
-		return WLAN_AUTH_TYPE_OWE;
-	case eCSR_AUTH_TYPE_SUITEB_EAP_SHA256:
-		return WLAN_AUTH_TYPE_SUITEB_EAP_SHA256;
-	case eCSR_AUTH_TYPE_SUITEB_EAP_SHA384:
-		return WLAN_AUTH_TYPE_SUITEB_EAP_SHA384;
-	case eCSR_AUTH_TYPE_SAE:
-		return WLAN_AUTH_TYPE_SAE;
-	case eCSR_AUTH_TYPE_OSEN:
-		return WLAN_AUTH_TYPE_OSEN;
-	case eCSR_AUTH_TYPE_FT_SAE:
-		return WLAN_AUTH_TYPE_FT_SAE;
-	case eCSR_AUTH_TYPE_FT_SUITEB_EAP_SHA384:
-		return WLAN_AUTH_TYPE_FT_SUITEB_EAP_SHA384;
-	case eCSR_NUM_OF_SUPPORT_AUTH_TYPE:
-	default:
-		return WLAN_AUTH_TYPE_OPEN_SYSTEM;
-	}
-}
-
-static enum csr_akm_type csr_covert_auth_type_old(enum wlan_auth_type auth)
-{
-	switch (auth) {
-	case WLAN_AUTH_TYPE_OPEN_SYSTEM:
-		return eCSR_AUTH_TYPE_OPEN_SYSTEM;
-	case WLAN_AUTH_TYPE_SHARED_KEY:
-		return eCSR_AUTH_TYPE_SHARED_KEY;
-	case WLAN_AUTH_TYPE_AUTOSWITCH:
-		return eCSR_AUTH_TYPE_AUTOSWITCH;
-	case WLAN_AUTH_TYPE_WPA:
-		return eCSR_AUTH_TYPE_WPA;
-	case WLAN_AUTH_TYPE_WPA_PSK:
-		return eCSR_AUTH_TYPE_WPA_PSK;
-	case WLAN_AUTH_TYPE_WPA_NONE:
-		return eCSR_AUTH_TYPE_WPA_NONE;
-	case WLAN_AUTH_TYPE_RSN:
-		return eCSR_AUTH_TYPE_RSN;
-	case WLAN_AUTH_TYPE_RSN_PSK:
-		return eCSR_AUTH_TYPE_RSN_PSK;
-	case WLAN_AUTH_TYPE_FT_RSN:
-		return eCSR_AUTH_TYPE_FT_RSN;
-	case WLAN_AUTH_TYPE_FT_RSN_PSK:
-		return eCSR_AUTH_TYPE_FT_RSN_PSK;
-	case WLAN_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
-		return eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
-	case WLAN_AUTH_TYPE_WAPI_WAI_PSK:
-		return eCSR_AUTH_TYPE_WAPI_WAI_PSK;
-	case WLAN_AUTH_TYPE_CCKM_WPA:
-		return eCSR_AUTH_TYPE_CCKM_WPA;
-	case WLAN_AUTH_TYPE_CCKM_RSN:
-		return eCSR_AUTH_TYPE_CCKM_RSN;
-	case WLAN_AUTH_TYPE_RSN_PSK_SHA256:
-		return eCSR_AUTH_TYPE_RSN_PSK_SHA256;
-	case WLAN_AUTH_TYPE_RSN_8021X_SHA256:
-		return eCSR_AUTH_TYPE_RSN_8021X_SHA256;
-	case WLAN_AUTH_TYPE_FILS_SHA256:
-		return eCSR_AUTH_TYPE_FILS_SHA256;
-	case WLAN_AUTH_TYPE_FILS_SHA384:
-		return eCSR_AUTH_TYPE_FILS_SHA384;
-	case WLAN_AUTH_TYPE_FT_FILS_SHA256:
-		return eCSR_AUTH_TYPE_FT_FILS_SHA256;
-	case WLAN_AUTH_TYPE_FT_FILS_SHA384:
-		return eCSR_AUTH_TYPE_FT_FILS_SHA384;
-	case WLAN_AUTH_TYPE_DPP_RSN:
-		return eCSR_AUTH_TYPE_DPP_RSN;
-	case WLAN_AUTH_TYPE_OWE:
-		return eCSR_AUTH_TYPE_OWE;
-	case WLAN_AUTH_TYPE_SUITEB_EAP_SHA256:
-		return eCSR_AUTH_TYPE_SUITEB_EAP_SHA256;
-	case WLAN_AUTH_TYPE_SUITEB_EAP_SHA384:
-		return eCSR_AUTH_TYPE_SUITEB_EAP_SHA384;
-	case WLAN_AUTH_TYPE_SAE:
-		return eCSR_AUTH_TYPE_SAE;
-	case WLAN_AUTH_TYPE_OSEN:
-		return eCSR_AUTH_TYPE_OSEN;
-	case WLAN_AUTH_TYPE_FT_SAE:
-		return eCSR_AUTH_TYPE_FT_SAE;
-	case WLAN_AUTH_TYPE_FT_SUITEB_EAP_SHA384:
-		return eCSR_AUTH_TYPE_FT_SUITEB_EAP_SHA384;
-	case WLAN_NUM_OF_SUPPORT_AUTH_TYPE:
-	default:
-		return eCSR_AUTH_TYPE_OPEN_SYSTEM;
-	}
-}
-
-enum wlan_enc_type csr_covert_enc_type_new(eCsrEncryptionType enc)
-{
-	switch (enc) {
-	case eCSR_ENCRYPT_TYPE_NONE:
-		return WLAN_ENCRYPT_TYPE_NONE;
-	case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
-		return WLAN_ENCRYPT_TYPE_WEP40_STATICKEY;
-	case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
-		return WLAN_ENCRYPT_TYPE_WEP104_STATICKEY;
-	case eCSR_ENCRYPT_TYPE_WEP40:
-		return WLAN_ENCRYPT_TYPE_WEP40;
-	case eCSR_ENCRYPT_TYPE_WEP104:
-		return WLAN_ENCRYPT_TYPE_WEP104;
-	case eCSR_ENCRYPT_TYPE_TKIP:
-		return WLAN_ENCRYPT_TYPE_TKIP;
-	case eCSR_ENCRYPT_TYPE_AES:
-		return WLAN_ENCRYPT_TYPE_AES;
-	case eCSR_ENCRYPT_TYPE_WPI:
-		return WLAN_ENCRYPT_TYPE_WPI;
-	case eCSR_ENCRYPT_TYPE_KRK:
-		return WLAN_ENCRYPT_TYPE_KRK;
-	case eCSR_ENCRYPT_TYPE_BTK:
-		return WLAN_ENCRYPT_TYPE_BTK;
-	case eCSR_ENCRYPT_TYPE_AES_CMAC:
-		return WLAN_ENCRYPT_TYPE_AES_CMAC;
-	case eCSR_ENCRYPT_TYPE_AES_GCMP:
-		return WLAN_ENCRYPT_TYPE_AES_GCMP;
-	case eCSR_ENCRYPT_TYPE_AES_GCMP_256:
-		return WLAN_ENCRYPT_TYPE_AES_GCMP_256;
-	case eCSR_ENCRYPT_TYPE_ANY:
-	default:
-		return WLAN_ENCRYPT_TYPE_NONE;
-	}
-}
-
-static eCsrEncryptionType csr_covert_enc_type_old(enum wlan_enc_type enc)
-{
-	switch (enc) {
-	case WLAN_ENCRYPT_TYPE_NONE:
-		return eCSR_ENCRYPT_TYPE_NONE;
-	case WLAN_ENCRYPT_TYPE_WEP40_STATICKEY:
-		return eCSR_ENCRYPT_TYPE_WEP40_STATICKEY;
-	case WLAN_ENCRYPT_TYPE_WEP104_STATICKEY:
-		return eCSR_ENCRYPT_TYPE_WEP104_STATICKEY;
-	case WLAN_ENCRYPT_TYPE_WEP40:
-		return eCSR_ENCRYPT_TYPE_WEP40;
-	case WLAN_ENCRYPT_TYPE_WEP104:
-		return eCSR_ENCRYPT_TYPE_WEP104;
-	case WLAN_ENCRYPT_TYPE_TKIP:
-		return eCSR_ENCRYPT_TYPE_TKIP;
-	case WLAN_ENCRYPT_TYPE_AES:
-		return eCSR_ENCRYPT_TYPE_AES;
-	case WLAN_ENCRYPT_TYPE_WPI:
-		return eCSR_ENCRYPT_TYPE_WPI;
-	case WLAN_ENCRYPT_TYPE_KRK:
-		return eCSR_ENCRYPT_TYPE_KRK;
-	case WLAN_ENCRYPT_TYPE_BTK:
-		return eCSR_ENCRYPT_TYPE_BTK;
-	case WLAN_ENCRYPT_TYPE_AES_CMAC:
-		return eCSR_ENCRYPT_TYPE_AES_CMAC;
-	case WLAN_ENCRYPT_TYPE_AES_GCMP:
-		return eCSR_ENCRYPT_TYPE_AES_GCMP;
-	case WLAN_ENCRYPT_TYPE_AES_GCMP_256:
-		return eCSR_ENCRYPT_TYPE_AES_GCMP_256;
-	case WLAN_ENCRYPT_TYPE_ANY:
-	default:
-		return eCSR_ENCRYPT_TYPE_NONE;
-	}
-}
-
-static void csr_fill_neg_crypto_info(struct tag_csrscan_result *bss,
-				     struct security_info *sec_info)
-{
-	bss->ucEncryptionType =
-		csr_covert_enc_type_old(sec_info->uc_enc);
-	bss->mcEncryptionType =
-		csr_covert_enc_type_old(sec_info->mc_enc);
-	bss->authType =
-		csr_covert_auth_type_old(sec_info->auth_type);
-}
-
-#endif
-
 #ifdef WLAN_FEATURE_FILS_SK
 /**
  * csr_update_bss_with_fils_data: Fill FILS params in bss desc from scan entry
@@ -2893,8 +2675,7 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 		return;
 	}
 
-	status = csr_fill_crypto_params_connected_profile(mac_ctx, profile,
-							  filter, sessionId);
+	status = csr_fill_filter_from_vdev_crypto(mac_ctx, filter, sessionId);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sme_err("fail to fill filter crypto");
 		qdf_mem_free(filter);
diff --git a/core/sme/src/csr/csr_inside_api.h b/core/sme/src/csr/csr_inside_api.h
index 9dded50e508b..0bcd0d835ef9 100644
--- a/core/sme/src/csr/csr_inside_api.h
+++ b/core/sme/src/csr/csr_inside_api.h
@@ -418,8 +418,6 @@ csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
 }
 #endif
 
-#ifdef WLAN_SCAN_SECURITY_FILTER_V1
-
 /*
  * csr_fill_filter_from_vdev_crypto() - fill scan filter crypto from vdev crypto
  * @mac_ctx: csr auth type
@@ -431,24 +429,6 @@ csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
 QDF_STATUS csr_fill_filter_from_vdev_crypto(struct mac_context *mac_ctx,
 					    struct scan_filter *filter,
 					    uint8_t vdev_id);
-#else
-
-/*
- * csr_covert_enc_type_new() - convert csr enc type to wlan enc type
- * @enc: csr enc type
- *
- * Return enum wlan_enc_type
- */
-enum wlan_enc_type csr_covert_enc_type_new(eCsrEncryptionType enc);
-
-/*
- * csr_covert_auth_type_new() - convert csr auth type to wlan auth type
- * @auth: csr auth type
- *
- * Return enum wlan_auth_type
- */
-enum wlan_auth_type csr_covert_auth_type_new(enum csr_akm_type auth);
-#endif
 
 /*
  * csr_set_open_mode_in_scan_filter() - set open mode in scan filter
@@ -478,22 +458,6 @@ csr_roam_get_scan_filter_from_profile(struct mac_context *mac_ctx,
 				      struct scan_filter *filter,
 				      bool is_roam, uint8_t vdev_id);
 
-/*
- * csr_fill_crypto_params_connected_profile() - fill scan filter crypto from
- * connected profile
- * @mac_ctx: csr auth type
- * @profile: connected profile
- * @filter: scan filter
- * @vdev_id: vdev
- *
- * Return QDF_STATUS
- */
-QDF_STATUS
-csr_fill_crypto_params_connected_profile(struct mac_context *mac_ctx,
-					 tCsrRoamConnectedProfile *profile,
-					 struct scan_filter *filter,
-					 uint8_t vdev_id);
-
 /**
  * csr_neighbor_roam_get_scan_filter_from_profile() - prepare scan filter from
  * connected profile
diff --git a/core/sme/src/csr/csr_neighbor_roam.c b/core/sme/src/csr/csr_neighbor_roam.c
index 192cea1e2a82..3a4d2e1a3912 100644
--- a/core/sme/src/csr/csr_neighbor_roam.c
+++ b/core/sme/src/csr/csr_neighbor_roam.c
@@ -340,35 +340,6 @@ csr_update_pmf_cap_from_connected_profile(tCsrRoamConnectedProfile *profile,
 {}
 #endif
 
-#ifdef WLAN_SCAN_SECURITY_FILTER_V1
-QDF_STATUS
-csr_fill_crypto_params_connected_profile(struct mac_context *mac_ctx,
-					 tCsrRoamConnectedProfile *profile,
-					 struct scan_filter *filter,
-					 uint8_t vdev_id)
-{
-	return csr_fill_filter_from_vdev_crypto(mac_ctx, filter, vdev_id);
-}
-#else
-QDF_STATUS
-csr_fill_crypto_params_connected_profile(struct mac_context *mac_ctx,
-					 tCsrRoamConnectedProfile *profile,
-					 struct scan_filter *filter,
-					 uint8_t vdev_id)
-{
-	filter->num_of_auth = 1;
-	filter->auth_type[0] = csr_covert_auth_type_new(profile->AuthType);
-	filter->num_of_enc_type = 1;
-	filter->enc_type[0] =
-		csr_covert_enc_type_new(profile->EncryptionType);
-	filter->num_of_mc_enc_type = 1;
-	filter->mc_enc_type[0] =
-		csr_covert_enc_type_new(profile->mcEncryptionType);
-
-	return QDF_STATUS_SUCCESS;
-}
-#endif
-
 QDF_STATUS
 csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
 					       struct scan_filter *filter,
@@ -420,8 +391,8 @@ csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
 			  filter->ssid_list[0].length);
 	}
 
-	status = csr_fill_crypto_params_connected_profile(mac, profile, filter,
-							  vdev_id);
+	status = csr_fill_filter_from_vdev_crypto(mac, filter, vdev_id);
+
 	if (QDF_IS_STATUS_ERROR(status))
 		return status;