samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Remove older scan filter params

Browse Source 
Remove older unused scan filter params and code related to it.

Change-Id: Ia1c9612e2be22ef2dada8be01cc404ec15318359
CRs-Fixed: 2737925
This commit is contained in:
Abhishek Singh
2020-07-22 12:00:39 +05:30
committed by snandini
parent 7d1262b85e
commit e34b54a7b7
5 changed files with 4 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Kbuild
View File

@@ -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

58
core/sme/src/csr/csr_api_roam.c
View File

@@ -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,

221
core/sme/src/csr/csr_api_scan.c
View File

@@ -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);

36
core/sme/src/csr/csr_inside_api.h
View File

@@ -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

33
core/sme/src/csr/csr_neighbor_roam.c
View File

@@ -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;