qcacld-3.0: Cleanup old scan filter

Driver uses old scan filter and old scan filter is converted
into new scan filter while sending scan command.

TO avoid this conversion use and fill new scan filter whenever
required.

Change-Id: Ib7e1c571c042a36f0b5864033ba640e8df1cd2f1
CRs-Fixed: 2544677

core/sme/inc/csr_api.h

@@ -269,56 +269,6 @@ typedef struct sCsrChannel_ {
 	uint32_t channel_freq_list[CFG_VALID_CHANNEL_LIST_LEN];
 } sCsrChannel;
 
-typedef struct tagCsrScanResultFilter {
-	tCsrBSSIDs BSSIDs;
-	tCsrSSIDs SSIDs;
-	tCsrChannelInfo ChannelInfo;
-	tCsrAuthList authType;
-	tCsrEncryptionList EncryptionType;
-	/*
-	 * eCSR_ENCRYPT_TYPE_ANY cannot be set in multicast encryption type.
-	 * If caller doesn't case, put all supported encryption types in here
-	 */
-	tCsrEncryptionList mcEncryptionType;
-	eCsrRoamBssType BSSType;
-	/* its a bit mask of all the needed phy mode defined in eCsrPhyMode */
-	eCsrPhyMode phyMode;
-	/*
-	 * If countryCode[0] is not 0, countryCode is checked
-	 * independent of fCheckUnknownCountryCode
-	 */
-	uint8_t countryCode[CFG_COUNTRY_CODE_LEN];
-	uint8_t uapsd_mask;
-	/* For WPS filtering if true => auth and ecryption should be ignored */
-	bool bWPSAssociation;
-	bool bOSENAssociation;
-	/*
-	 * For measurement reports --> if set, only SSID,
-	 * BSSID and channel is considered for filtering.
-	 */
-	bool fMeasurement;
-	struct mobility_domain_info mdid;
-	bool p2pResult;
-#ifdef WLAN_FEATURE_11W
-	/* Management Frame Protection */
-	bool MFPEnabled;
-	uint8_t MFPRequired;
-	uint8_t MFPCapable;
-#endif
-	/* The following flag is used to distinguish the
-	 * roaming case while building the scan filter and
-	 * applying it on to the scan results. This is mainly
-	 * used to support whitelist ssid feature.
-	 */
-	uint8_t scan_filter_for_roam;
-	struct qdf_mac_addr bssid_hint;
-	enum QDF_OPMODE csrPersona;
-	bool realm_check;
-	uint8_t fils_realm[2];
-	bool force_rsne_override;
-	qdf_time_t age_threshold;
-} tCsrScanResultFilter;
-
 typedef struct sCsrChnPower_ {
 	uint32_t first_chan_freq;
 	uint8_t numChannels;

core/sme/inc/csr_neighbor_roam.h

@@ -164,8 +164,6 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 		uint8_t sessionId);
 QDF_STATUS csr_neighbor_roam_init(struct mac_context *mac, uint8_t sessionId);
 void csr_neighbor_roam_close(struct mac_context *mac, uint8_t sessionId);
-QDF_STATUS csr_neighbor_roam_prepare_scan_profile_filter(struct mac_context *mac,
-		tCsrScanResultFilter *pScanFilter, uint8_t sessionId);
 QDF_STATUS csr_neighbor_roam_preauth_rsp_handler(struct mac_context *mac,
 		uint8_t sessionId, QDF_STATUS limStatus);
 bool csr_neighbor_roam_is11r_assoc(struct mac_context *mac, uint8_t sessionId);

core/sme/inc/sme_api.h

@@ -475,9 +475,18 @@ void sme_purge_pdev_all_ser_cmd_list(mac_handle_t mac_handle);
 QDF_STATUS sme_process_msg(struct mac_context *mac, struct scheduler_msg *pMsg);
 
 QDF_STATUS sme_mc_process_handler(struct scheduler_msg *msg);
-QDF_STATUS sme_scan_get_result(mac_handle_t mac_handle, uint8_t sessionId,
-		tCsrScanResultFilter *pFilter,
-		tScanResultHandle *phResult);
+/*
+ * sme_scan_get_result() - Return scan results based on filter
+ * @mac: Pointer to Global MAC structure
+ * @vdev_id: vdev_id
+ * @filter: If pFilter is NULL, all cached results are returned
+ * @phResult: an object for the result.
+ *
+ * Return QDF_STATUS
+ */
+QDF_STATUS sme_scan_get_result(mac_handle_t mac_handle, uint8_t vdev_id,
+			       struct scan_filter *filter,
+			       tScanResultHandle *phResult);
 QDF_STATUS sme_get_ap_channel_from_scan_cache(
 		struct csr_roam_profile *profile,
 		tScanResultHandle *scan_cache,

core/sme/src/common/sme_api.c

@@ -2544,29 +2544,19 @@ QDF_STATUS sme_remove_bssid_from_scan_list(mac_handle_t mac_handle,
 	return status;
 }
 
-
-/*
- * sme_scan_get_result
- * A wrapper function to request scan results from CSR.
- * This is a synchronous call
- *
- * pFilter - If pFilter is NULL, all cached results are returned
- * phResult - an object for the result.
- * Return QDF_STATUS
- */
-QDF_STATUS sme_scan_get_result(mac_handle_t mac_handle, uint8_t sessionId,
-			       tCsrScanResultFilter *pFilter,
+QDF_STATUS sme_scan_get_result(mac_handle_t mac_handle, uint8_t vdev_id,
+			       struct scan_filter *filter,
 			       tScanResultHandle *phResult)
 {
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 
 	MTRACE(qdf_trace(QDF_MODULE_ID_SME,
-			 TRACE_CODE_SME_RX_HDD_MSG_SCAN_GET_RESULTS, sessionId,
+			 TRACE_CODE_SME_RX_HDD_MSG_SCAN_GET_RESULTS, vdev_id,
 			 0));
 	status = sme_acquire_global_lock(&mac->sme);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		status = csr_scan_get_result(mac, pFilter, phResult);
+		status = csr_scan_get_result(mac, filter, phResult);
 		sme_release_global_lock(&mac->sme);
 	}
 
@@ -2633,7 +2623,7 @@ QDF_STATUS sme_get_ap_channel_from_scan_cache(
 {
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	struct mac_context *mac_ctx = sme_get_mac_context();
-	tCsrScanResultFilter *scan_filter = NULL;
+	struct scan_filter *scan_filter;
 	tScanResultHandle filtered_scan_result = NULL;
 	struct bss_description first_ap_profile;
 	uint8_t bss_chan_id;
@@ -2643,34 +2633,24 @@ QDF_STATUS sme_get_ap_channel_from_scan_cache(
 				FL("mac_ctx is NULL"));
 		return QDF_STATUS_E_FAILURE;
 	}
-	scan_filter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
+	scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
 	if (!scan_filter)
 		return QDF_STATUS_E_FAILURE;
 
 	qdf_mem_zero(&first_ap_profile, sizeof(struct bss_description));
 	if (!profile) {
-		scan_filter->EncryptionType.numEntries = 1;
-		scan_filter->EncryptionType.encryptionType[0]
-				= eCSR_ENCRYPT_TYPE_NONE;
+		/* No encryption */
+		scan_filter->num_of_enc_type = 1;
+		scan_filter->enc_type[0] = WLAN_ENCRYPT_TYPE_NONE;
 	} else {
 		/* Here is the profile we need to connect to */
-		status = csr_roam_prepare_filter_from_profile(mac_ctx,
-					profile,
-					scan_filter);
+		status = csr_roam_get_scan_filter_from_profile(mac_ctx,
+							       profile,
+							       scan_filter,
+							       false);
 	}
 
-	if (QDF_STATUS_SUCCESS == status) {
-		/* Save the WPS info */
-		if (profile) {
-			scan_filter->bWPSAssociation =
-						 profile->bWPSAssociation;
-			scan_filter->bOSENAssociation =
-						 profile->bOSENAssociation;
-		} else {
-			scan_filter->bWPSAssociation = 0;
-			scan_filter->bOSENAssociation = 0;
-		}
-	} else {
+	if (QDF_IS_STATUS_ERROR(status)) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
 			FL("Preparing the profile filter failed"));
 		qdf_mem_free(scan_filter);
@@ -2709,13 +2689,12 @@ QDF_STATUS sme_get_ap_channel_from_scan_cache(
 			sme_err("Failed to get scan get result");
 			status = QDF_STATUS_E_FAILURE;
 		}
-		csr_free_scan_filter(mac_ctx, scan_filter);
 		sme_release_global_lock(&mac_ctx->sme);
 	} else {
-		csr_free_scan_filter(mac_ctx, scan_filter);
 		status = QDF_STATUS_E_FAILURE;
 	}
 	qdf_mem_free(scan_filter);
+
 	return status;
 }
 
@@ -13894,43 +13873,37 @@ QDF_STATUS sme_get_rssi_snr_by_bssid(mac_handle_t mac_handle,
 				     int8_t *rssi, int8_t *snr)
 {
 	struct bss_description *bss_descp;
-	tCsrScanResultFilter *scan_filter;
+	struct scan_filter *scan_filter;
 	struct scan_result_list *bss_list;
 	tScanResultHandle result_handle = NULL;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
 
-	scan_filter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
+	scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
 	if (!scan_filter) {
 		status = QDF_STATUS_E_NOMEM;
-		goto free_scan_flter;
+		goto exit;
 	}
 
-	status = csr_roam_prepare_filter_from_profile(mac_ctx,
-						profile, scan_filter);
+	status = csr_roam_get_scan_filter_from_profile(mac_ctx,
+						       profile, scan_filter,
+						       false);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("prepare_filter failed");
-		goto free_scan_flter;
+		qdf_mem_free(scan_filter);
+		goto exit;
 	}
 
 	/* update filter to get scan result with just target BSSID */
-	if (!scan_filter->BSSIDs.bssid) {
-		scan_filter->BSSIDs.bssid =
-			qdf_mem_malloc(sizeof(struct qdf_mac_addr));
-		if (!scan_filter->BSSIDs.bssid) {
-			status = QDF_STATUS_E_NOMEM;
-			goto free_scan_flter;
-		}
-	}
-
-	scan_filter->BSSIDs.numOfBSSIDs = 1;
-	qdf_mem_copy(scan_filter->BSSIDs.bssid[0].bytes,
+	scan_filter->num_of_bssid = 1;
+	qdf_mem_copy(scan_filter->bssid_list[0].bytes,
 		     bssid, sizeof(struct qdf_mac_addr));
 
 	status = csr_scan_get_result(mac_ctx, scan_filter, &result_handle);
+	qdf_mem_free(scan_filter);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_debug("parse_scan_result failed");
-		goto free_scan_flter;
+		goto exit;
 	}
 
 	bss_list = (struct scan_result_list *)result_handle;
@@ -13938,7 +13911,7 @@ QDF_STATUS sme_get_rssi_snr_by_bssid(mac_handle_t mac_handle,
 	if (!bss_descp) {
 		sme_err("unable to fetch bss descriptor");
 		status = QDF_STATUS_E_FAULT;
-		goto free_scan_flter;
+		goto exit;
 	}
 
 	sme_debug("snr: %d, rssi: %d, raw_rssi: %d",
@@ -13949,13 +13922,7 @@ QDF_STATUS sme_get_rssi_snr_by_bssid(mac_handle_t mac_handle,
 	if (snr)
 		*snr = bss_descp->sinr;
 
-free_scan_flter:
-	/* free scan filter and exit */
-	if (scan_filter) {
-		csr_free_scan_filter(mac_ctx, scan_filter);
-		qdf_mem_free(scan_filter);
-	}
-
+exit:
 	if (result_handle)
 		csr_scan_result_purge(mac_ctx, result_handle);
 
@@ -13970,44 +13937,39 @@ QDF_STATUS sme_get_beacon_frm(mac_handle_t mac_handle,
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	tScanResultHandle result_handle = NULL;
-	tCsrScanResultFilter *scan_filter;
+	struct scan_filter *scan_filter;
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
 	struct bss_description *bss_descp;
 	struct scan_result_list *bss_list;
 	uint32_t ie_len;
 	uint8_t bss_chan_id;
 
-	scan_filter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
+	scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
 	if (!scan_filter) {
 		status = QDF_STATUS_E_NOMEM;
-		goto free_scan_flter;
+		goto exit;
 	}
-	status = csr_roam_prepare_filter_from_profile(mac_ctx,
-						profile, scan_filter);
+	status = csr_roam_get_scan_filter_from_profile(mac_ctx,
+						       profile, scan_filter,
+						       false);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sme_err("prepare_filter failed");
 		status = QDF_STATUS_E_FAULT;
-		goto free_scan_flter;
+		qdf_mem_free(scan_filter);
+		goto exit;
 	}
 
 	/* update filter to get scan result with just target BSSID */
-	if (!scan_filter->BSSIDs.bssid) {
-		scan_filter->BSSIDs.bssid =
-			qdf_mem_malloc(sizeof(struct qdf_mac_addr));
-		if (!scan_filter->BSSIDs.bssid) {
-			status = QDF_STATUS_E_NOMEM;
-			goto free_scan_flter;
-		}
-	}
-	scan_filter->BSSIDs.numOfBSSIDs = 1;
-	qdf_mem_copy(scan_filter->BSSIDs.bssid[0].bytes,
+	scan_filter->num_of_bssid = 1;
+	qdf_mem_copy(scan_filter->bssid_list[0].bytes,
 		     bssid, sizeof(struct qdf_mac_addr));
 
 	status = csr_scan_get_result(mac_ctx, scan_filter, &result_handle);
+	qdf_mem_free(scan_filter);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("parse_scan_result failed");
 		status = QDF_STATUS_E_FAULT;
-		goto free_scan_flter;
+		goto exit;
 	}
 
 	bss_list = (struct scan_result_list *)result_handle;
@@ -14015,7 +13977,7 @@ QDF_STATUS sme_get_beacon_frm(mac_handle_t mac_handle,
 	if (!bss_descp) {
 		sme_err("unable to fetch bss descriptor");
 		status = QDF_STATUS_E_FAULT;
-		goto free_scan_flter;
+		goto exit;
 	}
 
 	/**
@@ -14041,19 +14003,14 @@ QDF_STATUS sme_get_beacon_frm(mac_handle_t mac_handle,
 	*frame_buf = qdf_mem_malloc(*frame_len);
 	if (!*frame_buf) {
 		status = QDF_STATUS_E_NOMEM;
-		goto free_scan_flter;
+		goto exit;
 	}
 
 	sme_prepare_beacon_from_bss_descp(*frame_buf, bss_descp, bssid, ie_len);
 
 	if (!*channel)
 		*channel = bss_chan_id;
-free_scan_flter:
-	/* free scan filter and exit */
-	if (scan_filter) {
-		csr_free_scan_filter(mac_ctx, scan_filter);
-		qdf_mem_free(scan_filter);
-	}
+exit:
 	if (result_handle)
 		csr_scan_result_purge(mac_ctx, result_handle);
 

core/sme/src/csr/csr_api_roam.c

@@ -8354,12 +8354,13 @@ QDF_STATUS csr_roam_connect(struct mac_context *mac, uint32_t sessionId,
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	tScanResultHandle hBSSList;
-	tCsrScanResultFilter *pScanFilter;
+	struct scan_filter *filter;
 	uint32_t roamId = 0;
 	bool fCallCallback = false;
 	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
 	struct bss_description *first_ap_profile;
 	uint8_t channel_id = 0, first_ap_chan_id;
+	enum QDF_OPMODE opmode = QDF_STA_MODE;
 
 	if (!pSession) {
 		sme_err("session does not exist for given sessionId: %d",
@@ -8409,41 +8410,31 @@ QDF_STATUS csr_roam_connect(struct mac_context *mac, uint32_t sessionId,
 		mac->roam.roamSession[sessionId].connectState =
 			eCSR_ASSOC_STATE_TYPE_NOT_CONNECTED;
 
-	pScanFilter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
-	if (!pScanFilter) {
+	filter = qdf_mem_malloc(sizeof(*filter));
+	if (!filter) {
 		status = QDF_STATUS_E_NOMEM;
-		goto end;
+		goto error;
 	}
 
 	/* Try to connect to any BSS */
 	if (!pProfile) {
 		/* No encryption */
-		pScanFilter->EncryptionType.numEntries = 1;
-		pScanFilter->EncryptionType.encryptionType[0] =
-			eCSR_ENCRYPT_TYPE_NONE;
+		filter->num_of_enc_type = 1;
+		filter->enc_type[0] = WLAN_ENCRYPT_TYPE_NONE;
 	} else {
 		/* Here is the profile we need to connect to */
-		status = csr_roam_prepare_filter_from_profile(mac,
-				pProfile, pScanFilter);
+		status = csr_roam_get_scan_filter_from_profile(mac, pProfile,
+							       filter, false);
+		opmode = pProfile->csrPersona;
 	}
 	roamId = GET_NEXT_ROAM_ID(&mac->roam);
 	if (pRoamId)
 		*pRoamId = roamId;
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
-		qdf_mem_free(pScanFilter);
-		goto end;
+		qdf_mem_free(filter);
+		goto error;
 	}
 
-	/*Save the WPS info */
-	if (pProfile) {
-		pScanFilter->bWPSAssociation =
-			pProfile->bWPSAssociation;
-		pScanFilter->bOSENAssociation =
-			pProfile->bOSENAssociation;
-	} else {
-		pScanFilter->bWPSAssociation = 0;
-		pScanFilter->bOSENAssociation = 0;
-	}
 	if (pProfile && CSR_IS_INFRA_AP(pProfile)) {
 		/* This can be started right away */
 		status = csr_roam_issue_connect(mac, sessionId, pProfile, NULL,
@@ -8455,17 +8446,17 @@ QDF_STATUS csr_roam_connect(struct mac_context *mac, uint32_t sessionId,
 		} else
 			sme_debug("Connect request to proceed for sap mode");
 
-		csr_free_scan_filter(mac, pScanFilter);
-		qdf_mem_free(pScanFilter);
-		goto end;
+		qdf_mem_free(filter);
+		goto error;
 	}
-	status = csr_scan_get_result(mac, pScanFilter, &hBSSList);
+	status = csr_scan_get_result(mac, filter, &hBSSList);
+	qdf_mem_free(filter);
 	sme_debug("csr_scan_get_result Status: %d", status);
 	csr_roam_print_candidate_aps(hBSSList);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
 		/* check if set hw mode needs to be done */
-		if ((pScanFilter->csrPersona == QDF_STA_MODE) ||
-		    (pScanFilter->csrPersona == QDF_P2P_CLIENT_MODE)) {
+		if ((opmode == QDF_STA_MODE) ||
+		    (opmode == QDF_P2P_CLIENT_MODE)) {
 			bool ok;
 
 			csr_get_bssdescr_from_scan_handle(hBSSList,
@@ -8555,15 +8546,6 @@ QDF_STATUS csr_roam_connect(struct mac_context *mac, uint32_t sessionId,
 	}
 
 error:
-	if (pProfile)
-		/*
-		 * we need to free memory for filter
-		 * if profile exists
-		 */
-		csr_free_scan_filter(mac, pScanFilter);
-
-	qdf_mem_free(pScanFilter);
-end:
 	/* tell the caller if we fail to trigger a join request */
 	if (fCallCallback) {
 		csr_roam_call_callback(mac, sessionId, NULL, roamId,
@@ -9731,15 +9713,10 @@ static void
 csr_post_roam_failure(struct mac_context *mac_ctx,
 		      uint32_t session_id,
 		      struct csr_roam_info *roam_info,
-		      struct tagCsrScanResultFilter *scan_filter,
 		      struct csr_roam_profile *cur_roam_profile)
 {
 	QDF_STATUS status;
 
-	if (scan_filter) {
-		csr_free_scan_filter(mac_ctx, scan_filter);
-		qdf_mem_free(scan_filter);
-	}
 	if (cur_roam_profile)
 		qdf_mem_free(cur_roam_profile);
 
@@ -9772,7 +9749,6 @@ csr_post_roam_failure(struct mac_context *mac_ctx,
  * csr_check_profile_in_scan_cache() - finds if roam profile is present in scan
  * cache or not
  * @mac:                  mac global context
- * @scan_filter:           out param, scan filter
  * @neighbor_roam_info:    roam info struct
  * @hBSSList:              scan result
  *
@@ -9780,26 +9756,28 @@ csr_post_roam_failure(struct mac_context *mac_ctx,
  */
 static bool
 csr_check_profile_in_scan_cache(struct mac_context *mac_ctx,
-				tCsrScanResultFilter **scan_filter,
 				tpCsrNeighborRoamControlInfo neighbor_roam_info,
 				tScanResultHandle *hBSSList)
 {
 	QDF_STATUS status;
-	*scan_filter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
-	if (!*scan_filter)
+	struct scan_filter *scan_filter;
+
+	scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
+	if (!scan_filter)
 		return false;
 
-	(*scan_filter)->scan_filter_for_roam = 1;
-	status = csr_roam_prepare_filter_from_profile(mac_ctx,
+	status = csr_roam_get_scan_filter_from_profile(mac_ctx,
 			&neighbor_roam_info->csrNeighborRoamProfile,
-			*scan_filter);
+			scan_filter, true);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		sme_err(
 			"failed to prepare scan filter, status %d",
 			status);
+		qdf_mem_free(scan_filter);
 		return false;
 	}
-	status = csr_scan_get_result(mac_ctx, *scan_filter, hBSSList);
+	status = csr_scan_get_result(mac_ctx, scan_filter, hBSSList);
+	qdf_mem_free(scan_filter);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		sme_err(
 			"csr_scan_get_result failed, status %d",
@@ -9902,8 +9880,7 @@ purge_scan_result:
 	csr_scan_result_purge(mac, scan_handle_roam_ap);
 
 POST_ROAM_FAILURE:
-	csr_post_roam_failure(mac, session_id, roam_info,
-			      NULL, NULL);
+	csr_post_roam_failure(mac, session_id, roam_info, NULL);
 	qdf_mem_free(roam_info);
 	return status;
 }
@@ -9913,7 +9890,6 @@ void csr_handle_disassoc_ho(struct mac_context *mac, uint32_t session_id)
 {
 	uint32_t roam_id = 0;
 	struct csr_roam_info *roam_info;
-	struct tagCsrScanResultFilter *scan_filter = NULL;
 	struct sCsrNeighborRoamControlInfo *neighbor_roam_info = NULL;
 	struct scan_result_list *scan_handle_roam_ap;
 	struct sCsrNeighborRoamBSSInfo *bss_node;
@@ -9930,8 +9906,7 @@ void csr_handle_disassoc_ho(struct mac_context *mac, uint32_t session_id)
 	 * First ensure if the roam profile is in the scan cache.
 	 * If not, post a reassoc failure and disconnect.
 	 */
-	if (!csr_check_profile_in_scan_cache(mac, &scan_filter,
-			     neighbor_roam_info,
+	if (!csr_check_profile_in_scan_cache(mac, neighbor_roam_info,
 			     (tScanResultHandle *)&scan_handle_roam_ap))
 		goto POST_ROAM_FAILURE;
 
@@ -9976,8 +9951,6 @@ void csr_handle_disassoc_ho(struct mac_context *mac, uint32_t session_id)
 		/*if hw_mode change is required then handle roam
 		* issue connect in mode change response handler
 		*/
-		csr_free_scan_filter(mac, scan_filter);
-		qdf_mem_free(scan_filter);
 		qdf_mem_free(roam_info);
 		return;
 	} else if (status == QDF_STATUS_E_FAILURE)
@@ -9987,15 +9960,13 @@ void csr_handle_disassoc_ho(struct mac_context *mac, uint32_t session_id)
 					     scan_handle_roam_ap,
 					     roam_id);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		csr_free_scan_filter(mac, scan_filter);
-		qdf_mem_free(scan_filter);
 		qdf_mem_free(roam_info);
 		return;
 	}
 	csr_scan_result_purge(mac, scan_handle_roam_ap);
 
 POST_ROAM_FAILURE:
-	csr_post_roam_failure(mac, session_id, roam_info, scan_filter, NULL);
+	csr_post_roam_failure(mac, session_id, roam_info, NULL);
 	qdf_mem_free(roam_info);
 }
 #else
@@ -11012,15 +10983,8 @@ csr_create_fils_realm_hash(struct cds_fils_connection_info *fils_con_info,
 	return true;
 }
 
-/*
- * csr_update_fils_scan_filter: update scan filter in case of fils session
- * @scan_fltr: pointer to scan filer
- * @profile: csr profile pointer
- *
- * Return: None
- */
-static void csr_update_fils_scan_filter(tCsrScanResultFilter *scan_fltr,
-				struct csr_roam_profile *profile)
+static void csr_update_fils_scan_filter(struct scan_filter *filter,
+					struct csr_roam_profile *profile)
 {
 	if (profile->fils_con_info &&
 	    profile->fils_con_info->is_fils_connection) {
@@ -11028,184 +10992,344 @@ static void csr_update_fils_scan_filter(tCsrScanResultFilter *scan_fltr,
 
 		sme_debug("creating realm based on fils info %d",
 			profile->fils_con_info->is_fils_connection);
-		scan_fltr->realm_check =  csr_create_fils_realm_hash(
-				profile->fils_con_info, realm_hash);
-		memcpy(scan_fltr->fils_realm, realm_hash,
-			sizeof(uint8_t) * 2);
+		filter->fils_scan_filter.realm_check =
+			csr_create_fils_realm_hash(profile->fils_con_info,
+						   realm_hash);
+		if (filter->fils_scan_filter.realm_check)
+			qdf_mem_copy(filter->fils_scan_filter.fils_realm,
+				     realm_hash, REAM_HASH_LEN);
 	}
-
 }
+
 #else
-static void csr_update_fils_scan_filter(tCsrScanResultFilter *scan_fltr,
-				struct csr_roam_profile *profile)
+static void csr_update_fils_scan_filter(struct scan_filter *filter,
+					struct csr_roam_profile *profile)
 { }
 #endif
 
-/*
- * Prepare a filter base on a profile for parsing the scan results.
- * Upon successful return, caller MUST call csr_free_scan_filter on
- *pScanFilter when it is done with the filter.
+static inline void csr_copy_ssids(struct wlan_ssid *ssid, tSirMacSSid *from)
+{
+	ssid->length = from->length;
+	if (ssid->length > WLAN_SSID_MAX_LEN)
+		ssid->length = WLAN_SSID_MAX_LEN;
+	qdf_mem_copy(ssid->ssid, from->ssId, ssid->length);
+}
+
+void csr_copy_ssids_from_roam_params(struct roam_ext_params *roam_params,
+				     struct scan_filter *filter)
+{
+	uint8_t i;
+
+	if (!roam_params->num_ssid_allowed_list)
+		return;
+
+	filter->num_of_ssid = roam_params->num_ssid_allowed_list;
+	if (filter->num_of_ssid > WLAN_SCAN_FILTER_NUM_SSID)
+		filter->num_of_ssid = WLAN_SCAN_FILTER_NUM_SSID;
+	for  (i = 0; i < filter->num_of_ssid; i++)
+		csr_copy_ssids(&filter->ssid_list[i],
+			       &roam_params->ssid_allowed_list[i]);
+}
+
+static void csr_copy_ssids_from_profile(tCsrSSIDs *ssid_list,
+					struct scan_filter *filter)
+{
+	uint8_t i;
+
+	filter->num_of_ssid = ssid_list->numOfSSIDs;
+	if (filter->num_of_ssid > WLAN_SCAN_FILTER_NUM_SSID)
+		filter->num_of_ssid = WLAN_SCAN_FILTER_NUM_SSID;
+	for (i = 0; i < filter->num_of_ssid; i++)
+		csr_copy_ssids(&filter->ssid_list[i],
+			       &ssid_list->SSIDList[i].SSID);
+}
+
+#ifdef WLAN_ADAPTIVE_11R
+static void
+csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
+				    struct scan_filter *filter)
+{
+	filter->enable_adaptive_11r =
+		   mac_ctx->mlme_cfg->lfr.enable_adaptive_11r;
+}
+#else
+static inline void
+csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
+				    struct scan_filter *filter)
+{
+	filter->enable_adaptive_11r = false;
+}
+#endif
+
+void csr_update_connect_n_roam_cmn_filter(struct mac_context *mac_ctx,
+					  struct scan_filter *filter,
+					  enum QDF_OPMODE opmode)
+{
+	enum policy_mgr_con_mode pm_mode;
+	uint32_t len = 0;
+	QDF_STATUS status;
+
+	/* enable bss scoring for only STA mode */
+	if (opmode == QDF_STA_MODE)
+		filter->bss_scoring_required = true;
+
+	csr_update_adaptive_11r_scan_filter(mac_ctx, filter);
+
+	if (filter->num_of_bssid)
+		return;
+
+	if (policy_mgr_map_concurrency_mode(&opmode, &pm_mode)) {
+		status = policy_mgr_get_pcl(mac_ctx->psoc, pm_mode,
+					    filter->pcl_channel_list, &len,
+					    filter->pcl_weight_list,
+					    QDF_MAX_NUM_CHAN);
+		if (QDF_IS_STATUS_ERROR(status))
+			return;
+		filter->num_of_pcl_channels = len;
+	}
+}
+
+#ifdef FEATURE_WLAN_WAPI
+/**
+ * csr_update_phy_mode: Updates phy mode for wapi
+ * @profile: Source profile
+ * @phy_mode: phy_mode to be modified
+ *
+ * Return: None
+ */
+static void csr_update_phy_mode(struct csr_roam_profile *profile,
+				uint32_t *phy_mode)
+{
+	/*
+	 * check if user asked for WAPI with 11n or auto mode, in that
+	 * case modify the phymode to 11g
+	 */
+	if (csr_is_profile_wapi(profile)) {
+		if (*phy_mode & eCSR_DOT11_MODE_11n)
+			*phy_mode &= ~eCSR_DOT11_MODE_11n;
+		if (*phy_mode & eCSR_DOT11_MODE_AUTO)
+			*phy_mode &= ~eCSR_DOT11_MODE_AUTO;
+		if (!*phy_mode)
+			*phy_mode = eCSR_DOT11_MODE_11g;
+	}
+}
+#else
+static inline
+void csr_update_phy_mode(struct csr_roam_profile *profile, uint32_t *phy_mode)
+{}
+#endif
+
+/**
+ * csr_convert_dotllmod_phymode: Convert eCsrPhyMode to wlan_phymode
+ * @dotllmode: phy mode
+ *
+ * Return: returns enum wlan_phymode
  */
+static enum wlan_phymode csr_convert_dotllmod_phymode(eCsrPhyMode dotllmode)
+{
+	enum wlan_phymode con_phy_mode;
+
+	switch (dotllmode) {
+	case eCSR_DOT11_MODE_abg:
+		con_phy_mode = WLAN_PHYMODE_AUTO;
+		break;
+	case eCSR_DOT11_MODE_11a:
+		con_phy_mode = WLAN_PHYMODE_11A;
+		break;
+	case eCSR_DOT11_MODE_11b:
+		con_phy_mode = WLAN_PHYMODE_11B;
+		break;
+	case eCSR_DOT11_MODE_11g:
+		con_phy_mode = WLAN_PHYMODE_11G;
+		break;
+	case eCSR_DOT11_MODE_11n:
+		con_phy_mode = WLAN_PHYMODE_11NA_HT20;
+		break;
+	case eCSR_DOT11_MODE_11g_ONLY:
+		con_phy_mode = WLAN_PHYMODE_11G;
+		break;
+	case eCSR_DOT11_MODE_11n_ONLY:
+		con_phy_mode = WLAN_PHYMODE_11NA_HT20;
+		break;
+	case eCSR_DOT11_MODE_11b_ONLY:
+		con_phy_mode = WLAN_PHYMODE_11B;
+		break;
+	case eCSR_DOT11_MODE_11ac:
+		con_phy_mode = WLAN_PHYMODE_11AC_VHT160;
+		break;
+	case eCSR_DOT11_MODE_11ac_ONLY:
+		con_phy_mode = WLAN_PHYMODE_11AC_VHT160;
+		break;
+	case eCSR_DOT11_MODE_AUTO:
+		con_phy_mode = WLAN_PHYMODE_AUTO;
+		break;
+	case eCSR_DOT11_MODE_11ax:
+		con_phy_mode = WLAN_PHYMODE_11AXA_HE160;
+		break;
+	case eCSR_DOT11_MODE_11ax_ONLY:
+		con_phy_mode = WLAN_PHYMODE_11AXA_HE160;
+		break;
+	default:
+		con_phy_mode = WLAN_PHYMODE_AUTO;
+		break;
+	}
+
+	return con_phy_mode;
+}
+
+#ifdef WLAN_FEATURE_11W
+
+/**
+ * csr_update_pmf_cap_from_profile: Updates PMF cap
+ * @profile: Source profile
+ * @filter: scan filter
+ *
+ * Return: None
+ */
+static void csr_update_pmf_cap_from_profile(struct csr_roam_profile *profile,
+					    struct scan_filter *filter)
+{
+	if (profile->MFPCapable || profile->MFPEnabled)
+		filter->pmf_cap = WLAN_PMF_CAPABLE;
+	if (profile->MFPRequired)
+		filter->pmf_cap = WLAN_PMF_REQUIRED;
+}
+#else
+static inline
+void csr_update_pmf_cap_from_profile(struct csr_roam_profile *profile,
+				     struct scan_filter *filter)
+{}
+#endif
+
 QDF_STATUS
-csr_roam_prepare_filter_from_profile(struct mac_context *mac_ctx,
-				     struct csr_roam_profile *profile,
-				     tCsrScanResultFilter *scan_fltr)
+csr_roam_get_scan_filter_from_profile(struct mac_context *mac_ctx,
+				      struct csr_roam_profile *profile,
+				      struct scan_filter *filter,
+				      bool is_roam)
 {
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	uint32_t size = 0;
-	uint8_t idx = 0;
-	tCsrChannelInfo *fltr_ch_info = &scan_fltr->ChannelInfo;
-	tCsrChannelInfo *profile_ch_info = &profile->ChannelInfo;
+	tCsrChannelInfo *ch_info;
 	struct roam_ext_params *roam_params;
 	uint8_t i;
-	uint32_t *flt_freq_lst, *prof_freq_lst;
-	uint32_t num_ch;
+	uint32_t phy_mode;
 
+	if (!filter || !profile) {
+		sme_err("filter or profile is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
 	roam_params = &mac_ctx->roam.configParam.roam_params;
 
+	qdf_mem_zero(filter, sizeof(*filter));
 	if (profile->BSSIDs.numOfBSSIDs) {
-		size = sizeof(struct qdf_mac_addr) * profile->BSSIDs.
-							numOfBSSIDs;
-		scan_fltr->BSSIDs.bssid = qdf_mem_malloc(size);
-		if (!scan_fltr->BSSIDs.bssid) {
-			status = QDF_STATUS_E_NOMEM;
-			goto free_filter;
-		}
-		scan_fltr->BSSIDs.numOfBSSIDs = profile->BSSIDs.numOfBSSIDs;
-		qdf_mem_copy(scan_fltr->BSSIDs.bssid,
-			     profile->BSSIDs.bssid, size);
+		filter->num_of_bssid = profile->BSSIDs.numOfBSSIDs;
+		if (filter->num_of_bssid > WLAN_SCAN_FILTER_NUM_BSSID)
+			filter->num_of_bssid = WLAN_SCAN_FILTER_NUM_BSSID;
+		for (i = 0; i < filter->num_of_bssid; i++)
+			qdf_mem_copy(filter->bssid_list[i].bytes,
+				     profile->BSSIDs.bssid[i].bytes,
+				     QDF_MAC_ADDR_SIZE);
 	}
 
 	if (profile->SSIDs.numOfSSIDs) {
-		scan_fltr->SSIDs.numOfSSIDs = profile->SSIDs.numOfSSIDs;
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-			("No of Allowed List:%d"),
-			roam_params->num_ssid_allowed_list);
-		if (scan_fltr->scan_filter_for_roam
-			&& roam_params->num_ssid_allowed_list) {
-			scan_fltr->SSIDs.numOfSSIDs =
-				roam_params->num_ssid_allowed_list;
-			size = sizeof(tCsrSSIDInfo) *
-				scan_fltr->SSIDs.numOfSSIDs;
-			scan_fltr->SSIDs.SSIDList = qdf_mem_malloc(size);
-			if (!scan_fltr->SSIDs.SSIDList)
-				status = QDF_STATUS_E_FAILURE;
-			else
-				status = QDF_STATUS_SUCCESS;
-			if (!QDF_IS_STATUS_SUCCESS(status))
-				goto free_filter;
-			for  (i = 0;
-				i < roam_params->num_ssid_allowed_list;
-				i++) {
-				qdf_mem_copy((void *)
-				    scan_fltr->SSIDs.SSIDList[i].SSID.ssId,
-				    roam_params->ssid_allowed_list[i].ssId,
-				    roam_params->ssid_allowed_list[i].length);
-				scan_fltr->SSIDs.SSIDList[i].SSID.length =
-				    roam_params->ssid_allowed_list[i].length;
-				scan_fltr->SSIDs.SSIDList[i].handoffPermitted =
-					1;
-				scan_fltr->SSIDs.SSIDList[i].ssidHidden = 0;
-			}
-		} else {
-			size = sizeof(tCsrSSIDInfo) *
-				profile->SSIDs.numOfSSIDs;
-			scan_fltr->SSIDs.SSIDList = qdf_mem_malloc(size);
-			if (!scan_fltr->SSIDs.SSIDList) {
-				status = QDF_STATUS_E_NOMEM;
-				goto free_filter;
-			}
-			qdf_mem_copy(scan_fltr->SSIDs.SSIDList,
-					profile->SSIDs.SSIDList, size);
-		}
+		if (is_roam && roam_params->num_ssid_allowed_list)
+			csr_copy_ssids_from_roam_params(roam_params, filter);
+		else
+			csr_copy_ssids_from_profile(&profile->SSIDs, filter);
 	}
 
-	if (!profile_ch_info->freq_list ||
-	    profile_ch_info->freq_list[0] == 0) {
-		fltr_ch_info->numOfChannels = 0;
-		fltr_ch_info->freq_list = NULL;
-	} else if (profile_ch_info->numOfChannels) {
-		fltr_ch_info->numOfChannels = 0;
-		fltr_ch_info->freq_list =
-			qdf_mem_malloc(sizeof(*fltr_ch_info->freq_list) *
-				       profile_ch_info->numOfChannels);
-		if (!fltr_ch_info->freq_list) {
-			status = QDF_STATUS_E_NOMEM;
-			goto free_filter;
-		}
-
-		flt_freq_lst = fltr_ch_info->freq_list;
-		prof_freq_lst = profile_ch_info->freq_list;
-		num_ch = 0;
-
-		for (idx = 0; idx < profile_ch_info->numOfChannels; idx++) {
+	ch_info = &profile->ChannelInfo;
+	if (ch_info->numOfChannels && ch_info->freq_list &&
+	    ch_info->freq_list[0]) {
+		filter->num_of_channels = 0;
+		for (i = 0; i < ch_info->numOfChannels; i++) {
+			if (filter->num_of_channels >= QDF_MAX_NUM_CHAN) {
+				sme_err("max allowed channel(%d) reached",
+					filter->num_of_channels);
+				break;
+			}
 			if (csr_roam_is_chan_freq_valid(mac_ctx,
-							prof_freq_lst[idx])) {
-				flt_freq_lst[num_ch] = prof_freq_lst[idx];
-				num_ch++;
+						ch_info->freq_list[i])) {
+				filter->channel_list[filter->num_of_channels] =
+				  (uint8_t)wlan_reg_freq_to_chan(mac_ctx->pdev,
+							ch_info->freq_list[i]);
+				filter->num_of_channels++;
 			} else {
-				sme_debug(
-					"Channel freq (%d) is invalid",
-					profile_ch_info->freq_list[idx]);
+				sme_debug("freq (%d) is invalid",
+					  ch_info->freq_list[i]);
 			}
 		}
+	}
 
-		fltr_ch_info->numOfChannels = num_ch;
+	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 {
-		sme_err("Channel list empty");
-		status = QDF_STATUS_E_FAILURE;
-		goto free_filter;
-	}
-	scan_fltr->uapsd_mask = profile->uapsd_mask;
-	scan_fltr->authType = profile->AuthType;
-	scan_fltr->EncryptionType = profile->EncryptionType;
-	scan_fltr->mcEncryptionType = profile->mcEncryptionType;
-	scan_fltr->BSSType = profile->BSSType;
-	scan_fltr->phyMode = profile->phyMode;
-#ifdef FEATURE_WLAN_WAPI
-	/*
-	 * check if user asked for WAPI with 11n or auto mode, in that
-	 * case modify the phymode to 11g
-	 */
-	if (csr_is_profile_wapi(profile)) {
-		if (scan_fltr->phyMode & eCSR_DOT11_MODE_11n)
-			scan_fltr->phyMode &= ~eCSR_DOT11_MODE_11n;
-		if (scan_fltr->phyMode & eCSR_DOT11_MODE_AUTO)
-			scan_fltr->phyMode &= ~eCSR_DOT11_MODE_AUTO;
-		if (!scan_fltr->phyMode)
-			scan_fltr->phyMode = eCSR_DOT11_MODE_11g;
-	}
-#endif /* FEATURE_WLAN_WAPI */
-	/*Save the WPS info */
-	scan_fltr->bWPSAssociation = profile->bWPSAssociation;
-	scan_fltr->bOSENAssociation = profile->bOSENAssociation;
-	if (profile->countryCode[0]) {
+		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]);
+	}
+
+	if (profile->BSSType == eCSR_BSS_TYPE_INFRASTRUCTURE)
+		filter->bss_type = WLAN_TYPE_BSS;
+	else if (profile->BSSType == eCSR_BSS_TYPE_IBSS ||
+		 profile->BSSType == eCSR_BSS_TYPE_START_IBSS)
+		filter->bss_type = WLAN_TYPE_IBSS;
+	else
+		filter->bss_type = WLAN_TYPE_ANY;
+
+	phy_mode = profile->phyMode;
+	csr_update_phy_mode(profile, &phy_mode);
+
+	filter->dot11_mode = csr_convert_dotllmod_phymode(phy_mode);
+	if (profile->bWPSAssociation || profile->bOSENAssociation)
+		filter->ignore_auth_enc_type = true;
+	if (profile->countryCode[0])
 		/*
 		 * This causes the matching function to use countryCode as one
 		 * of the criteria.
 		 */
-		qdf_mem_copy(scan_fltr->countryCode, profile->countryCode,
+		qdf_mem_copy(filter->country, profile->countryCode,
 			     CFG_COUNTRY_CODE_LEN);
-	}
-	scan_fltr->mdid = profile->mdid;
-	qdf_mem_copy(scan_fltr->bssid_hint.bytes,
-		profile->bssid_hint.bytes, QDF_MAC_ADDR_SIZE);
 
-#ifdef WLAN_FEATURE_11W
-	/* Management Frame Protection */
-	scan_fltr->MFPEnabled = profile->MFPEnabled;
-	scan_fltr->MFPRequired = profile->MFPRequired;
-	scan_fltr->MFPCapable = profile->MFPCapable;
-#endif
-	scan_fltr->csrPersona = profile->csrPersona;
-	csr_update_fils_scan_filter(scan_fltr, profile);
-	scan_fltr->force_rsne_override = profile->force_rsne_override;
+	filter->mobility_domain = profile->mdid.mobility_domain;
+	qdf_mem_copy(filter->bssid_hint.bytes, profile->bssid_hint.bytes,
+		     QDF_MAC_ADDR_SIZE);
 
-free_filter:
-	if (!QDF_IS_STATUS_SUCCESS(status))
-		csr_free_scan_filter(mac_ctx, scan_fltr);
+	csr_update_pmf_cap_from_profile(profile, filter);
 
-	return status;
+	csr_update_fils_scan_filter(filter, profile);
+
+	csr_update_connect_n_roam_cmn_filter(mac_ctx, filter,
+					     profile->csrPersona);
+
+	return QDF_STATUS_SUCCESS;
 }
 
 static
@@ -13862,24 +13986,14 @@ bool csr_is_same_profile(struct mac_context *mac,
 {
 	uint32_t i;
 	bool fCheck = false;
-	tCsrScanResultFilter *pScanFilter = NULL;
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (!(pProfile1 && pProfile2))
 		return fCheck;
-	pScanFilter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
-	if (!pScanFilter)
-		return fCheck;
-
-	status = csr_roam_prepare_filter_from_profile(mac, pProfile2,
-						      pScanFilter);
-	if (!(QDF_IS_STATUS_SUCCESS(status)))
-		goto free_scan_filter;
 
-	for (i = 0; i < pScanFilter->SSIDs.numOfSSIDs; i++) {
+	for (i = 0; i < pProfile2->SSIDs.numOfSSIDs; i++) {
 		fCheck = csr_is_ssid_match(mac,
-				pScanFilter->SSIDs.SSIDList[i].SSID.ssId,
-				pScanFilter->SSIDs.SSIDList[i].SSID.length,
+				pProfile2->SSIDs.SSIDList[i].SSID.ssId,
+				pProfile2->SSIDs.SSIDList[i].SSID.length,
 				pProfile1->SSID.ssId,
 				pProfile1->SSID.length,
 				false);
@@ -13887,7 +14001,7 @@ bool csr_is_same_profile(struct mac_context *mac,
 			break;
 	}
 	if (!fCheck)
-		goto free_scan_filter;
+		goto exit;
 
 	if (!csr_is_auth_in_list(mac, &pProfile2->AuthType,
 				 pProfile1->AuthType)
@@ -13895,20 +14009,18 @@ bool csr_is_same_profile(struct mac_context *mac,
 	    || !csr_is_encryption_in_list(mac, &pProfile2->EncryptionType,
 					  pProfile1->EncryptionType)) {
 		fCheck = false;
-		goto free_scan_filter;
+		goto exit;
 	}
 	if (pProfile1->mdid.mdie_present || pProfile2->mdid.mdie_present) {
 		if (pProfile1->mdid.mobility_domain !=
 		    pProfile2->mdid.mobility_domain) {
 			fCheck = false;
-			goto free_scan_filter;
+			goto exit;
 		}
 	}
 	/* Match found */
 	fCheck = true;
-free_scan_filter:
-	csr_free_scan_filter(mac, pScanFilter);
-	qdf_mem_free(pScanFilter);
+exit:
 	return fCheck;
 }
 

core/sme/src/csr/csr_api_scan.c

@@ -50,6 +50,8 @@
 #include "wlan_reg_services_api.h"
 #include "sch_api.h"
 #include "wlan_blm_api.h"
+#include "qdf_crypto.h"
+#include <wlan_crypto_global_api.h>
 
 static void csr_set_cfg_valid_channel_list(struct mac_context *mac,
 					   uint32_t *pchan_freq_list,
@@ -118,7 +120,7 @@ QDF_STATUS csr_scan_handle_search_for_ssid(struct mac_context *mac_ctx,
 {
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	tScanResultHandle hBSSList = CSR_INVALID_SCANRESULT_HANDLE;
-	tCsrScanResultFilter *pScanFilter = NULL;
+	struct scan_filter *filter;
 	struct csr_roam_profile *profile;
 	struct csr_roam_session *session;
 
@@ -152,16 +154,19 @@ QDF_STATUS csr_scan_handle_search_for_ssid(struct mac_context *mac_ctx,
 		}
 		if (!profile)
 			break;
-		pScanFilter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
-		if (!pScanFilter) {
+		filter = qdf_mem_malloc(sizeof(*filter));
+		if (!filter) {
 			status = QDF_STATUS_E_NOMEM;
 			break;
 		}
-		status = csr_roam_prepare_filter_from_profile(mac_ctx, profile,
-							      pScanFilter);
-		if (!QDF_IS_STATUS_SUCCESS(status))
+		status = csr_roam_get_scan_filter_from_profile(mac_ctx, profile,
+							       filter, false);
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
+			qdf_mem_free(filter);
 			break;
-		status = csr_scan_get_result(mac_ctx, pScanFilter, &hBSSList);
+		}
+		status = csr_scan_get_result(mac_ctx, filter, &hBSSList);
+		qdf_mem_free(filter);
 		if (!QDF_IS_STATUS_SUCCESS(status))
 			break;
 		if (mac_ctx->roam.roamSession[session_id].connectState ==
@@ -187,10 +192,7 @@ QDF_STATUS csr_scan_handle_search_for_ssid(struct mac_context *mac_ctx,
 				       eCSR_ROAM_ASSOCIATION_FAILURE,
 				       eCSR_ROAM_RESULT_SCAN_FOR_SSID_FAILURE);
 	}
-	if (pScanFilter) {
-		csr_free_scan_filter(mac_ctx, pScanFilter);
-		qdf_mem_free(pScanFilter);
-	}
+
 	return status;
 }
 
@@ -2053,7 +2055,7 @@ csr_scan_get_channel_for_hw_mode_change(struct mac_context *mac_ctx,
 	return candidate_chan;
 }
 
-static enum wlan_auth_type csr_covert_auth_type_new(enum csr_akm_type auth)
+enum wlan_auth_type csr_covert_auth_type_new(enum csr_akm_type auth)
 {
 	switch (auth) {
 	case eCSR_AUTH_TYPE_NONE:
@@ -2184,7 +2186,7 @@ static enum csr_akm_type csr_covert_auth_type_old(enum wlan_auth_type auth)
 	}
 }
 
-static enum wlan_enc_type csr_covert_enc_type_new(eCsrEncryptionType enc)
+enum wlan_enc_type csr_covert_enc_type_new(eCsrEncryptionType enc)
 {
 	switch (enc) {
 	case eCSR_ENCRYPT_TYPE_NONE:
@@ -2254,241 +2256,6 @@ static eCsrEncryptionType csr_covert_enc_type_old(enum wlan_enc_type enc)
 	}
 }
 
-#ifdef WLAN_FEATURE_11W
-/**
- * csr_update_pmf_cap: Updates PMF cap
- * @src_filter: Source filter
- * @dst_filter: Destination filter
- *
- * Return: None
- */
-static void csr_update_pmf_cap(tCsrScanResultFilter *src_filter,
-			       struct scan_filter *dst_filter) {
-
-	if (src_filter->MFPCapable || src_filter->MFPEnabled)
-		dst_filter->pmf_cap = WLAN_PMF_CAPABLE;
-	if (src_filter->MFPRequired)
-		dst_filter->pmf_cap = WLAN_PMF_REQUIRED;
-}
-#else
-static inline void csr_update_pmf_cap(tCsrScanResultFilter *src_filter,
-				      struct scan_filter *dst_filter)
-{}
-#endif
-
-/**
- * csr_convert_dotllmod_phymode: Convert eCsrPhyMode to wlan_phymode
- * @dotllmode: phy mode
- *
- * Return: returns enum wlan_phymode
- */
-static enum wlan_phymode csr_convert_dotllmod_phymode(eCsrPhyMode dotllmode)
-{
-
-	enum wlan_phymode con_phy_mode;
-
-	switch (dotllmode) {
-	case eCSR_DOT11_MODE_abg:
-		con_phy_mode = WLAN_PHYMODE_AUTO;
-		break;
-	case eCSR_DOT11_MODE_11a:
-		con_phy_mode = WLAN_PHYMODE_11A;
-		break;
-	case eCSR_DOT11_MODE_11b:
-		con_phy_mode = WLAN_PHYMODE_11B;
-		break;
-	case eCSR_DOT11_MODE_11g:
-		con_phy_mode = WLAN_PHYMODE_11G;
-		break;
-	case eCSR_DOT11_MODE_11n:
-		con_phy_mode = WLAN_PHYMODE_11NA_HT20;
-		break;
-	case eCSR_DOT11_MODE_11g_ONLY:
-		con_phy_mode = WLAN_PHYMODE_11G;
-		break;
-	case eCSR_DOT11_MODE_11n_ONLY:
-		con_phy_mode = WLAN_PHYMODE_11NA_HT20;
-		break;
-	case eCSR_DOT11_MODE_11b_ONLY:
-		con_phy_mode = WLAN_PHYMODE_11B;
-		break;
-	case eCSR_DOT11_MODE_11ac:
-		con_phy_mode = WLAN_PHYMODE_11AC_VHT160;
-		break;
-	case eCSR_DOT11_MODE_11ac_ONLY:
-		con_phy_mode = WLAN_PHYMODE_11AC_VHT160;
-		break;
-	case eCSR_DOT11_MODE_AUTO:
-		con_phy_mode = WLAN_PHYMODE_AUTO;
-		break;
-	case eCSR_DOT11_MODE_11ax:
-		con_phy_mode = WLAN_PHYMODE_11AXA_HE160;
-		break;
-	case eCSR_DOT11_MODE_11ax_ONLY:
-		con_phy_mode = WLAN_PHYMODE_11AXA_HE160;
-		break;
-	default:
-		con_phy_mode = WLAN_PHYMODE_AUTO;
-		break;
-	}
-
-	return con_phy_mode;
-}
-
-#ifdef WLAN_ADAPTIVE_11R
-/**
- * csr_update_adaptive_11r_scan_filter - Copy adaptive 11r ini to scan
- * module
- * @mac_ctx: Pointer to mac_context
- * @scan_filter: Scan filter to be sent to scan module
- *
- * Return: None
- */
-static void
-csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
-				    struct scan_filter *filter)
-{
-	filter->enable_adaptive_11r =
-		   mac_ctx->mlme_cfg->lfr.enable_adaptive_11r;
-}
-#else
-static inline void
-csr_update_adaptive_11r_scan_filter(struct mac_context *mac_ctx,
-				    struct scan_filter *filter)
-{
-	filter->enable_adaptive_11r = false;
-}
-#endif
-
-static QDF_STATUS csr_prepare_scan_filter(struct mac_context *mac_ctx,
-					  tCsrScanResultFilter *pFilter,
-					  struct scan_filter *filter)
-{
-	int i;
-	uint32_t len = 0;
-	QDF_STATUS status;
-	enum policy_mgr_con_mode new_mode;
-
-	filter->num_of_bssid = pFilter->BSSIDs.numOfBSSIDs;
-	if (filter->num_of_bssid > WLAN_SCAN_FILTER_NUM_BSSID)
-		filter->num_of_bssid = WLAN_SCAN_FILTER_NUM_BSSID;
-	for (i = 0; i < filter->num_of_bssid; i++)
-		qdf_mem_copy(filter->bssid_list[i].bytes,
-			pFilter->BSSIDs.bssid[i].bytes,
-			QDF_MAC_ADDR_SIZE);
-
-	filter->age_threshold = pFilter->age_threshold;
-
-	filter->num_of_ssid = pFilter->SSIDs.numOfSSIDs;
-	if (filter->num_of_ssid > WLAN_SCAN_FILTER_NUM_SSID)
-		filter->num_of_ssid = WLAN_SCAN_FILTER_NUM_SSID;
-	for (i = 0; i < filter->num_of_ssid; i++) {
-		filter->ssid_list[i].length =
-			pFilter->SSIDs.SSIDList[i].SSID.length;
-		qdf_mem_copy(filter->ssid_list[i].ssid,
-			pFilter->SSIDs.SSIDList[i].SSID.ssId,
-			filter->ssid_list[i].length);
-	}
-
-	filter->num_of_channels =
-		pFilter->ChannelInfo.numOfChannels;
-	if (filter->num_of_channels > QDF_MAX_NUM_CHAN)
-		filter->num_of_channels = QDF_MAX_NUM_CHAN;
-	sme_freq_to_chan_list(mac_ctx->pdev, filter->channel_list,
-			      pFilter->ChannelInfo.freq_list,
-			      filter->num_of_channels);
-	if (pFilter->realm_check) {
-		filter->fils_scan_filter.realm_check = true;
-		qdf_mem_copy(filter->fils_scan_filter.fils_realm,
-			pFilter->fils_realm, REAM_HASH_LEN);
-	}
-
-	if (pFilter->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 =
-			pFilter->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(
-			  pFilter->authType.authType[i]);
-		filter->num_of_enc_type =
-			pFilter->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(
-			  pFilter->EncryptionType.encryptionType[i]);
-		filter->num_of_mc_enc_type =
-				pFilter->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(
-			  pFilter->mcEncryptionType.encryptionType[i]);
-	}
-	qdf_mem_copy(filter->country, pFilter->countryCode,
-		     CFG_COUNTRY_CODE_LEN);
-
-	if (pFilter->bWPSAssociation || pFilter->bOSENAssociation)
-		filter->ignore_auth_enc_type = true;
-
-	filter->rrm_measurement_filter = pFilter->fMeasurement;
-
-	filter->mobility_domain = pFilter->mdid.mobility_domain;
-
-	filter->p2p_results = pFilter->p2pResult;
-
-	csr_update_pmf_cap(pFilter, filter);
-
-	if (pFilter->BSSType == eCSR_BSS_TYPE_INFRASTRUCTURE)
-		filter->bss_type = WLAN_TYPE_BSS;
-	else if (pFilter->BSSType == eCSR_BSS_TYPE_IBSS ||
-		pFilter->BSSType == eCSR_BSS_TYPE_START_IBSS)
-		filter->bss_type = WLAN_TYPE_IBSS;
-	else
-		filter->bss_type = WLAN_TYPE_ANY;
-
-	filter->dot11_mode = csr_convert_dotllmod_phymode(pFilter->phyMode);
-
-	// enable bss scoring for only STA mode
-	if (pFilter->csrPersona == QDF_STA_MODE)
-		filter->bss_scoring_required = true;
-	else
-		filter->bss_scoring_required = false;
-
-	csr_update_adaptive_11r_scan_filter(mac_ctx, filter);
-
-	if (!pFilter->BSSIDs.numOfBSSIDs) {
-		if (policy_mgr_map_concurrency_mode(
-		   &pFilter->csrPersona, &new_mode)) {
-			status = policy_mgr_get_pcl(mac_ctx->psoc, new_mode,
-				filter->pcl_channel_list, &len,
-				filter->pcl_weight_list, QDF_MAX_NUM_CHAN);
-			filter->num_of_pcl_channels = (uint8_t)len;
-		}
-	}
-	qdf_mem_copy(filter->bssid_hint.bytes,
-			pFilter->bssid_hint.bytes,
-			QDF_MAC_ADDR_SIZE);
-
-	return QDF_STATUS_SUCCESS;
-}
-
 #ifdef WLAN_FEATURE_FILS_SK
 /**
  * csr_update_bss_with_fils_data: Fill FILS params in bss desc from scan entry
@@ -2769,13 +2536,12 @@ static void csr_remove_ap_with_assoc_disallowed(struct mac_context *mac_ctx,
 }
 
 QDF_STATUS csr_scan_get_result(struct mac_context *mac_ctx,
-			       tCsrScanResultFilter *pFilter,
+			       struct scan_filter *filter,
 			       tScanResultHandle *results)
 {
 	QDF_STATUS status;
 	struct scan_result_list *ret_list = NULL;
 	qdf_list_t *list = NULL;
-	struct scan_filter *filter = NULL;
 	struct wlan_objmgr_pdev *pdev = NULL;
 	uint32_t num_bss = 0;
 
@@ -2789,28 +2555,14 @@ QDF_STATUS csr_scan_get_result(struct mac_context *mac_ctx,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	if (pFilter) {
-		filter = qdf_mem_malloc(sizeof(*filter));
-		if (!filter) {
-			status = QDF_STATUS_E_NOMEM;
-			goto error;
-		}
-
-		status = csr_prepare_scan_filter(mac_ctx, pFilter, filter);
-		if (QDF_IS_STATUS_ERROR(status)) {
-			sme_err("Prepare filter failed");
-			goto error;
-		}
-	}
-
-	list = ucfg_scan_get_result(pdev,
-		    pFilter ? filter : NULL);
+	list = ucfg_scan_get_result(pdev, filter);
 	if (list) {
 		num_bss = qdf_list_size(list);
 		sme_debug("num_entries %d", num_bss);
 	}
+
 	/* Filter the scan list with the blacklist, rssi reject, avoided APs */
-	if (pFilter && pFilter->csrPersona == QDF_STA_MODE)
+	if (filter && filter->bss_scoring_required)
 		wlan_blm_filter_bssid(pdev, list);
 
 	if (!list || (list && !qdf_list_size(list))) {
@@ -2835,7 +2587,7 @@ QDF_STATUS csr_scan_get_result(struct mac_context *mac_ctx,
 		/* Fail or No one wants the result. */
 		csr_scan_result_purge(mac_ctx, (tScanResultHandle) ret_list);
 	else {
-		if (pFilter && pFilter->csrPersona == QDF_STA_MODE)
+		if (filter && filter->bss_scoring_required)
 			csr_remove_ap_with_assoc_disallowed(mac_ctx, ret_list);
 
 		if (!csr_ll_count(&ret_list->List)) {
@@ -2857,8 +2609,6 @@ QDF_STATUS csr_scan_get_result(struct mac_context *mac_ctx,
 	}
 
 error:
-	if (filter)
-		qdf_mem_free(filter);
 	if (list)
 		ucfg_scan_purge_results(list);
 	if (pdev)
@@ -2872,7 +2622,7 @@ QDF_STATUS csr_scan_get_result_for_bssid(struct mac_context *mac_ctx,
 					 tCsrScanResultInfo *res)
 {
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
-	tCsrScanResultFilter *scan_filter = NULL;
+	struct scan_filter *scan_filter;
 	tScanResultHandle filtered_scan_result = NULL;
 	tCsrScanResultInfo *scan_result;
 
@@ -2882,18 +2632,13 @@ QDF_STATUS csr_scan_get_result_for_bssid(struct mac_context *mac_ctx,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	scan_filter = qdf_mem_malloc(sizeof(tCsrScanResultFilter));
+	scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
 	if (!scan_filter)
 		return QDF_STATUS_E_NOMEM;
 
-	scan_filter->BSSIDs.bssid = qdf_mem_malloc(sizeof(*bssid));
-	if (!scan_filter->BSSIDs.bssid) {
-		status = QDF_STATUS_E_FAILURE;
-		goto free_filter;
-	}
-
-	scan_filter->BSSIDs.numOfBSSIDs = 1;
-	qdf_mem_copy(scan_filter->BSSIDs.bssid, bssid, sizeof(*bssid));
+	scan_filter->num_of_bssid = 1;
+	qdf_mem_copy(scan_filter->bssid_list[0].bytes, bssid->bytes,
+		     QDF_MAC_ADDR_SIZE);
 
 	status = csr_scan_get_result(mac_ctx, scan_filter,
 				&filtered_scan_result);
@@ -2921,7 +2666,6 @@ QDF_STATUS csr_scan_get_result_for_bssid(struct mac_context *mac_ctx,
 	csr_scan_result_purge(mac_ctx, filtered_scan_result);
 
 free_filter:
-	csr_free_scan_filter(mac_ctx, scan_filter);
 	if (scan_filter)
 		qdf_mem_free(scan_filter);
 

core/sme/src/csr/csr_host_scan_roam.c

@@ -358,30 +358,33 @@ QDF_STATUS csr_neighbor_roam_process_scan_complete(struct mac_context *mac,
 {
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 		&mac->roam.neighborRoamInfo[sessionId];
-	tCsrScanResultFilter scanFilter;
+	struct scan_filter *filter;
 	tScanResultHandle scanResult;
 	uint32_t tempVal = 0;
 	QDF_STATUS hstatus;
 
-	hstatus = csr_neighbor_roam_prepare_scan_profile_filter(mac,
-								&scanFilter,
-								sessionId);
+	filter = qdf_mem_malloc(sizeof(*filter));
+	if (!filter)
+		return QDF_STATUS_E_NOMEM;
+
+	hstatus = csr_neighbor_roam_get_scan_filter_from_profile(mac,
+								 filter,
+								 sessionId);
 	sme_debug("Prepare scan to find neighbor AP filter status: %d",
 		hstatus);
 	if (QDF_STATUS_SUCCESS != hstatus) {
 		sme_err("Scan Filter prep fail for Assoc %d Bail out",
 			tempVal);
+		qdf_mem_free(filter);
 		return QDF_STATUS_E_FAILURE;
 	}
-	hstatus = csr_scan_get_result(mac, &scanFilter, &scanResult);
+	hstatus = csr_scan_get_result(mac, filter, &scanResult);
+	qdf_mem_free(filter);
 	if (hstatus != QDF_STATUS_SUCCESS)
 		sme_err("Get Scan Result status code %d", hstatus);
 	/* Process the scan results and update roamable AP list */
 	csr_neighbor_roam_process_scan_results(mac, sessionId, &scanResult);
 
-	/* Free the scan filter */
-	csr_free_scan_filter(mac, &scanFilter);
-
 	tempVal = csr_ll_count(&pNeighborRoamInfo->roamableAPList);
 
 	if (tempVal) {

core/sme/src/csr/csr_inside_api.h

@@ -157,16 +157,6 @@ QDF_STATUS csr_roam_save_connected_bss_desc(struct mac_context *mac,
 					    uint32_t sessionId,
 					    struct bss_description *bss_desc);
 
-/*
- * Prepare a filter base on a profile for parsing the scan results.
- * Upon successful return, caller MUST call csr_free_scan_filter on
- * pScanFilter when it is done with the filter.
- */
-QDF_STATUS
-csr_roam_prepare_filter_from_profile(struct mac_context *mac,
-				     struct csr_roam_profile *pProfile,
-				     tCsrScanResultFilter *pScanFilter);
-
 QDF_STATUS csr_roam_copy_profile(struct mac_context *mac,
 				 struct csr_roam_profile *pDstProfile,
 				 struct csr_roam_profile *pSrcProfile);
@@ -360,10 +350,6 @@ void csr_free_connect_bss_desc(struct mac_context *mac, uint32_t sessionId);
 void csr_release_profile(struct mac_context *mac,
 			 struct csr_roam_profile *pProfile);
 
-/* To free memory allocated inside scanFilter */
-void csr_free_scan_filter(struct mac_context *mac, tCsrScanResultFilter
-			*pScanFilter);
-
 enum csr_cfgdot11mode
 csr_get_cfg_dot11_mode_from_csr_phy_mode(struct csr_roam_profile *pProfile,
 					 eCsrPhyMode phyMode,
@@ -424,15 +410,89 @@ enum csr_cfgdot11mode csr_find_best_phy_mode(struct mac_context *mac,
 							uint32_t phyMode);
 
 /*
- * csr_scan_get_result() -
- * Return scan results.
+ * csr_copy_ssids_from_roam_params() - copy SSID from roam_params to scan filter
+ * @roam_params: roam params
+ * @filter: scan filter
+ *
+ * Return void
+ */
+void csr_copy_ssids_from_roam_params(struct roam_ext_params *roam_params,
+				     struct scan_filter *filter);
+
+/*
+ * csr_update_connect_n_roam_cmn_filter() - update common scan filter
+ * @mac_ctx: pointer to mac context
+ * @filter: scan filter
+ * @opmode: opmode
+ *
+ * Return void
+ */
+void csr_update_connect_n_roam_cmn_filter(struct mac_context *mac_ctx,
+					  struct scan_filter *filter,
+					  enum QDF_OPMODE opmode);
+
+/*
+ * 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);
+
+/**
+ * csr_roam_get_scan_filter_from_profile() - prepare scan filter from
+ * given roam profile
+ * @mac: Pointer to Global MAC structure
+ * @profile: roam profile
+ * @filter: Populated scan filter based on the connected profile
+ * @is_roam: if filter is for roam
+ *
+ * This function creates a scan filter based on the roam profile. Based on this
+ * filter, scan results are obtained.
+ *
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE otherwise
+ */
+QDF_STATUS
+csr_roam_get_scan_filter_from_profile(struct mac_context *mac_ctx,
+				      struct csr_roam_profile *profile,
+				      struct scan_filter *filter,
+				      bool is_roam);
+
+/**
+ * csr_neighbor_roam_get_scan_filter_from_profile() - prepare scan filter from
+ * connected profile
+ * @mac: Pointer to Global MAC structure
+ * @filter: Populated scan filter based on the connected profile
+ * @vdev_id: Session ID
+ *
+ * This function creates a scan filter based on the currently
+ * connected profile. Based on this filter, scan results are obtained
+ *
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE otherwise
+ */
+QDF_STATUS
+csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
+					       struct scan_filter *filter,
+					       uint8_t vdev_id);
+/*
+ * csr_scan_get_result() - Return scan results based on filter
+ * @mac: Pointer to Global MAC structure
+ * @filter: If pFilter is NULL, all cached results are returned
+ * @phResult: an object for the result.
  *
- * pFilter - If pFilter is NULL, all cached results are returned
- * phResult - an object for the result.
  * Return QDF_STATUS
  */
-QDF_STATUS csr_scan_get_result(struct mac_context *mac, tCsrScanResultFilter
-				*pFilter, tScanResultHandle *phResult);
+QDF_STATUS csr_scan_get_result(struct mac_context *mac,
+			       struct scan_filter *filter,
+			       tScanResultHandle *phResult);
 
 /**
  * csr_scan_get_result_for_bssid - gets the scan result from scan cache for the

core/sme/src/csr/csr_neighbor_roam.c

@@ -323,145 +323,100 @@ static void csr_neighbor_roam_reset_init_state_control_info(struct mac_context *
 	csr_neighbor_roam_reset_report_scan_state_control_info(mac, sessionId);
 }
 
-/**
- * csr_neighbor_roam_prepare_scan_profile_filter()
- *
- * @mac_ctx: Pointer to Global MAC structure
- * @session_id: Session ID
- * @scan_filter: Populated scan filter based on the connected profile
- *
- * This function creates a scan filter based on the currently
- * connected profile. Based on this filter, scan results are obtained
- *
- * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE otherwise
- */
+#ifdef WLAN_FEATURE_11W
+static void
+csr_update_pmf_cap_from_connected_profile(tCsrRoamConnectedProfile *profile,
+					  struct scan_filter *filter)
+{
+	if (profile->MFPCapable || profile->MFPEnabled)
+		filter->pmf_cap = WLAN_PMF_CAPABLE;
+	if (profile->MFPRequired)
+		filter->pmf_cap = WLAN_PMF_REQUIRED;
+}
+#else
+static inline void
+csr_update_pmf_cap_from_connected_profile(tCsrRoamConnectedProfile *profile,
+					  struct scan_filter *filter)
+{}
+#endif
+
 QDF_STATUS
-csr_neighbor_roam_prepare_scan_profile_filter(struct mac_context *mac,
-					      tCsrScanResultFilter *pScanFilter,
-					      uint8_t sessionId)
+csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
+					       struct scan_filter *filter,
+					       uint8_t vdev_id)
 {
-	tpCsrNeighborRoamControlInfo nbr_roam_info =
-		&mac->roam.neighborRoamInfo[sessionId];
-	tCsrRoamConnectedProfile *pCurProfile =
-		&mac->roam.roamSession[sessionId].connectedProfile;
-	uint8_t i = 0;
+	tpCsrNeighborRoamControlInfo nbr_roam_info;
+	tCsrRoamConnectedProfile *profile;
 	struct roam_ext_params *roam_params;
+	tCsrChannelInfo *chan_info;
 	uint8_t num_ch = 0;
+	enum QDF_OPMODE opmode = QDF_STA_MODE;
 
-	QDF_ASSERT(pScanFilter);
-	if (!pScanFilter)
+	if (!filter)
+		return QDF_STATUS_E_FAILURE;
+	if (!CSR_IS_SESSION_VALID(mac, vdev_id))
 		return QDF_STATUS_E_FAILURE;
 
-	qdf_mem_zero(pScanFilter, sizeof(tCsrScanResultFilter));
+	qdf_mem_zero(filter, sizeof(*filter));
+	nbr_roam_info = &mac->roam.neighborRoamInfo[vdev_id];
+	profile = &mac->roam.roamSession[vdev_id].connectedProfile;
 	roam_params = &mac->roam.configParam.roam_params;
-	/* We dont want to set BSSID based Filter */
-	pScanFilter->BSSIDs.numOfBSSIDs = 0;
-	pScanFilter->scan_filter_for_roam = 1;
+
 	/* only for HDD requested handoff fill in the BSSID in the filter */
 	if (nbr_roam_info->uOsRequestedHandoff) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-			FL("OS Requested Handoff"));
-		pScanFilter->BSSIDs.numOfBSSIDs = 1;
-		pScanFilter->BSSIDs.bssid =
-			qdf_mem_malloc(sizeof(tSirMacAddr) *
-				       pScanFilter->BSSIDs.numOfBSSIDs);
-		if (!pScanFilter->BSSIDs.bssid)
-			return QDF_STATUS_E_NOMEM;
-
-		/* Populate the BSSID from handoff info received from HDD */
-		for (i = 0; i < pScanFilter->BSSIDs.numOfBSSIDs; i++) {
-			qdf_copy_macaddr(&pScanFilter->BSSIDs.bssid[i],
-				 &nbr_roam_info->handoffReqInfo.bssid);
-		}
+		sme_debug("OS Requested Handoff");
+		filter->num_of_bssid = 1;
+		qdf_mem_copy(filter->bssid_list[0].bytes,
+			     &nbr_roam_info->handoffReqInfo.bssid.bytes,
+			     QDF_MAC_ADDR_SIZE);
 	}
-	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-		FL("No of Allowed SSID List:%d"),
-		roam_params->num_ssid_allowed_list);
-	if (roam_params->num_ssid_allowed_list) {
-		pScanFilter->SSIDs.numOfSSIDs =
-			roam_params->num_ssid_allowed_list;
-		pScanFilter->SSIDs.SSIDList =
-			qdf_mem_malloc(sizeof(tCsrSSIDInfo) *
-				pScanFilter->SSIDs.numOfSSIDs);
-		if (!pScanFilter->SSIDs.SSIDList) {
-			qdf_mem_free(pScanFilter->BSSIDs.bssid);
-			pScanFilter->BSSIDs.bssid = NULL;
-			return QDF_STATUS_E_NOMEM;
-		}
+	sme_debug("No of Allowed SSID List:%d",
+		  roam_params->num_ssid_allowed_list);
 
-		for (i = 0; i < roam_params->num_ssid_allowed_list; i++) {
-			pScanFilter->SSIDs.SSIDList[i].handoffPermitted = 1;
-			pScanFilter->SSIDs.SSIDList[i].ssidHidden = 0;
-			qdf_mem_copy((void *)
-				pScanFilter->SSIDs.SSIDList[i].SSID.ssId,
-				roam_params->ssid_allowed_list[i].ssId,
-				roam_params->ssid_allowed_list[i].length);
-			pScanFilter->SSIDs.SSIDList[i].SSID.length =
-				roam_params->ssid_allowed_list[i].length;
-		}
+	if (roam_params->num_ssid_allowed_list) {
+		csr_copy_ssids_from_roam_params(roam_params, filter);
 	} else {
-		/* Populate all the information from the connected profile */
-		pScanFilter->SSIDs.numOfSSIDs = 1;
-		pScanFilter->SSIDs.SSIDList =
-			qdf_mem_malloc(sizeof(tCsrSSIDInfo));
-		if (!pScanFilter->SSIDs.SSIDList) {
-			qdf_mem_free(pScanFilter->BSSIDs.bssid);
-			pScanFilter->BSSIDs.bssid = NULL;
-			return QDF_STATUS_E_NOMEM;
-		}
+		filter->num_of_ssid = 1;
 
-		pScanFilter->SSIDs.SSIDList->handoffPermitted = 1;
-		pScanFilter->SSIDs.SSIDList->ssidHidden = 0;
-		pScanFilter->SSIDs.SSIDList->SSID.length =
-			pCurProfile->SSID.length;
-		qdf_mem_copy((void *)pScanFilter->SSIDs.SSIDList->SSID.ssId,
-			(void *)pCurProfile->SSID.ssId,
-			pCurProfile->SSID.length);
+		filter->ssid_list[0].length = profile->SSID.length;
+		if (filter->ssid_list[0].length > WLAN_SSID_MAX_LEN)
+			filter->ssid_list[0].length = WLAN_SSID_MAX_LEN;
+		qdf_mem_copy(filter->ssid_list[0].ssid,
+			     profile->SSID.ssId,
+			     filter->ssid_list[0].length);
 
 		sme_debug("Filtering for SSID %.*s,length of SSID = %u",
-			pScanFilter->SSIDs.SSIDList->SSID.length,
-			pScanFilter->SSIDs.SSIDList->SSID.ssId,
-			pScanFilter->SSIDs.SSIDList->SSID.length);
+			  filter->ssid_list[0].length,
+			  filter->ssid_list[0].ssid,
+			  filter->ssid_list[0].length);
 	}
-	pScanFilter->authType.numEntries = 1;
-	pScanFilter->authType.authType[0] = pCurProfile->AuthType;
-
-	pScanFilter->EncryptionType.numEntries = 1;     /* This must be 1 */
-	pScanFilter->EncryptionType.encryptionType[0] =
-		pCurProfile->EncryptionType;
-
-	pScanFilter->mcEncryptionType.numEntries = 1;
-	pScanFilter->mcEncryptionType.encryptionType[0] =
-		pCurProfile->mcEncryptionType;
 
-	pScanFilter->BSSType = pCurProfile->BSSType;
-
-	num_ch =
-	    nbr_roam_info->roamChannelInfo.currentChannelListInfo.numOfChannels;
+	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);
+
+	if (profile->BSSType == eCSR_BSS_TYPE_INFRASTRUCTURE)
+		filter->bss_type = WLAN_TYPE_BSS;
+	else if (profile->BSSType == eCSR_BSS_TYPE_IBSS ||
+		 profile->BSSType == eCSR_BSS_TYPE_START_IBSS)
+		filter->bss_type = WLAN_TYPE_IBSS;
+	else
+		filter->bss_type = WLAN_TYPE_ANY;
+
+	chan_info = &nbr_roam_info->roamChannelInfo.currentChannelListInfo;
+	num_ch = chan_info->numOfChannels;
 	if (num_ch) {
-		/*
-		 * We are intrested only in the scan results on channels we
-		 * scanned
-		 */
-		pScanFilter->ChannelInfo.numOfChannels = num_ch;
-		pScanFilter->ChannelInfo.freq_list =
-			qdf_mem_malloc(num_ch * sizeof(uint32_t));
-		if (!pScanFilter->ChannelInfo.freq_list) {
-			pScanFilter->ChannelInfo.numOfChannels = 0;
-			qdf_mem_free(pScanFilter->BSSIDs.bssid);
-			pScanFilter->BSSIDs.bssid = NULL;
-			qdf_mem_free(pScanFilter->SSIDs.SSIDList);
-			pScanFilter->SSIDs.SSIDList = NULL;
-			return QDF_STATUS_E_NOMEM;
-		}
-		for (i = 0; i < pScanFilter->ChannelInfo.numOfChannels; i++) {
-			pScanFilter->ChannelInfo.freq_list[i] =
-				nbr_roam_info->roamChannelInfo.
-				currentChannelListInfo.freq_list[i];
-		}
-	} else {
-		pScanFilter->ChannelInfo.numOfChannels = 0;
-		pScanFilter->ChannelInfo.freq_list = NULL;
+		filter->num_of_channels = num_ch;
+		if (filter->num_of_channels > QDF_MAX_NUM_CHAN)
+			filter->num_of_channels = QDF_MAX_NUM_CHAN;
+		sme_freq_to_chan_list(mac->pdev, filter->channel_list,
+				      chan_info->freq_list,
+				      filter->num_of_channels);
 	}
 
 	if (nbr_roam_info->is11rAssoc)
@@ -469,13 +424,12 @@ csr_neighbor_roam_prepare_scan_profile_filter(struct mac_context *mac,
 		 * MDIE should be added as a part of profile. This should be
 		 * added as a part of filter as well
 		 */
-		pScanFilter->mdid = pCurProfile->mdid;
+		filter->mobility_domain = profile->mdid.mobility_domain;
+
+	csr_update_pmf_cap_from_connected_profile(profile, filter);
+
+	csr_update_connect_n_roam_cmn_filter(mac, filter, opmode);
 
-#ifdef WLAN_FEATURE_11W
-	pScanFilter->MFPEnabled = pCurProfile->MFPEnabled;
-	pScanFilter->MFPRequired = pCurProfile->MFPRequired;
-	pScanFilter->MFPCapable = pCurProfile->MFPCapable;
-#endif
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -1466,7 +1420,7 @@ static QDF_STATUS csr_neighbor_roam_process_handoff_req(
 	uint8_t i = 0;
 	uint8_t roam_now = 0;
 	uint8_t roamable_ap_count = 0;
-	tCsrScanResultFilter    scan_filter;
+	struct scan_filter *scan_filter;
 	tScanResultHandle       scan_result;
 
 	if (!session) {
@@ -1526,17 +1480,22 @@ static QDF_STATUS csr_neighbor_roam_process_handoff_req(
 	 */
 	if (roam_ctrl_info->handoffReqInfo.src == CONNECT_CMD_USERSPACE) {
 		sme_debug("Connect cmd with bssid within same ESS");
-		status = csr_neighbor_roam_prepare_scan_profile_filter(mac_ctx,
-								&scan_filter,
+		scan_filter = qdf_mem_malloc(sizeof(*scan_filter));
+		if (!scan_filter) {
+			status = QDF_STATUS_E_NOMEM;
+			goto end;
+		}
+		status = csr_neighbor_roam_get_scan_filter_from_profile(mac_ctx,
+								scan_filter,
 								session_id);
 		sme_debug("Filter creation status: %d", status);
-		status = csr_scan_get_result(mac_ctx, &scan_filter,
+		status = csr_scan_get_result(mac_ctx, scan_filter,
 					     &scan_result);
+		qdf_mem_free(scan_filter);
 		csr_neighbor_roam_process_scan_results(mac_ctx, session_id,
 							&scan_result);
 		roamable_ap_count = csr_ll_count(
 					&roam_ctrl_info->roamableAPList);
-		csr_free_scan_filter(mac_ctx, &scan_filter);
 		sme_debug("roam_now=%d, roamable_ap_count=%d",
 			roam_now, roamable_ap_count);
 	}

core/sme/src/csr/csr_util.c

@@ -5954,23 +5954,6 @@ void csr_release_profile(struct mac_context *mac, struct csr_roam_profile *pProf
 	}
 }
 
-void csr_free_scan_filter(struct mac_context *mac, tCsrScanResultFilter
-						*pScanFilter)
-{
-	if (pScanFilter->BSSIDs.bssid) {
-		qdf_mem_free(pScanFilter->BSSIDs.bssid);
-		pScanFilter->BSSIDs.bssid = NULL;
-	}
-	if (pScanFilter->ChannelInfo.freq_list) {
-		qdf_mem_free(pScanFilter->ChannelInfo.freq_list);
-		pScanFilter->ChannelInfo.freq_list = NULL;
-	}
-	if (pScanFilter->SSIDs.SSIDList) {
-		qdf_mem_free(pScanFilter->SSIDs.SSIDList);
-		pScanFilter->SSIDs.SSIDList = NULL;
-	}
-}
-
 void csr_free_roam_profile(struct mac_context *mac, uint32_t sessionId)
 {
 	struct csr_roam_session *pSession = &mac->roam.roamSession[sessionId];

core/sme/src/rrm/sme_rrm.c

@@ -433,7 +433,7 @@ static QDF_STATUS sme_rrm_send_scan_result(struct mac_context *mac_ctx,
 					   uint8_t measurementdone)
 {
 	mac_handle_t mac_handle = MAC_HANDLE(mac_ctx);
-	tCsrScanResultFilter filter;
+	struct scan_filter *filter;
 	tScanResultHandle result_handle;
 	tCsrScanResultInfo *scan_results, *next_result;
 	tCsrScanResultInfo **scanresults_arr = NULL;
@@ -446,28 +446,30 @@ static QDF_STATUS sme_rrm_send_scan_result(struct mac_context *mac_ctx,
 	tSirScanType scan_type;
 	struct csr_roam_session *session;
 
-	qdf_mem_zero(&filter, sizeof(filter));
-	filter.BSSIDs.numOfBSSIDs = 1;
-	filter.BSSIDs.bssid = (struct qdf_mac_addr *)&rrm_ctx->bssId;
+	filter = qdf_mem_malloc(sizeof(*filter));
+	if (!filter)
+		return QDF_STATUS_E_NOMEM;
 
-	if (rrm_ctx->ssId.length) {
-		filter.SSIDs.SSIDList = qdf_mem_malloc(sizeof(tCsrSSIDInfo));
-		if (!filter.SSIDs.SSIDList)
-			return QDF_STATUS_E_NOMEM;
+	/* update filter to get scan result with just target BSSID */
+	filter->num_of_bssid = 1;
+	qdf_mem_copy(filter->bssid_list[0].bytes,
+		     rrm_ctx->bssId, sizeof(struct qdf_mac_addr));
 
-		filter.SSIDs.SSIDList->SSID.length =
-			rrm_ctx->ssId.length;
-		qdf_mem_copy(filter.SSIDs.SSIDList->SSID.ssId,
-				rrm_ctx->ssId.ssId, rrm_ctx->ssId.length);
-		filter.SSIDs.numOfSSIDs = 1;
-	} else {
-		filter.SSIDs.numOfSSIDs = 0;
+	if (rrm_ctx->ssId.length) {
+		filter->num_of_ssid = 1;
+		filter->ssid_list[0].length = rrm_ctx->ssId.length;
+		if (filter->ssid_list[0].length > WLAN_SSID_MAX_LEN)
+			filter->ssid_list[0].length = WLAN_SSID_MAX_LEN;
+		qdf_mem_copy(filter->ssid_list[0].ssid,
+			     rrm_ctx->ssId.ssId, filter->ssid_list[0].length);
 	}
 
-	filter.ChannelInfo.numOfChannels = num_chan;
-	filter.ChannelInfo.freq_list = freq_list;
-	filter.fMeasurement = true;
-
+	filter->num_of_channels = num_chan;
+	if (filter->num_of_channels > QDF_MAX_NUM_CHAN)
+		filter->num_of_channels = QDF_MAX_NUM_CHAN;
+	sme_freq_to_chan_list(mac_ctx->pdev, filter->channel_list,
+			      freq_list, filter->num_of_channels);
+	filter->rrm_measurement_filter = true;
 	/*
 	 * In case this is beacon report request from last AP (before roaming)
 	 * following call to csr_roam_get_session_id_from_bssid will fail,
@@ -479,10 +481,8 @@ static QDF_STATUS sme_rrm_send_scan_result(struct mac_context *mac_ctx,
 		session_id = mac_ctx->roam.roamSession->sessionId;
 	}
 	status = sme_scan_get_result(mac_handle, (uint8_t)session_id,
-				     &filter, &result_handle);
-
-	if (filter.SSIDs.SSIDList)
-		qdf_mem_free(filter.SSIDs.SSIDList);
+				     filter, &result_handle);
+	qdf_mem_free(filter);
 
 	sme_debug("RRM Measurement Done %d", measurementdone);
 	if (!result_handle) {