qcacld-3.0: Move code from CSR to roam scan offload to new structs

Move code from CSR to roam scan offload to use new converged
structures.

Change-Id: Ie69a88f419d38ec611b4dc18ed15d7eb1f53e1ae
CRs-Fixed: 2853488

components/mlme/core/inc/wlan_mlme_main.h

@@ -652,6 +652,7 @@ QDF_STATUS wlan_mlme_get_bssid_vdev_id(struct wlan_objmgr_pdev *pdev,
  * Return: chan freq of given vdev id
  */
 qdf_freq_t wlan_get_operation_chan_freq(struct wlan_objmgr_vdev *vdev);
+
 /**
  * wlan_get_operation_chan_freq_vdev_id() - get operating chan freq of
  * given vdev id
@@ -689,6 +690,18 @@ QDF_STATUS wlan_strip_ie(uint8_t *addn_ie, uint16_t *addn_ielen,
 			 uint8_t *oui, uint8_t oui_length,
 			 uint8_t *extracted_ie, uint32_t eid_max_len);
 
+/**
+ * wlan_is_channel_present_in_list() - check if rfeq is present in the list
+ * given vdev id
+ * @freq_lst: given freq list
+ * @num_chan: num of chan freq
+ * @chan_freq: chan freq to check
+ *
+ * Return: chan freq of given vdev id
+ */
+bool wlan_is_channel_present_in_list(qdf_freq_t *freq_lst,
+				     uint32_t num_chan, qdf_freq_t chan_freq);
+
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
 /**
  * mlme_get_supplicant_disabled_roaming() - Get supplicant disabled roaming

components/mlme/core/src/wlan_mlme_main.c

@@ -2889,6 +2889,25 @@ QDF_STATUS wlan_strip_ie(uint8_t *addn_ie, uint16_t *addn_ielen,
 	return QDF_STATUS_SUCCESS;
 }
 
+bool wlan_is_channel_present_in_list(qdf_freq_t *freq_lst,
+				     uint32_t num_chan, qdf_freq_t chan_freq)
+{
+	int i = 0;
+
+	/* Check for NULL pointer */
+	if (!freq_lst || (num_chan == 0))
+		return false;
+
+	/* Look for the channel in the list */
+	for (i = 0; (i < num_chan) && (i < CFG_VALID_CHANNEL_LIST_LEN); i++) {
+		if (freq_lst[i] == chan_freq)
+			return true;
+	}
+
+	return false;
+}
+
+
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
 static
 const char *mlme_roam_state_to_string(enum roam_offload_state state)

components/mlme/dispatcher/inc/wlan_mlme_public_struct.h

@@ -33,8 +33,6 @@
 #define OWE_TRANSITION_OUI_TYPE "\x50\x6f\x9a\x1c"
 #define OWE_TRANSITION_OUI_SIZE 4
 
-#define CFG_VALID_CHANNEL_LIST_LEN              100
-
 #define CFG_PMKID_MODES_OKC                        (0x1)
 #define CFG_PMKID_MODES_PMKSA_CACHING              (0x2)
 

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

@@ -28,6 +28,8 @@
 #include "wlan_cm_roam_api.h"
 #include "wlan_mlme_vdev_mgr_interface.h"
 #include "wlan_crypto_global_api.h"
+#include "wlan_psoc_mlme_api.h"
+#include "pld_common.h"
 
 /**
  * cm_roam_scan_bmiss_cnt() - set roam beacon miss count
@@ -533,6 +535,733 @@ cm_roam_scan_offload_scan_period(uint8_t vdev_id,
 			cfg_params->full_roam_scan_period;
 }
 
+static void
+cm_roam_fill_11w_params(struct wlan_objmgr_vdev *vdev,
+			struct ap_profile_params *req)
+{
+	uint32_t group_mgmt_cipher;
+	bool peer_rmf_capable = false;
+	uint32_t keymgmt;
+	uint16_t rsn_caps;
+
+	/*
+	 * Get rsn cap of link, intersection of self cap and bss cap,
+	 * Only set PMF flags when both STA and current AP has MFP enabled
+	 */
+	rsn_caps = (uint16_t)wlan_crypto_get_param(vdev,
+						   WLAN_CRYPTO_PARAM_RSN_CAP);
+	if (wlan_crypto_vdev_has_mgmtcipher(vdev,
+					(1 << WLAN_CRYPTO_CIPHER_AES_GMAC) |
+					(1 << WLAN_CRYPTO_CIPHER_AES_GMAC_256) |
+					(1 << WLAN_CRYPTO_CIPHER_AES_CMAC)) &&
+					(rsn_caps &
+					 WLAN_CRYPTO_RSN_CAP_MFP_ENABLED))
+		peer_rmf_capable = true;
+
+	keymgmt = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_MGMT_CIPHER);
+
+	if (keymgmt & (1 << WLAN_CRYPTO_CIPHER_AES_CMAC))
+		group_mgmt_cipher = WMI_CIPHER_AES_CMAC;
+	else if (keymgmt & (1 << WLAN_CRYPTO_CIPHER_AES_GMAC))
+		group_mgmt_cipher = WMI_CIPHER_AES_GMAC;
+	else if (keymgmt & (1 << WLAN_CRYPTO_CIPHER_AES_GMAC_256))
+		group_mgmt_cipher = WMI_CIPHER_BIP_GMAC_256;
+	else
+		group_mgmt_cipher = WMI_CIPHER_NONE;
+
+	if (peer_rmf_capable) {
+		req->profile.rsn_mcastmgmtcipherset = group_mgmt_cipher;
+		req->profile.flags |= WMI_AP_PROFILE_FLAG_PMF;
+	} else {
+		req->profile.rsn_mcastmgmtcipherset = WMI_CIPHER_NONE;
+	}
+}
+
+static void cm_update_score_params(struct wlan_objmgr_psoc *psoc,
+				   struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				   struct scoring_param *req_score_params,
+				   struct rso_config *rso_cfg)
+{
+	struct wlan_mlme_roam_scoring_cfg *roam_score_params;
+	struct weight_cfg *weight_config;
+	struct psoc_mlme_obj *mlme_psoc_obj;
+	struct scoring_cfg *score_config;
+
+	mlme_psoc_obj = wlan_psoc_mlme_get_cmpt_obj(psoc);
+	if (!mlme_psoc_obj)
+		return;
+
+	score_config = &mlme_psoc_obj->psoc_cfg.score_config;
+	roam_score_params = &mlme_obj->cfg.roam_scoring;
+	weight_config = &score_config->weight_config;
+
+	if (!rso_cfg->cfg_param.enable_scoring_for_roam)
+		req_score_params->disable_bitmap =
+			WLAN_ROAM_SCORING_DISABLE_ALL;
+
+	req_score_params->rssi_weightage = weight_config->rssi_weightage;
+	req_score_params->ht_weightage = weight_config->ht_caps_weightage;
+	req_score_params->vht_weightage = weight_config->vht_caps_weightage;
+	req_score_params->he_weightage = weight_config->he_caps_weightage;
+	req_score_params->bw_weightage = weight_config->chan_width_weightage;
+	req_score_params->band_weightage = weight_config->chan_band_weightage;
+	req_score_params->nss_weightage = weight_config->nss_weightage;
+	req_score_params->esp_qbss_weightage =
+		weight_config->channel_congestion_weightage;
+	req_score_params->beamforming_weightage =
+		weight_config->beamforming_cap_weightage;
+	req_score_params->pcl_weightage =
+		weight_config->pcl_weightage;
+	req_score_params->oce_wan_weightage = weight_config->oce_wan_weightage;
+	req_score_params->oce_ap_tx_pwr_weightage =
+		weight_config->oce_ap_tx_pwr_weightage;
+	req_score_params->oce_subnet_id_weightage =
+		weight_config->oce_subnet_id_weightage;
+	req_score_params->sae_pk_ap_weightage =
+		weight_config->sae_pk_ap_weightage;
+
+	req_score_params->bw_index_score =
+		score_config->bandwidth_weight_per_index;
+	req_score_params->band_index_score =
+		score_config->band_weight_per_index;
+	req_score_params->nss_index_score =
+		score_config->nss_weight_per_index;
+
+	req_score_params->vendor_roam_score_algorithm =
+			score_config->vendor_roam_score_algorithm;
+
+
+	req_score_params->roam_score_delta =
+				roam_score_params->roam_score_delta;
+	req_score_params->roam_trigger_bitmap =
+				roam_score_params->roam_trigger_bitmap;
+
+	qdf_mem_copy(&req_score_params->rssi_scoring, &score_config->rssi_score,
+		     sizeof(struct rssi_config_score));
+	qdf_mem_copy(&req_score_params->esp_qbss_scoring,
+		     &score_config->esp_qbss_scoring,
+		     sizeof(struct per_slot_score));
+	qdf_mem_copy(&req_score_params->oce_wan_scoring,
+		     &score_config->oce_wan_scoring,
+		     sizeof(struct per_slot_score));
+	req_score_params->cand_min_roam_score_delta =
+					roam_score_params->min_roam_score_delta;
+}
+
+static uint32_t cm_crpto_cipher_wmi_cipher(int32_t cipherset)
+{
+
+	if (!cipherset || cipherset < 0)
+		return WMI_CIPHER_NONE;
+
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_GCM) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_GCM_256))
+		return WMI_CIPHER_AES_GCM;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_CCM) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_OCB) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_CCM_256))
+		return WMI_CIPHER_AES_CCM;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_TKIP))
+		return WMI_CIPHER_TKIP;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_CMAC) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_CMAC_256))
+		return WMI_CIPHER_AES_CMAC;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_WAPI_GCM4) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_WAPI_SMS4))
+		return WMI_CIPHER_WAPI;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_GMAC) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_AES_GMAC_256))
+		return WMI_CIPHER_AES_GMAC;
+	if (QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_WEP) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_WEP_40) ||
+	    QDF_HAS_PARAM(cipherset, WLAN_CRYPTO_CIPHER_WEP_104))
+		return WMI_CIPHER_WEP;
+
+	return WMI_CIPHER_NONE;
+}
+
+static uint32_t cm_get_rsn_wmi_auth_type(int32_t akm)
+{
+	/* Try the more preferred ones first. */
+	if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_FILS_SHA384))
+		return WMI_AUTH_FT_RSNA_FILS_SHA384;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_FILS_SHA256))
+		return WMI_AUTH_FT_RSNA_FILS_SHA256;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FILS_SHA384))
+		return WMI_AUTH_RSNA_FILS_SHA384;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FILS_SHA256))
+		return WMI_AUTH_RSNA_FILS_SHA256;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_SAE))
+		return WMI_AUTH_FT_RSNA_SAE;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_SAE))
+		return WMI_AUTH_WPA3_SAE;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_OWE))
+		return WMI_AUTH_WPA3_OWE;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_IEEE8021X))
+		return WMI_AUTH_FT_RSNA;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_PSK))
+		return WMI_AUTH_FT_RSNA_PSK;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_IEEE8021X))
+		return WMI_AUTH_RSNA;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_PSK))
+		return WMI_AUTH_RSNA_PSK;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_CCKM))
+		return WMI_AUTH_CCKM_RSNA;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_PSK_SHA256))
+		return WMI_AUTH_RSNA_PSK_SHA256;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_IEEE8021X_SHA256))
+		return WMI_AUTH_RSNA_8021X_SHA256;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_IEEE8021X_SUITE_B))
+		return WMI_AUTH_RSNA_SUITE_B_8021X_SHA256;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_IEEE8021X_SUITE_B_192))
+		return WMI_AUTH_RSNA_SUITE_B_8021X_SHA384;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_FT_IEEE8021X_SHA384))
+		return WMI_AUTH_FT_RSNA_SUITE_B_8021X_SHA384;
+	else
+		return WMI_AUTH_NONE;
+}
+
+static uint32_t cm_get_wpa_wmi_auth_type(int32_t akm)
+{
+	/* Try the more preferred ones first. */
+	if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_IEEE8021X))
+		return WMI_AUTH_WPA;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_PSK))
+		return WMI_AUTH_WPA_PSK;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_CCKM))
+		return WMI_AUTH_CCKM_WPA;
+	else
+		return WMI_AUTH_NONE;
+}
+
+static uint32_t cm_get_wapi_wmi_auth_type(int32_t akm)
+{
+	/* Try the more preferred ones first. */
+	if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_WAPI_CERT))
+		return WMI_AUTH_WAPI;
+	else if (QDF_HAS_PARAM(akm, WLAN_CRYPTO_KEY_MGMT_WAPI_PSK))
+		return WMI_AUTH_WAPI_PSK;
+	else
+		return WMI_AUTH_NONE;
+}
+
+static uint32_t cm_crpto_authmode_to_wmi_authmode(int32_t authmodeset,
+						  int32_t akm,
+						  int32_t ucastcipherset)
+{
+	if (!authmodeset || authmodeset < 0)
+		return WMI_AUTH_OPEN;
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_OPEN))
+		return WMI_AUTH_OPEN;
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_AUTO) ||
+	    QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_NONE)) {
+		if ((QDF_HAS_PARAM(ucastcipherset, WLAN_CRYPTO_CIPHER_WEP) ||
+		     QDF_HAS_PARAM(ucastcipherset, WLAN_CRYPTO_CIPHER_WEP_40) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_WEP_104) ||
+		     QDF_HAS_PARAM(ucastcipherset, WLAN_CRYPTO_CIPHER_TKIP) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_AES_GCM) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_AES_GCM_256) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_AES_CCM) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_AES_OCB) ||
+		     QDF_HAS_PARAM(ucastcipherset,
+				   WLAN_CRYPTO_CIPHER_AES_CCM_256)))
+			return WMI_AUTH_OPEN;
+		else
+			return WMI_AUTH_NONE;
+	}
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_SHARED))
+		return WMI_AUTH_SHARED;
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_8021X) ||
+	    QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_RSNA) ||
+	    QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_CCKM) ||
+	    QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_SAE) ||
+	    QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_FILS_SK))
+		return cm_get_rsn_wmi_auth_type(akm);
+
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_WPA))
+		return cm_get_wpa_wmi_auth_type(akm);
+
+	if (QDF_HAS_PARAM(authmodeset, WLAN_CRYPTO_AUTH_WAPI))
+		return cm_get_wapi_wmi_auth_type(akm);
+
+	return WMI_AUTH_OPEN;
+}
+
+/**
+ * cm_roam_scan_offload_ap_profile() - set roam ap profile parameters
+ * @psoc: psoc ctx
+ * @vdev: vdev id
+ * @rso_cfg: rso config
+ * @params:  roam ap profile related parameters
+ *
+ * This function is used to set roam ap profile related parameters
+ *
+ * Return: None
+ */
+static void
+cm_roam_scan_offload_ap_profile(struct wlan_objmgr_psoc *psoc,
+				struct wlan_objmgr_vdev *vdev,
+				struct rso_config *rso_cfg,
+				struct ap_profile_params *params)
+{
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+	int32_t uccipher, authmode, mccipher, akm;
+	struct ap_profile *profile = &params->profile;
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return;
+
+	params->vdev_id = vdev_id;
+	wlan_vdev_mlme_get_ssid(vdev, profile->ssid.ssid,
+				&profile->ssid.length);
+	/* Pairwise cipher suite */
+	uccipher = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_UCAST_CIPHER);
+	profile->rsn_ucastcipherset = cm_crpto_cipher_wmi_cipher(uccipher);
+	/* Group cipher suite */
+	mccipher = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_MCAST_CIPHER);
+	profile->rsn_mcastcipherset = cm_crpto_cipher_wmi_cipher(mccipher);
+	/* Group management cipher suite */
+	cm_roam_fill_11w_params(vdev, params);
+	authmode = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_AUTH_MODE);
+	akm = wlan_crypto_get_param(vdev, WLAN_CRYPTO_PARAM_KEY_MGMT);
+	profile->rsn_authmode =
+		cm_crpto_authmode_to_wmi_authmode(authmode, akm, uccipher);
+
+	profile->rssi_threshold = rso_cfg->cfg_param.roam_rssi_diff;
+	profile->bg_rssi_threshold = rso_cfg->cfg_param.bg_rssi_threshold;
+	/*
+	 * rssi_diff which is updated via framework is equivalent to the
+	 * INI RoamRssiDiff parameter and hence should be updated.
+	 */
+	if (mlme_obj->cfg.lfr.rso_user_config.rssi_diff)
+		profile->rssi_threshold =
+				mlme_obj->cfg.lfr.rso_user_config.rssi_diff;
+
+	profile->rssi_abs_thresh =
+			mlme_obj->cfg.lfr.roam_rssi_abs_threshold;
+
+	cm_update_score_params(psoc, mlme_obj, &params->param, rso_cfg);
+
+	params->min_rssi_params[DEAUTH_MIN_RSSI] =
+			mlme_obj->cfg.trig_min_rssi[DEAUTH_MIN_RSSI];
+	params->min_rssi_params[BMISS_MIN_RSSI] =
+			mlme_obj->cfg.trig_min_rssi[BMISS_MIN_RSSI];
+	params->min_rssi_params[MIN_RSSI_2G_TO_5G_ROAM] =
+			mlme_obj->cfg.trig_min_rssi[MIN_RSSI_2G_TO_5G_ROAM];
+
+	params->score_delta_param[IDLE_ROAM_TRIGGER] =
+			mlme_obj->cfg.trig_score_delta[IDLE_ROAM_TRIGGER];
+	params->score_delta_param[BTM_ROAM_TRIGGER] =
+			mlme_obj->cfg.trig_score_delta[BTM_ROAM_TRIGGER];
+}
+
+static bool
+cm_check_band_freq_match(enum band_info band, qdf_freq_t freq)
+{
+	if (band == BAND_ALL)
+		return true;
+
+	if (band == BAND_2G && WLAN_REG_IS_24GHZ_CH_FREQ(freq))
+		return true;
+
+	if (band == BAND_5G && WLAN_REG_IS_5GHZ_CH_FREQ(freq))
+		return true;
+
+	return false;
+}
+
+/**
+ * cm_is_dfs_unsafe_extra_band_chan() - check if dfs unsafe or extra band
+ * channel
+ * @vdev: vdev
+ * @mlme_obj: psoc mlme obj
+ * @freq: channel freq to check
+ * @band: band for intra band check
+.*.
+ * Return: bool if match else false
+ */
+static bool
+cm_is_dfs_unsafe_extra_band_chan(struct wlan_objmgr_vdev *vdev,
+				 struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				 qdf_freq_t freq,
+				 enum band_info band)
+{
+	uint16_t  unsafe_chan[NUM_CHANNELS];
+	uint16_t  unsafe_chan_cnt = 0;
+	uint16_t  cnt = 0;
+	bool is_unsafe_chan;
+	qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
+	struct rso_roam_policy_params *roam_policy;
+	struct wlan_objmgr_pdev *pdev;
+
+	if (!qdf_ctx)
+		return true;
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev)
+		return true;
+
+	roam_policy = &mlme_obj->cfg.lfr.rso_user_config.policy_params;
+	if ((mlme_obj->cfg.lfr.roaming_dfs_channel ==
+	     ROAMING_DFS_CHANNEL_DISABLED ||
+	     roam_policy->dfs_mode == CSR_STA_ROAM_POLICY_DFS_DISABLED) &&
+	    (wlan_reg_is_dfs_for_freq(pdev, freq)))
+		return true;
+
+	pld_get_wlan_unsafe_channel(qdf_ctx->dev, unsafe_chan,
+				    &unsafe_chan_cnt,
+				    sizeof(unsafe_chan));
+	if (roam_policy->skip_unsafe_channels && unsafe_chan_cnt) {
+		is_unsafe_chan = false;
+		for (cnt = 0; cnt < unsafe_chan_cnt; cnt++) {
+			if (unsafe_chan[cnt] == freq) {
+				is_unsafe_chan = true;
+				mlme_debug("ignoring unsafe channel freq %d",
+					   freq);
+				return true;
+			}
+		}
+	}
+	if (!cm_check_band_freq_match(band, freq)) {
+		mlme_debug("ignoring non-intra band freq %d", freq);
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * cm_populate_roam_chan_list() - Populate roam channel list
+ * parameters
+ * @vdev: vdev
+ * @mlme_obj:  mlme_obj
+ * @dst: Destination roam channel buf to populate the roam chan list
+ * @src: Source channel list
+ *
+ * Return: QDF_STATUS enumeration
+ */
+static QDF_STATUS
+cm_populate_roam_chan_list(struct wlan_objmgr_vdev *vdev,
+			   struct wlan_mlme_psoc_ext_obj *mlme_obj,
+			   struct wlan_roam_scan_channel_list *dst,
+			   struct rso_chan_info *src)
+{
+	enum band_info band;
+	uint32_t band_cap;
+	uint8_t i = 0;
+	uint8_t num_channels = 0;
+	qdf_freq_t *freq_lst = src->freq_list;
+
+	/*
+	 * The INI channels need to be filtered with respect to the current band
+	 * that is supported.
+	 */
+	band_cap = mlme_obj->cfg.gen.band_capability;
+	if (!band_cap) {
+		mlme_err("Invalid band_cap(%d), roam scan offload req aborted",
+			 band_cap);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	band = wlan_reg_band_bitmap_to_band_info(band_cap);
+	num_channels = dst->chan_count;
+	for (i = 0; i < src->num_chan; i++) {
+		if (wlan_is_channel_present_in_list(dst->chan_freq_list,
+						    num_channels, *freq_lst)) {
+			freq_lst++;
+			continue;
+		}
+		if (cm_is_dfs_unsafe_extra_band_chan(vdev, mlme_obj,
+						     *freq_lst, band)) {
+			freq_lst++;
+			continue;
+		}
+		dst->chan_freq_list[num_channels++] = *freq_lst;
+		freq_lst++;
+	}
+	dst->chan_count = num_channels;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+cm_fetch_ch_lst_from_ini(struct wlan_objmgr_vdev *vdev,
+			 struct wlan_mlme_psoc_ext_obj *mlme_obj,
+			 struct wlan_roam_scan_channel_list *chan_info,
+			 struct rso_chan_info *specific_chan_info)
+{
+	QDF_STATUS status;
+
+	status = cm_populate_roam_chan_list(vdev, mlme_obj, chan_info,
+					    specific_chan_info);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Failed to copy channels to roam list");
+		return status;
+	}
+	chan_info->chan_cache_type = CHANNEL_LIST_STATIC;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static void
+cm_fetch_ch_lst_from_occupied_lst(struct wlan_objmgr_vdev *vdev,
+				  struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				  struct rso_config *rso_cfg,
+				  struct wlan_roam_scan_channel_list *chan_info,
+				  uint8_t reason)
+{
+	uint8_t i = 0;
+	uint8_t num_channels = 0;
+	qdf_freq_t op_freq;
+	enum band_info band = BAND_ALL;
+	struct wlan_chan_list *occupied_channels;
+
+	occupied_channels = &rso_cfg->occupied_chan_lst;
+	op_freq = wlan_get_operation_chan_freq(vdev);
+	if (mlme_obj->cfg.lfr.roam_intra_band) {
+		if (WLAN_REG_IS_5GHZ_CH_FREQ(op_freq))
+			band = BAND_5G;
+		else if (WLAN_REG_IS_24GHZ_CH_FREQ(op_freq))
+			band = BAND_2G;
+		else
+			band = BAND_UNKNOWN;
+	}
+
+	for (i = 0; i < occupied_channels->num_chan; i++) {
+		if (cm_is_dfs_unsafe_extra_band_chan(vdev, mlme_obj,
+				occupied_channels->freq_list[i], band))
+			continue;
+
+		chan_info->chan_freq_list[num_channels++] =
+					occupied_channels->freq_list[i];
+	}
+	chan_info->chan_count = num_channels;
+	chan_info->chan_cache_type = CHANNEL_LIST_DYNAMIC;
+}
+
+/**
+ * cm_add_ch_lst_from_roam_scan_list() - channel from roam scan chan list
+ * parameters
+ * @vdev: vdev
+ * @mlme_obj:  mlme_obj
+ * @chan_info: RSO channel info
+ * @rso_cfg: rso config
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+cm_add_ch_lst_from_roam_scan_list(struct wlan_objmgr_vdev *vdev,
+				  struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				  struct wlan_roam_scan_channel_list *chan_info,
+				  struct rso_config *rso_cfg)
+{
+	QDF_STATUS status;
+	struct rso_chan_info *pref_chan_info =
+			&rso_cfg->cfg_param.pref_chan_info;
+
+	if (!pref_chan_info->num_chan)
+		return QDF_STATUS_SUCCESS;
+
+	status = cm_populate_roam_chan_list(vdev, mlme_obj, chan_info,
+					    pref_chan_info);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Failed to copy channels to roam list");
+		return status;
+	}
+	cm_dump_freq_list(pref_chan_info);
+	chan_info->chan_cache_type = CHANNEL_LIST_DYNAMIC;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+#ifdef FEATURE_WLAN_ESE
+static void
+cm_fetch_ch_lst_from_received_list(struct wlan_objmgr_vdev *vdev,
+				  struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				  struct rso_config *rso_cfg,
+				  struct wlan_roam_scan_channel_list *chan_info)
+{
+	uint8_t i = 0;
+	uint8_t num_channels = 0;
+	qdf_freq_t *freq_lst = NULL;
+	enum band_info band = BAND_ALL;
+	struct rso_chan_info *curr_ch_lst_info = &rso_cfg->roam_scan_freq_lst;
+
+	if (curr_ch_lst_info->num_chan == 0)
+		return;
+
+	freq_lst = curr_ch_lst_info->freq_list;
+	for (i = 0; i < curr_ch_lst_info->num_chan; i++) {
+		if (cm_is_dfs_unsafe_extra_band_chan(vdev, mlme_obj,
+						     freq_lst[i], band))
+			continue;
+
+		chan_info->chan_freq_list[num_channels++] = freq_lst[i];
+	}
+	chan_info->chan_count = num_channels;
+	chan_info->chan_cache_type = CHANNEL_LIST_DYNAMIC;
+}
+
+static inline bool cm_is_ese_assoc(struct rso_config *rso_cfg)
+{
+	return rso_cfg->is_ese_assoc;
+}
+
+#else
+static inline void
+cm_fetch_ch_lst_from_received_list(struct wlan_objmgr_vdev *vdev,
+				  struct wlan_mlme_psoc_ext_obj *mlme_obj,
+				  struct rso_config *rso_cfg,
+				  struct wlan_roam_scan_channel_list *chan_info)
+{}
+static inline bool cm_is_ese_assoc(struct rso_config *rso_cfg)
+{
+	return false;
+}
+#endif
+
+/**
+ * cm_fetch_valid_ch_lst() - fetch channel list from valid channel list and
+ * update rso req msg parameters
+ * @vdev: vdev
+ * @mlme_obj:  mlme_obj
+ * @chan_info: channel info
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+cm_fetch_valid_ch_lst(struct wlan_objmgr_vdev *vdev,
+		      struct wlan_mlme_psoc_ext_obj *mlme_obj,
+		      struct wlan_roam_scan_channel_list *chan_info)
+{
+	qdf_freq_t *ch_freq_list = NULL;
+	uint8_t i = 0, num_channels = 0;
+	enum band_info band = BAND_ALL;
+	qdf_freq_t op_freq;
+
+	op_freq = wlan_get_operation_chan_freq(vdev);
+	if (mlme_obj->cfg.lfr.roam_intra_band) {
+		if (WLAN_REG_IS_5GHZ_CH_FREQ(op_freq))
+			band = BAND_5G;
+		else if (WLAN_REG_IS_24GHZ_CH_FREQ(op_freq))
+			band = BAND_2G;
+		else
+			band = BAND_UNKNOWN;
+	}
+
+	ch_freq_list = mlme_obj->cfg.reg.valid_channel_freq_list;
+	for (i = 0; i < mlme_obj->cfg.reg.valid_channel_list_num; i++) {
+		if (wlan_reg_is_dsrc_freq(ch_freq_list[i]))
+			continue;
+		if (cm_is_dfs_unsafe_extra_band_chan(vdev, mlme_obj,
+						     ch_freq_list[i],
+						     band))
+			continue;
+		chan_info->chan_freq_list[num_channels++] = ch_freq_list[i];
+	}
+	chan_info->chan_count = num_channels;
+	chan_info->chan_cache_type = CHANNEL_LIST_DYNAMIC;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static void
+cm_fill_rso_channel_list(struct wlan_objmgr_psoc *psoc,
+			 struct wlan_objmgr_vdev *vdev,
+			 struct rso_config *rso_cfg,
+			 struct wlan_roam_scan_channel_list *chan_info,
+			 uint8_t reason)
+{
+	QDF_STATUS status;
+	uint8_t ch_cache_str[128] = {0};
+	uint8_t i, j;
+	struct rso_chan_info *specific_chan_info;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return;
+
+	specific_chan_info = &rso_cfg->cfg_param.specific_chan_info;
+	chan_info->vdev_id = vdev_id;
+	if (cm_is_ese_assoc(rso_cfg) ||
+	    rso_cfg->roam_scan_freq_lst.num_chan == 0) {
+		/*
+		 * Retrieve the Channel Cache either from ini or from
+		 * the occupied channels list along with preferred
+		 * channel list configured by the client.
+		 * Give Preference to INI Channels
+		 */
+		if (specific_chan_info->num_chan) {
+			status = cm_fetch_ch_lst_from_ini(vdev, mlme_obj,
+							  chan_info,
+							  specific_chan_info);
+			if (QDF_IS_STATUS_ERROR(status)) {
+				mlme_err("Fetch channel list from ini failed");
+				return;
+			}
+		} else if (reason == REASON_FLUSH_CHANNEL_LIST) {
+			chan_info->chan_cache_type = CHANNEL_LIST_STATIC;
+			chan_info->chan_count = 0;
+		} else {
+			cm_fetch_ch_lst_from_occupied_lst(vdev, mlme_obj,
+							  rso_cfg,
+							  chan_info, reason);
+			/* Add the preferred channel list configured by
+			 * client to the roam channel list along with
+			 * occupied channel list.
+			 */
+			cm_add_ch_lst_from_roam_scan_list(vdev, mlme_obj,
+							  chan_info, rso_cfg);
+		}
+	} else {
+		/*
+		 * If ESE is enabled, and a neighbor Report is received,
+		 * then Ignore the INI Channels or the Occupied Channel
+		 * List. Consider the channels in the neighbor list sent
+		 * by the ESE AP
+		 */
+		cm_fetch_ch_lst_from_received_list(vdev, mlme_obj, rso_cfg,
+						   chan_info);
+	}
+
+	if (!chan_info->chan_count &&
+	    reason != REASON_FLUSH_CHANNEL_LIST) {
+		/* Maintain the Valid Channels List */
+		status = cm_fetch_valid_ch_lst(vdev, mlme_obj, chan_info);
+		if (QDF_IS_STATUS_ERROR(status)) {
+			mlme_err("Fetch channel list fail");
+			return;
+		}
+	}
+
+	for (i = 0, j = 0; i < chan_info->chan_count; i++) {
+		if (j < sizeof(ch_cache_str))
+			j += snprintf(ch_cache_str + j,
+				      sizeof(ch_cache_str) - j, " %d",
+				      chan_info->chan_freq_list[i]);
+		else
+			break;
+	}
+
+	mlme_debug("chan_cache_type:%d, No of chan:%d, chan: %s",
+		   chan_info->chan_cache_type,
+		   chan_info->chan_count, ch_cache_str);
+}
+
 /**
  * cm_roam_start_req() - roam start request handling
  * @psoc: psoc pointer
@@ -580,6 +1309,10 @@ cm_roam_start_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	cm_roam_scan_offload_scan_period(vdev_id,
 					 &start_req->scan_period_params,
 					 rso_cfg);
+	cm_roam_scan_offload_ap_profile(psoc, vdev, rso_cfg,
+					&start_req->profile_params);
+	cm_fill_rso_channel_list(psoc, vdev, rso_cfg, &start_req->rso_chan_info,
+				 reason);
 
 	/* fill from legacy through this API */
 	wlan_cm_roam_fill_start_req(psoc, vdev_id, start_req, reason);
@@ -646,6 +1379,10 @@ cm_roam_update_config_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	cm_roam_scan_offload_scan_period(vdev_id,
 					 &update_req->scan_period_params,
 					 rso_cfg);
+	cm_roam_scan_offload_ap_profile(psoc, vdev, rso_cfg,
+					&update_req->profile_params);
+	cm_fill_rso_channel_list(psoc, vdev, rso_cfg,
+				 &update_req->rso_chan_info, reason);
 
 	/* fill from legacy through this API */
 	wlan_cm_roam_fill_update_config_req(psoc, vdev_id, update_req, reason);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2021 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -100,6 +100,14 @@ cm_roam_stop_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 QDF_STATUS
 cm_roam_fill_rssi_change_params(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 				struct wlan_roam_rssi_change_params *params);
+
+/**
+ * cm_dump_freq_list() - dump chan list
+ * @chan_info: chan info to dump
+ *
+ * Return: void
+ */
+void cm_dump_freq_list(struct rso_chan_info *chan_info);
 #endif
 
 /**

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

@@ -68,6 +68,7 @@ cm_handle_disconnect_req(struct wlan_objmgr_vdev *vdev,
 	enum QDF_OPMODE opmode;
 	struct wlan_objmgr_pdev *pdev;
 	uint8_t vdev_id;
+	struct rso_config *rso_cfg;
 
 	if (!vdev || !req)
 		return QDF_STATUS_E_FAILURE;
@@ -77,12 +78,14 @@ cm_handle_disconnect_req(struct wlan_objmgr_vdev *vdev,
 		mlme_err("vdev_id: %d pdev not found", vdev_id);
 		return QDF_STATUS_E_INVAL;
 	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		return QDF_STATUS_E_INVAL;
 	vdev_id = wlan_vdev_get_id(vdev);
 
 	qdf_mem_zero(&msg, sizeof(msg));
 
 	discon_req = qdf_mem_malloc(sizeof(*discon_req));
-
 	if (!discon_req)
 		return QDF_STATUS_E_NOMEM;
 
@@ -93,6 +96,10 @@ cm_handle_disconnect_req(struct wlan_objmgr_vdev *vdev,
 					  REASON_DISCONNECTED);
 
 	cm_csr_handle_diconnect_req(vdev, req);
+	if (rso_cfg->roam_scan_freq_lst.freq_list)
+		qdf_mem_free(rso_cfg->roam_scan_freq_lst.freq_list);
+	rso_cfg->roam_scan_freq_lst.freq_list = NULL;
+	rso_cfg->roam_scan_freq_lst.num_chan = 0;
 
 	qdf_mem_copy(discon_req, req, sizeof(*req));
 	msg.bodyptr = discon_req;

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

@@ -351,6 +351,38 @@ struct rso_config *wlan_cm_get_rso_config_fl(struct wlan_objmgr_vdev *vdev,
 void wlan_cm_set_disable_hi_rssi(struct wlan_objmgr_pdev *pdev,
 				 uint8_t vdev_id, bool value);
 
+#ifdef FEATURE_WLAN_ESE
+/**
+ * wlan_cm_set_ese_assoc  - set ese assoc
+ * @pdev: pdev pointer
+ * @vdev_id: vdev
+ * @value: value to set
+ *
+ * Return: void
+ */
+void wlan_cm_set_ese_assoc(struct wlan_objmgr_pdev *pdev,
+			   uint8_t vdev_id, bool value);
+
+/**
+ * wlan_cm_get_ese_assoc  - get ese assoc
+ * @pdev: pdev pointer
+ * @vdev_id: vdev
+ *
+ * Return: value
+ */
+bool wlan_cm_get_ese_assoc(struct wlan_objmgr_pdev *pdev,
+			   uint8_t vdev_id);
+#else
+static inline void wlan_cm_set_ese_assoc(struct wlan_objmgr_pdev *pdev,
+					 uint8_t vdev_id, bool value) {}
+static inline
+bool wlan_cm_get_ese_assoc(struct wlan_objmgr_pdev *pdev,
+			   uint8_t vdev_id)
+{
+	return false;
+}
+#endif
+
 /**
  * wlan_cm_rso_config_init  - initialize RSO config
  * @vdev: vdev pointer

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

@@ -97,6 +97,8 @@
 #define DEFAULT_ROAM_SCAN_SCHEME_BITMAP 0
 #define ROAM_MAX_CFG_VALUE 0xffffffff
 
+#define CFG_VALID_CHANNEL_LIST_LEN 100
+
 /**
  * struct rso_chan_info - chan info
  * @num_chan: number of channels
@@ -140,12 +142,21 @@ struct rso_cfg_params {
 	uint32_t roam_scan_period_after_inactivity;
 };
 
+/**
+ * struct wlan_chan_list - channel list
+ * @num_chan: number of channels
+ * @freq_list: freq list
+ */
+struct wlan_chan_list {
+	uint8_t num_chan;
+	qdf_freq_t freq_list[CFG_VALID_CHANNEL_LIST_LEN];
+};
+
 /**
  * struct rso_config - connect config to be used to send info in
  * RSO. This is the info we dont have in VDEV or CM ctx
  * @rsn_cap: original rsn caps from the connect req from supplicant
  * @disable_hi_rssi: disable high rssi
- * @roam_candidate_count: roam candidate count
  * @roam_control_enable: Flag used to cache the status of roam control
  *			 configuration. This will be set only if the
  *			 corresponding vendor command data is configured to
@@ -165,11 +176,13 @@ struct rso_cfg_params {
  * ROAM_TRIGGER_REASON_PER, ROAM_TRIGGER_REASON_BMISS
  * @cfg_param: per vdev config params
  * @assoc_ie: assoc IE
+ * @occupied_chan_lst: occupied channel list
+ * @roam_candidate_count: candidate count
+ * @is_ese_assoc: is ese assoc
  */
 struct rso_config {
 	uint8_t rsn_cap;
 	bool disable_hi_rssi;
-	int8_t roam_candidate_count;
 	bool roam_control_enable;
 	uint8_t rescan_rssi_delta;
 	uint8_t beacon_rssi_weight;
@@ -177,16 +190,52 @@ struct rso_config {
 	uint32_t roam_scan_scheme_bitmap;
 	struct rso_cfg_params cfg_param;
 	struct element_info assoc_ie;
+	struct wlan_chan_list occupied_chan_lst;
+	int8_t roam_candidate_count;
+#ifdef FEATURE_WLAN_ESE
+	bool is_ese_assoc;
+#endif
+	struct rso_chan_info roam_scan_freq_lst;
+};
+
+/**
+ * enum sta_roam_policy_dfs_mode - state of DFS mode for STA ROME policy
+ * @CSR_STA_ROAM_POLICY_NONE: DFS mode attribute is not valid
+ * @CSR_STA_ROAM_POLICY_DFS_ENABLED:  DFS mode is enabled
+ * @CSR_STA_ROAM_POLICY_DFS_DISABLED: DFS mode is disabled
+ * @CSR_STA_ROAM_POLICY_DFS_DEPRIORITIZE: Deprioritize DFS channels in scanning
+ */
+enum sta_roam_policy_dfs_mode {
+	CSR_STA_ROAM_POLICY_NONE,
+	CSR_STA_ROAM_POLICY_DFS_ENABLED,
+	CSR_STA_ROAM_POLICY_DFS_DISABLED,
+	CSR_STA_ROAM_POLICY_DFS_DEPRIORITIZE
+};
+
+/**
+ * struct rso_roam_policy_params - sta roam policy params for station
+ * @dfs_mode: tell is DFS channels needs to be skipped while scanning
+ * @skip_unsafe_channels: tells if unsafe channels needs to be skip in scanning
+ * @sap_operating_band: Opearting band for SAP
+ */
+struct rso_roam_policy_params {
+	enum sta_roam_policy_dfs_mode dfs_mode;
+	bool skip_unsafe_channels;
+	uint8_t sap_operating_band;
 };
 
 /**
  * struct rso_params - global RSO params
  * @good_rssi_roam: Lazy Roam
  * @alert_rssi_threshold: Alert RSSI
+ * @rssi: rssi diff
+ * @policy_params: roam policy params
  */
 struct rso_config_params {
 	int good_rssi_roam;
 	int alert_rssi_threshold;
+	int rssi_diff;
+	struct rso_roam_policy_params policy_params;
 };
 
 /**

components/umac/mlme/connection_mgr/dispatcher/src/wlan_cm_roam_api.c

@@ -582,6 +582,55 @@ void wlan_cm_set_disable_hi_rssi(struct wlan_objmgr_pdev *pdev,
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
 }
 
+#ifdef FEATURE_WLAN_ESE
+void wlan_cm_set_ese_assoc(struct wlan_objmgr_pdev *pdev,
+			   uint8_t vdev_id, bool value)
+{
+	static struct rso_config *rso_cfg;
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id,
+						    WLAN_MLME_CM_ID);
+	if (!vdev) {
+		mlme_err("vdev object is NULL");
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+		return;
+	}
+
+	rso_cfg->is_ese_assoc = value;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+}
+
+bool wlan_cm_get_ese_assoc(struct wlan_objmgr_pdev *pdev,
+			   uint8_t vdev_id)
+{
+	static struct rso_config *rso_cfg;
+	struct wlan_objmgr_vdev *vdev;
+	bool ese_assoc;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id,
+						    WLAN_MLME_CM_ID);
+	if (!vdev) {
+		mlme_err("vdev object is NULL");
+		return false;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+		return false;
+	}
+
+	ese_assoc = rso_cfg->is_ese_assoc;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+
+	return ese_assoc;
+}
+#endif
+
 static QDF_STATUS
 cm_roam_update_cfg(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 		   uint8_t reason)
@@ -604,7 +653,7 @@ cm_roam_update_cfg(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	return status;
 }
 
-static void cm_dump_freq_list(struct rso_chan_info *chan_info)
+void cm_dump_freq_list(struct rso_chan_info *chan_info)
 {
 	uint8_t *channel_list;
 	uint8_t i = 0, j = 0;
@@ -983,6 +1032,10 @@ void wlan_cm_rso_config_deinit(struct wlan_objmgr_vdev *vdev,
 		rso_cfg->assoc_ie.ptr = NULL;
 		rso_cfg->assoc_ie.len = 0;
 	}
+	if (rso_cfg->roam_scan_freq_lst.freq_list)
+		qdf_mem_free(rso_cfg->roam_scan_freq_lst.freq_list);
+	rso_cfg->roam_scan_freq_lst.freq_list = NULL;
+	rso_cfg->roam_scan_freq_lst.num_chan = 0;
 
 	cm_flush_roam_channel_list(&cfg_params->specific_chan_info);
 	cm_flush_roam_channel_list(&cfg_params->pref_chan_info);

core/hdd/src/wlan_hdd_cfg.c

@@ -878,6 +878,11 @@ QDF_STATUS hdd_set_sme_config(struct hdd_context *hdd_ctx)
 	bool ese_enabled;
 #endif
 	struct hdd_config *config = hdd_ctx->config;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+
+	mlme_obj = mlme_get_psoc_ext_obj(hdd_ctx->psoc);
+	if (!mlme_obj)
+		return QDF_STATUS_E_INVAL;
 
 	sme_config = qdf_mem_malloc(sizeof(*sme_config));
 	if (!sme_config)
@@ -944,9 +949,9 @@ QDF_STATUS hdd_set_sme_config(struct hdd_context *hdd_ctx)
 
 	cds_set_multicast_logging(hdd_ctx->config->multicast_host_fw_msgs);
 
-	sme_config->csr_config.sta_roam_policy_params.dfs_mode =
+	mlme_obj->cfg.lfr.rso_user_config.policy_params.dfs_mode =
 		CSR_STA_ROAM_POLICY_DFS_ENABLED;
-	sme_config->csr_config.sta_roam_policy_params.skip_unsafe_channels = 0;
+	mlme_obj->cfg.lfr.rso_user_config.policy_params.skip_unsafe_channels = 0;
 
 	status = hdd_set_sme_cfgs_related_to_mlme(hdd_ctx, sme_config);
 	if (!QDF_IS_STATUS_SUCCESS(status))

core/mac/inc/sir_api.h

@@ -54,7 +54,6 @@ struct mac_context;
 
 /* / Max supported channel list */
 #define SIR_MAX_SUPPORTED_CHANNEL_LIST      96
-#define CFG_VALID_CHANNEL_LIST_LEN              100
 
 #define SIR_MDIE_SIZE               3   /* MD ID(2 bytes), Capability(1 byte) */
 

core/sme/inc/csr_api.h

@@ -747,41 +747,12 @@ typedef struct tagCsrRoamConnectedProfile {
 	bool qosConnection;     /* A connection is QoS enabled */
 	bool qap;               /* AP supports QoS */
 	struct mobility_domain_info mdid;
-#ifdef FEATURE_WLAN_ESE
-	bool isESEAssoc;
-#endif
 	uint32_t dot11Mode;
 #ifndef FEATURE_CM_ENABLE
 	uint8_t proxy_arp_service;
 #endif
 } tCsrRoamConnectedProfile;
 
-/**
- * enum sta_roam_policy_dfs_mode - state of DFS mode for STA ROME policy
- * @CSR_STA_ROAM_POLICY_NONE: DFS mode attribute is not valid
- * @CSR_STA_ROAM_POLICY_DFS_ENABLED:  DFS mode is enabled
- * @CSR_STA_ROAM_POLICY_DFS_DISABLED: DFS mode is disabled
- * @CSR_STA_ROAM_POLICY_DFS_DEPRIORITIZE: Deprioritize DFS channels in scanning
- */
-enum sta_roam_policy_dfs_mode {
-	CSR_STA_ROAM_POLICY_NONE,
-	CSR_STA_ROAM_POLICY_DFS_ENABLED,
-	CSR_STA_ROAM_POLICY_DFS_DISABLED,
-	CSR_STA_ROAM_POLICY_DFS_DEPRIORITIZE
-};
-
-/**
- * struct csr_sta_roam_policy_params - sta roam policy params for station
- * @dfs_mode: tell is DFS channels needs to be skipped while scanning
- * @skip_unsafe_channels: tells if unsafe channels needs to be skip in scanning
- * @sap_operating_band: Opearting band for SAP
- */
-struct csr_sta_roam_policy_params {
-	enum sta_roam_policy_dfs_mode dfs_mode;
-	bool skip_unsafe_channels;
-	uint8_t sap_operating_band;
-};
-
 /**
  * struct csr_neighbor_report_offload_params - neighbor report offload params
  * @params_bitmask: bitmask to specify which of the below are enabled
@@ -856,7 +827,6 @@ struct csr_config_params {
 #ifdef FEATURE_AP_MCC_CH_AVOIDANCE
 	bool sap_channel_avoidance;
 #endif /* FEATURE_AP_MCC_CH_AVOIDANCE */
-	struct csr_sta_roam_policy_params sta_roam_policy_params;
 	enum force_1x1_type is_force_1x1;
 	uint32_t offload_11k_enable_bitmask;
 	bool wep_tkip_in_he;

core/sme/inc/csr_internal.h

@@ -361,7 +361,6 @@ struct csr_config {
 	uint8_t conc_custom_rule2;
 	uint8_t is_sta_connection_in_5gz_enabled;
 	struct roam_ext_params roam_params;
-	struct csr_sta_roam_policy_params sta_roam_policy;
 	enum force_1x1_type is_force_1x1;
 	uint32_t offload_11k_enable_bitmask;
 	bool wep_tkip_in_he;
@@ -414,10 +413,6 @@ struct csr_scanstruct {
 	 */
 	uint8_t fEnableDFSChnlScan;
 	bool fDropScanCmd;      /* true means we don't accept scan commands */
-
-	/* This includes all channels on which candidate APs are found */
-	struct csr_channel occupiedChannels[WLAN_MAX_VDEVS];
-	int8_t roam_candidate_count[WLAN_MAX_VDEVS];
 	int8_t inScanResultBestAPRssi;
 	bool fcc_constraint;
 	bool pending_channel_list_req;
@@ -611,8 +606,6 @@ struct csr_roamstruct {
 	 * This may or may not have the up-to-date valid channel list. It is
 	 * used to get CFG_VALID_CHANNEL_LIST and not alloc mem all time
 	 */
-	uint32_t valid_ch_freq_list[CFG_VALID_CHANNEL_LIST_LEN];
-	uint32_t numValidChannels;       /* total number of channels in CFG */
 	int32_t sPendingCommands;
 	qdf_mc_timer_t hTimerWaitForKey; /* support timeout for WaitForKey */
 	struct csr_timer_info WaitForKeyTimerInfo;
@@ -933,8 +926,6 @@ QDF_STATUS csr_get_tsm_stats(struct mac_context *mac,
 bool csr_roam_is_fast_roam_enabled(struct mac_context *mac,  uint8_t vdev_id);
 bool csr_roam_is_roam_offload_scan_enabled(
 	struct mac_context *mac);
-bool csr_is_channel_present_in_list(uint32_t *pChannelList,
-				    int numChannels, uint32_t chan_freq);
 QDF_STATUS csr_add_to_channel_list_front(uint32_t *pChannelList,
 					 int numChannels, uint32_t chan_freq);
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)

core/sme/inc/csr_neighbor_roam.h

@@ -42,16 +42,6 @@ typedef enum {
 	eNEIGHBOR_STATE_MAX
 } eCsrNeighborRoamState;
 
-#define CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX    255
-typedef struct sCsrNeighborRoamChannelInfo {
-	/* Flag to mark reception of IAPP Neighbor list */
-	bool IAPPNeighborListReceived;
-	/* Current channel index that is being scanned */
-	uint8_t currentChanIndex;
-	/* Max number of channels in channel list and the list of channels */
-	tCsrChannelInfo currentChannelListInfo;
-} tCsrNeighborRoamChannelInfo, *tpCsrNeighborRoamChannelInfo;
-
 typedef struct sCsrNeighborRoamBSSInfo {
 	tListElem List;
 	uint8_t apPreferenceVal;
@@ -87,13 +77,11 @@ typedef struct sCsrNeighborRoamControlInfo {
 	eCsrNeighborRoamState prevNeighborRoamState;
 	struct qdf_mac_addr currAPbssid;  /* current assoc AP */
 	uint32_t curr_ap_op_chan_freq; /* current assoc AP */
-	tCsrNeighborRoamChannelInfo roamChannelInfo;
 	tDblLinkList roamableAPList;    /* List of current FT candidates */
 	struct csr_roam_profile csrNeighborRoamProfile;
 	bool is11rAssoc;
 	tCsr11rAssocNeighborInfo FTRoamInfo;
 #ifdef FEATURE_WLAN_ESE
-	bool isESEAssoc;
 	bool isVOAdmitted;
 	uint16_t MinQBssLoadRequired;
 #endif

core/sme/inc/sme_api.h

@@ -1197,16 +1197,6 @@ QDF_STATUS sme_get_roam_scan_channel_list(mac_handle_t mac_handle,
 					  uint8_t *pNumChannels,
 					  uint8_t sessionId);
 
-/**
- * sme_dump_freq_list() - Dump the frequencies from given chan info
- * @chan_info: Contains the frequency list and number of frequencies
- *
- * Extract number of frequencies and frequency list from chan_info and print
- * to the logs.
- *
- * Return: None
- */
-void sme_dump_freq_list(struct rso_chan_info *chan_info);
 bool sme_get_is_ese_feature_enabled(mac_handle_t mac_handle);
 bool sme_get_wes_mode(mac_handle_t mac_handle);
 bool sme_get_roam_scan_control(mac_handle_t mac_handle);

core/sme/inc/sme_inside.h

@@ -193,7 +193,27 @@ QDF_STATUS sme_release_global_lock(struct sme_context *sme);
 void csr_flush_cfg_bg_scan_roam_channel_list(struct rso_chan_info *channel_info);
 
 #ifdef FEATURE_WLAN_ESE
+/**
+ * csr_create_roam_scan_channel_list() - create roam scan channel list
+ * @mac: Global mac pointer
+ * @rso_cfg: roam config
+ * @sessionId: session id
+ * @chan_freq_list: pointer to channel list
+ * @numChannels: number of channels
+ * @band: band enumeration
+ *
+ * This function modifies the roam scan channel list as per AP neighbor
+ * report; AP neighbor report may be empty or may include only other AP
+ * channels; in any case, we merge the channel list with the learned occupied
+ * channels list.
+ * if the band is 2.4G, then make sure channel list contains only 2.4G
+ * valid channels if the band is 5G, then make sure channel list contains
+ * only 5G valid channels
+ *
+ * Return: QDF_STATUS enumeration
+ */
 QDF_STATUS csr_create_roam_scan_channel_list(struct mac_context *mac,
+		struct rso_config *rso_cfg,
 		uint8_t sessionId,
 		uint32_t *chan_freq_list,
 		uint8_t numChannels,

core/sme/src/common/sme_api.c

@@ -1817,13 +1817,14 @@ QDF_STATUS sme_set_ese_roam_scan_channel_list(mac_handle_t mac_handle,
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	tpCsrNeighborRoamControlInfo pNeighborRoamInfo = NULL;
-	tpCsrChannelInfo curchnl_list_info = NULL;
 	uint8_t oldChannelList[CFG_VALID_CHANNEL_LIST_LEN * 5] = { 0 };
 	uint8_t newChannelList[CFG_VALID_CHANNEL_LIST_LEN * 5] = { 0 };
 	uint8_t i = 0, j = 0;
 	enum band_info band = -1;
 	uint32_t band_bitmap;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_chan_info *chan_lst;
 
 	if (sessionId >= WLAN_MAX_VDEVS) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
@@ -1831,40 +1832,52 @@ QDF_STATUS sme_set_ese_roam_scan_channel_list(mac_handle_t mac_handle,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	pNeighborRoamInfo = &mac->roam.neighborRoamInfo[sessionId];
-	curchnl_list_info =
-		&pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo;
-
 	status = sme_acquire_global_lock(&mac->sme);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		return status;
 
-	if (curchnl_list_info->freq_list) {
-		for (i = 0; i < curchnl_list_info->numOfChannels; i++) {
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac->psoc, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL");
+		sme_release_global_lock(&mac->sme);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		sme_release_global_lock(&mac->sme);
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	chan_lst = &rso_cfg->roam_scan_freq_lst;
+
+	if (chan_lst->freq_list) {
+		for (i = 0; i < chan_lst->num_chan; i++) {
 			j += snprintf(oldChannelList + j,
 				sizeof(oldChannelList) - j, "%d",
-				curchnl_list_info->freq_list[i]);
+				chan_lst->freq_list[i]);
 		}
 	}
 	ucfg_reg_get_band(mac->pdev, &band_bitmap);
 	band = wlan_reg_band_bitmap_to_band_info(band_bitmap);
-	status = csr_create_roam_scan_channel_list(mac, sessionId,
+	status = csr_create_roam_scan_channel_list(mac, rso_cfg, sessionId,
 				chan_freq_list, numChannels,
 				band);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		if (curchnl_list_info->freq_list) {
+		if (chan_lst->freq_list) {
 			j = 0;
-			for (i = 0; i < curchnl_list_info->numOfChannels; i++) {
+			for (i = 0; i < chan_lst->num_chan; i++) {
 				j += snprintf(newChannelList + j,
 					sizeof(newChannelList) - j, "%d",
-					curchnl_list_info->freq_list[i]);
+					chan_lst->freq_list[i]);
 			}
 		}
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-			"ESE roam scan chnl list successfully set to %s-old value is %s-roam state is %d",
-			newChannelList, oldChannelList,
-			pNeighborRoamInfo->neighborRoamState);
+		sme_debug("ESE roam scan chnl list successfully set to %s-old value is %s",
+			  newChannelList, oldChannelList);
 	}
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	if (mac->mlme_cfg->lfr.roam_scan_offload_enabled)
 		csr_roam_update_cfg(mac, sessionId,
@@ -7094,30 +7107,6 @@ QDF_STATUS sme_get_roam_rssi_diff(mac_handle_t mac_handle, uint8_t vdev_id,
 	return QDF_STATUS_SUCCESS;
 }
 
-void sme_dump_freq_list(struct rso_chan_info *chan_info)
-{
-	uint8_t *channel_list;
-	uint8_t i = 0, j = 0;
-	uint32_t buflen = CFG_VALID_CHANNEL_LIST_LEN * 4;
-
-	channel_list = qdf_mem_malloc(buflen);
-	if (!channel_list)
-		return;
-
-	if (chan_info->freq_list) {
-		for (i = 0; i < chan_info->num_chan; i++) {
-			if (j < buflen)
-				j += snprintf(channel_list + j, buflen - j,
-					      "%d ", chan_info->freq_list[i]);
-			else
-				break;
-		}
-	}
-
-	sme_debug("frequency list [%u]: %s", i, channel_list);
-	qdf_mem_free(channel_list);
-}
-
 static bool sme_validate_freq_list(mac_handle_t mac_handle,
 				   uint32_t *freq_list,
 				   uint8_t num_channels)
@@ -7227,8 +7216,6 @@ QDF_STATUS sme_get_roam_scan_channel_list(mac_handle_t mac_handle,
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct rso_chan_info *chan_info;
-	struct csr_channel *occupied_ch_lst =
-		&mac->scan.occupiedChannels[sessionId];
 	struct wlan_objmgr_vdev *vdev;
 	struct rso_config *rso_cfg;
 	struct rso_cfg_params *cfg_params;
@@ -7276,16 +7263,16 @@ QDF_STATUS sme_get_roam_scan_channel_list(mac_handle_t mac_handle,
 					chan_info->freq_list[chan_cnt];
 		}
 
-		if (occupied_ch_lst->numChannels) {
-			for (i = 0; i < occupied_ch_lst->numChannels &&
-			     chan_cnt < WNI_CFG_VALID_CHANNEL_LIST_LEN; i++)
+		if (rso_cfg->occupied_chan_lst.num_chan) {
+			for (i = 0; i < rso_cfg->occupied_chan_lst.num_chan &&
+			     chan_cnt < CFG_VALID_CHANNEL_LIST_LEN; i++)
 				freq_list[chan_cnt++] =
-					occupied_ch_lst->channel_freq_list[i];
+				     rso_cfg->occupied_chan_lst.freq_list[i];
 		}
 
 		*pNumChannels = chan_cnt;
 		if (!(chan_info->num_chan ||
-		      occupied_ch_lst->numChannels)) {
+		      rso_cfg->occupied_chan_lst.num_chan)) {
 			sme_err("Roam Scan channel list is NOT yet initialized");
 			*pNumChannels = 0;
 			status = QDF_STATUS_E_INVAL;
@@ -12983,7 +12970,7 @@ QDF_STATUS sme_update_sta_roam_policy(mac_handle_t mac_handle,
 {
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	struct sme_config_params *sme_config;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
 
 	if (!mac_ctx) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_FATAL,
@@ -12991,22 +12978,17 @@ QDF_STATUS sme_update_sta_roam_policy(mac_handle_t mac_handle,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	sme_config = qdf_mem_malloc(sizeof(*sme_config));
-	if (!sme_config)
+	mlme_obj = mlme_get_psoc_ext_obj(mac_ctx->psoc);
+	if (!mlme_obj)
 		return QDF_STATUS_E_FAILURE;
 
-	qdf_mem_zero(sme_config, sizeof(*sme_config));
-	sme_get_config_param(mac_handle, sme_config);
-
-	sme_config->csr_config.sta_roam_policy_params.dfs_mode =
+	mlme_obj->cfg.lfr.rso_user_config.policy_params.dfs_mode =
 		dfs_mode;
-	sme_config->csr_config.sta_roam_policy_params.skip_unsafe_channels =
+	mlme_obj->cfg.lfr.rso_user_config.policy_params.skip_unsafe_channels =
 		skip_unsafe_channels;
-	sme_config->csr_config.sta_roam_policy_params.sap_operating_band =
+	mlme_obj->cfg.lfr.rso_user_config.policy_params.sap_operating_band =
 		sap_operating_band;
 
-	sme_update_config(mac_handle, sme_config);
-
 	status = csr_update_channel_list(mac_ctx);
 	if (QDF_STATUS_SUCCESS != status) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
@@ -13021,7 +13003,7 @@ QDF_STATUS sme_update_sta_roam_policy(mac_handle_t mac_handle,
 			sme_release_global_lock(&mac_ctx->sme);
 		}
 	}
-	qdf_mem_free(sme_config);
+
 	return status;
 }
 

core/sme/src/csr/csr_api_scan.c

@@ -319,27 +319,27 @@ QDF_STATUS csr_scan_result_purge(struct mac_context *mac,
 static void csr_add_to_occupied_channels(struct mac_context *mac,
 					 uint32_t ch_freq,
 					 uint8_t sessionId,
-					 struct csr_channel *occupied_ch,
+					 struct rso_config *rso_cfg,
 					 bool is_init_list)
 {
 	QDF_STATUS status;
-	uint8_t num_occupied_ch = occupied_ch->numChannels;
-	uint32_t *occupied_ch_lst = occupied_ch->channel_freq_list;
+	uint8_t num_occupied_ch = rso_cfg->occupied_chan_lst.num_chan;
+	uint32_t *occupied_ch_lst = rso_cfg->occupied_chan_lst.freq_list;
 
 	if (is_init_list)
-		mac->scan.roam_candidate_count[sessionId]++;
+		rso_cfg->roam_candidate_count++;
 
-	if (csr_is_channel_present_in_list(occupied_ch_lst,
-					   num_occupied_ch, ch_freq))
+	if (wlan_is_channel_present_in_list(occupied_ch_lst,
+					    num_occupied_ch, ch_freq))
 		return;
 
 	status = csr_add_to_channel_list_front(occupied_ch_lst,
 					       num_occupied_ch, ch_freq);
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		occupied_ch->numChannels++;
-		if (occupied_ch->numChannels >
+		rso_cfg->occupied_chan_lst.num_chan++;
+		if (rso_cfg->occupied_chan_lst.num_chan >
 		    CSR_BG_SCAN_OCCUPIED_CHANNEL_LIST_LEN)
-			occupied_ch->numChannels =
+			rso_cfg->occupied_chan_lst.num_chan =
 				CSR_BG_SCAN_OCCUPIED_CHANNEL_LIST_LEN;
 	}
 }
@@ -1621,10 +1621,11 @@ bool csr_roam_is_valid_channel(struct mac_context *mac, uint32_t ch_freq)
 {
 	bool fValid = false;
 	uint32_t idx_valid_ch;
-	uint32_t len = mac->roam.numValidChannels;
+	uint32_t num_chan = mac->mlme_cfg->reg.valid_channel_list_num;
+	uint32_t *freq_lst = mac->mlme_cfg->reg.valid_channel_freq_list;
 
-	for (idx_valid_ch = 0; (idx_valid_ch < len); idx_valid_ch++) {
-		if (ch_freq == mac->roam.valid_ch_freq_list[idx_valid_ch]) {
+	for (idx_valid_ch = 0; (idx_valid_ch < num_chan); idx_valid_ch++) {
+		if (ch_freq == freq_lst[idx_valid_ch]) {
 			fValid = true;
 			break;
 		}
@@ -2403,24 +2404,24 @@ void csr_remove_bssid_from_scan_list(struct mac_context *mac_ctx,
 	csr_flush_bssid(mac_ctx, bssid);
 }
 
-static void csr_dump_occupied_chan_list(struct csr_channel *occupied_ch)
+static void csr_dump_occupied_chan_list(struct wlan_chan_list *occupied_ch)
 {
 	uint8_t idx;
 	uint32_t buff_len;
 	char *chan_buff;
 	uint32_t len = 0;
 
-	buff_len = (occupied_ch->numChannels * 5) + 1;
+	buff_len = (occupied_ch->num_chan * 5) + 1;
 	chan_buff = qdf_mem_malloc(buff_len);
 	if (!chan_buff)
 		return;
 
-	for (idx = 0; idx < occupied_ch->numChannels; idx++)
+	for (idx = 0; idx < occupied_ch->num_chan; idx++)
 		len += qdf_scnprintf(chan_buff + len, buff_len - len, " %d",
-				     occupied_ch->channel_freq_list[idx]);
+				     occupied_ch->freq_list[idx]);
 
 	sme_nofl_debug("Occupied chan list[%d]:%s",
-		       occupied_ch->numChannels, chan_buff);
+		       occupied_ch->num_chan, chan_buff);
 
 	qdf_mem_free(chan_buff);
 }
@@ -2530,15 +2531,11 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 	}
 
 	/* Empty occupied channels here */
-	mac_ctx->scan.occupiedChannels[sessionId].numChannels = 0;
-	mac_ctx->scan.roam_candidate_count[sessionId] = 0;
-
-	csr_add_to_occupied_channels(
-			mac_ctx,
-			profile->op_freq,
-			sessionId,
-			&mac_ctx->scan.occupiedChannels[sessionId],
-			true);
+	rso_cfg->occupied_chan_lst.num_chan = 0;
+	rso_cfg->roam_candidate_count = 0;
+
+	csr_add_to_occupied_channels(mac_ctx, profile->op_freq, sessionId,
+				     rso_cfg, true);
 	list = ucfg_scan_get_result(pdev, filter);
 	if (!list || (list && !qdf_list_size(list))) {
 		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
@@ -2546,7 +2543,6 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 	}
 
 	chan = wlan_vdev_get_active_channel(vdev);
-	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 	if (!chan) {
 		sme_err("no active channel");
 		goto err;
@@ -2567,16 +2563,15 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 
 			csr_add_to_occupied_channels
 				   (mac_ctx, cur_node->entry->channel.chan_freq,
-				    sessionId,
-				    &mac_ctx->scan.occupiedChannels[sessionId],
-				    true);
+				    sessionId, rso_cfg, true);
 
 		qdf_list_peek_next(list, cur_lst, &next_lst);
 		cur_lst = next_lst;
 		next_lst = NULL;
 	}
 err:
-	csr_dump_occupied_chan_list(&mac_ctx->scan.occupiedChannels[sessionId]);
+	csr_dump_occupied_chan_list(&rso_cfg->occupied_chan_lst);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 	qdf_mem_free(filter);
 	if (list)
 		ucfg_scan_purge_results(list);
@@ -2600,10 +2595,9 @@ rel_vdev_ref:
  */
 QDF_STATUS csr_scan_filter_results(struct mac_context *mac_ctx)
 {
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	uint32_t len = sizeof(mac_ctx->roam.valid_ch_freq_list);
+	uint32_t len = mac_ctx->mlme_cfg->reg.valid_channel_list_num;
 	struct wlan_objmgr_pdev *pdev = NULL;
-	uint32_t i;
+	uint32_t i, valid_chan_len = 0;
 	uint32_t ch_freq;
 	uint32_t valid_ch_freq_list[CFG_VALID_CHANNEL_LIST_LEN];
 
@@ -2613,28 +2607,22 @@ QDF_STATUS csr_scan_filter_results(struct mac_context *mac_ctx)
 		sme_err("pdev is NULL");
 		return QDF_STATUS_E_INVAL;
 	}
-	status = csr_get_cfg_valid_channels(mac_ctx,
-			  mac_ctx->roam.valid_ch_freq_list,
-			  &len);
-
-	/* Get valid channels list from CFG */
-	if (QDF_IS_STATUS_ERROR(status)) {
-		wlan_objmgr_pdev_release_ref(pdev, WLAN_LEGACY_MAC_ID);
-		sme_err("Failed to get Channel list from CFG");
-		return status;
-	}
-	sme_debug("No of valid channel %d", len);
 
 	/* This is a temporary conversion till the scm handles freq */
-
 	for (i = 0; i < len; i++) {
-		ch_freq = mac_ctx->roam.valid_ch_freq_list[i];
-		valid_ch_freq_list[i] = ch_freq;
+		if (wlan_reg_is_dsrc_freq(
+			mac_ctx->mlme_cfg->reg.valid_channel_freq_list[i]))
+			continue;
+		ch_freq = mac_ctx->mlme_cfg->reg.valid_channel_freq_list[i];
+		valid_ch_freq_list[valid_chan_len++] = ch_freq;
 	}
+	sme_debug("No of valid channel %d", valid_chan_len);
 
-	ucfg_scan_filter_valid_channel(pdev, valid_ch_freq_list, len);
+	ucfg_scan_filter_valid_channel(pdev, valid_ch_freq_list,
+				       valid_chan_len);
 
 	wlan_objmgr_pdev_release_ref(pdev, WLAN_LEGACY_MAC_ID);
+
 	return QDF_STATUS_SUCCESS;
 }
 

core/sme/src/csr/csr_host_scan_roam.c

@@ -235,7 +235,7 @@ void csr_neighbor_roam_process_scan_results(struct mac_context *mac_ctx,
 
 #ifdef FEATURE_WLAN_ESE
 			if (!csr_roam_is_roam_offload_scan_enabled(mac_ctx) &&
-			    (n_roam_info->isESEAssoc) &&
+			    (wlan_cm_get_ese_assoc(mac_ctx->pdev, sessionid)) &&
 			    !csr_neighbor_roam_is_preauth_candidate(mac_ctx,
 				sessionid, descr->bssId)) {
 				sme_err("BSSID in preauth faillist. Ignore");
@@ -620,7 +620,7 @@ csr_neighbor_roam_get_handoff_ap_info(struct mac_context *mac,
 				ngbr_roam_info->FTRoamInfo.preAuthDoneList));
 	} else
 #ifdef FEATURE_WLAN_ESE
-	if (ngbr_roam_info->isESEAssoc) {
+	if (wlan_cm_get_ese_assoc(mac->pdev, session_id)) {
 		/* Always the BSS info in the head is the handoff candidate */
 		bss_node =
 			csr_neighbor_roam_next_roamable_ap(mac,

core/sme/src/csr/csr_neighbor_roam.c

@@ -49,9 +49,6 @@ static const char *lfr_get_config_item_string(uint8_t reason)
 	}
 }
 
-static void csr_neighbor_roam_reset_channel_info(tpCsrNeighborRoamChannelInfo
-						 rChInfo);
-
 void csr_neighbor_roam_state_transition(struct mac_context *mac_ctx,
 		uint8_t newstate, uint8_t session)
 {
@@ -241,23 +238,6 @@ QDF_STATUS csr_neighbor_roam_update_config(struct mac_context *mac_ctx,
 	return QDF_STATUS_SUCCESS;
 }
 
-/*CleanUP Routines*/
-static void csr_neighbor_roam_reset_channel_info(tpCsrNeighborRoamChannelInfo
-						 rChInfo)
-{
-	if ((rChInfo->IAPPNeighborListReceived == false) &&
-	    (rChInfo->currentChannelListInfo.numOfChannels)) {
-		rChInfo->currentChanIndex =
-			CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX;
-		rChInfo->currentChannelListInfo.numOfChannels = 0;
-		if (rChInfo->currentChannelListInfo.freq_list)
-			qdf_mem_free(rChInfo->currentChannelListInfo.freq_list);
-		rChInfo->currentChannelListInfo.freq_list = NULL;
-	} else {
-		rChInfo->currentChanIndex = 0;
-	}
-}
-
 /**
  * csr_neighbor_roam_reset_connected_state_control_info()
  *
@@ -276,9 +256,30 @@ static void csr_neighbor_roam_reset_connected_state_control_info(
 {
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 		&mac->roam.neighborRoamInfo[sessionId];
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_chan_info *chan_lst;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac->psoc, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL");
+		return;
+	}
+
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
+
+	chan_lst = &rso_cfg->roam_scan_freq_lst;
+	if (chan_lst->freq_list)
+		qdf_mem_free(chan_lst->freq_list);
+	chan_lst->freq_list = NULL;
+	chan_lst->num_chan = 0;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
-	csr_neighbor_roam_reset_channel_info(&pNeighborRoamInfo->
-					roamChannelInfo);
 	csr_neighbor_roam_free_roamable_bss_list(mac,
 					&pNeighborRoamInfo->roamableAPList);
 
@@ -301,7 +302,7 @@ static void csr_neighbor_roam_reset_report_scan_state_control_info(
 
 	qdf_zero_macaddr(&pNeighborRoamInfo->currAPbssid);
 #ifdef FEATURE_WLAN_ESE
-	pNeighborRoamInfo->isESEAssoc = false;
+	wlan_cm_set_ese_assoc(mac->pdev, sessionId, false);
 	pNeighborRoamInfo->isVOAdmitted = false;
 	pNeighborRoamInfo->MinQBssLoadRequired = 0;
 #endif
@@ -375,9 +376,11 @@ csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
 	tpCsrNeighborRoamControlInfo nbr_roam_info;
 	tCsrRoamConnectedProfile *profile;
 	struct roam_ext_params *roam_params;
-	tCsrChannelInfo *chan_info;
 	uint8_t num_ch = 0;
 	QDF_STATUS status;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_chan_info *chan_lst;
 
 	if (!filter)
 		return QDF_STATUS_E_FAILURE;
@@ -423,16 +426,29 @@ csr_neighbor_roam_get_scan_filter_from_profile(struct mac_context *mac,
 	if (QDF_IS_STATUS_ERROR(status))
 		return status;
 
-	chan_info = &nbr_roam_info->roamChannelInfo.currentChannelListInfo;
-	num_ch = chan_info->numOfChannels;
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac->psoc, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return QDF_STATUS_E_FAILURE;
+	}
+	chan_lst = &rso_cfg->roam_scan_freq_lst;
+	num_ch = chan_lst->num_chan;
 	if (num_ch) {
 		filter->num_of_channels = num_ch;
 		if (filter->num_of_channels > NUM_CHANNELS)
 			filter->num_of_channels = NUM_CHANNELS;
-		qdf_mem_copy(filter->chan_freq_list, chan_info->freq_list,
+		qdf_mem_copy(filter->chan_freq_list, chan_lst->freq_list,
 			     filter->num_of_channels *
 			     sizeof(filter->chan_freq_list[0]));
 	}
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	if (nbr_roam_info->is11rAssoc)
 		/*
@@ -713,8 +729,6 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 			 */
 		csr_neighbor_roam_state_transition(mac,
 				eCSR_NEIGHBOR_ROAM_STATE_INIT, sessionId);
-			pNeighborRoamInfo->roamChannelInfo.
-				IAPPNeighborListReceived = false;
 			pNeighborRoamInfo->uOsRequestedHandoff = 0;
 		}
 		break;
@@ -727,8 +741,6 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 	case eCSR_NEIGHBOR_ROAM_STATE_CONNECTED:
 		csr_neighbor_roam_state_transition(mac,
 				eCSR_NEIGHBOR_ROAM_STATE_INIT, sessionId);
-		pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived =
-				false;
 		csr_neighbor_roam_reset_connected_state_control_info(mac,
 				sessionId);
 		break;
@@ -741,8 +753,6 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 	case eCSR_NEIGHBOR_ROAM_STATE_PREAUTHENTICATING:
 		csr_neighbor_roam_state_transition(mac,
 				eCSR_NEIGHBOR_ROAM_STATE_INIT, sessionId);
-		pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived =
-				false;
 		csr_neighbor_roam_reset_preauth_control_info(mac, sessionId);
 		csr_neighbor_roam_reset_report_scan_state_control_info(mac,
 				sessionId);
@@ -754,8 +764,6 @@ QDF_STATUS csr_neighbor_roam_indicate_disconnect(struct mac_context *mac,
 		sme_debug("Transit to INIT state");
 		csr_neighbor_roam_state_transition(mac,
 				eCSR_NEIGHBOR_ROAM_STATE_INIT, sessionId);
-			pNeighborRoamInfo->roamChannelInfo.
-			IAPPNeighborListReceived = false;
 			pNeighborRoamInfo->uOsRequestedHandoff = 0;
 		break;
 	}
@@ -837,12 +845,10 @@ static void csr_neighbor_roam_info_ctx_init(struct mac_context *mac,
 
 #ifdef FEATURE_WLAN_ESE
 	/* Based on the auth scheme tell if we are 11r */
-	if (session->connectedProfile.isESEAssoc) {
+	if (wlan_cm_get_ese_assoc(mac->pdev, session_id)) {
 		if (mac->mlme_cfg->lfr.fast_transition_enabled)
 			init_ft_flag = true;
-		ngbr_roam_info->isESEAssoc = true;
-	} else
-		ngbr_roam_info->isESEAssoc = false;
+	}
 #endif
 	/* If "FastRoamEnabled" ini is enabled */
 	if (csr_roam_is_fast_roam_enabled(mac, session_id))
@@ -961,8 +967,6 @@ QDF_STATUS csr_neighbor_roam_indicate_connect(
 			 */
 			csr_neighbor_roam_state_transition(mac,
 				eCSR_NEIGHBOR_ROAM_STATE_INIT, session_id);
-			ngbr_roam_info->roamChannelInfo.
-					IAPPNeighborListReceived = false;
 			ngbr_roam_info->uOsRequestedHandoff = 0;
 			break;
 		}
@@ -1047,13 +1051,6 @@ QDF_STATUS csr_neighbor_roam_init(struct mac_context *mac, uint8_t sessionId)
 		return QDF_STATUS_E_RESOURCES;
 	}
 
-	pNeighborRoamInfo->roamChannelInfo.currentChanIndex =
-		CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX;
-	pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo.numOfChannels = 0;
-	pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo.freq_list =
-		NULL;
-	pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived = false;
-
 	status = csr_neighbor_roam_init11r_assoc_info(mac);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("LL Open of roam able AP List failed");
@@ -1062,7 +1059,6 @@ QDF_STATUS csr_neighbor_roam_init(struct mac_context *mac, uint8_t sessionId)
 
 	csr_neighbor_roam_state_transition(mac,
 			eCSR_NEIGHBOR_ROAM_STATE_INIT, sessionId);
-	pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived = false;
 	pNeighborRoamInfo->uOsRequestedHandoff = 0;
 	/* Set the Last Sent Cmd as RSO_STOP */
 	pNeighborRoamInfo->last_sent_cmd = ROAM_SCAN_OFFLOAD_STOP;
@@ -1080,7 +1076,6 @@ 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)
 {
-	tCsrChannelInfo *current_channel_list_info;
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 		&mac->roam.neighborRoamInfo[sessionId];
 
@@ -1097,17 +1092,6 @@ void csr_neighbor_roam_close(struct mac_context *mac, uint8_t sessionId)
 					&pNeighborRoamInfo->roamableAPList);
 	csr_ll_close(&pNeighborRoamInfo->roamableAPList);
 
-	current_channel_list_info =
-		&pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo;
-	if (current_channel_list_info->freq_list)
-		qdf_mem_free(current_channel_list_info->freq_list);
-
-	current_channel_list_info->freq_list = NULL;
-	pNeighborRoamInfo->roamChannelInfo.currentChanIndex =
-		CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX;
-	current_channel_list_info->numOfChannels = 0;
-	pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived = false;
-
 	/* Free the profile.. */
 	csr_release_profile(mac, &pNeighborRoamInfo->csrNeighborRoamProfile);
 	pNeighborRoamInfo->FTRoamInfo.currentNeighborRptRetryNum = 0;

core/sme/src/csr/csr_roam_preauth.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -87,7 +87,6 @@ void csr_neighbor_roam_tranistion_preauth_done_to_disconnected(
 	qdf_mc_timer_stop(&session->ftSmeContext.preAuthReassocIntvlTimer);
 	csr_neighbor_roam_state_transition(mac_ctx,
 		eCSR_NEIGHBOR_ROAM_STATE_INIT, session_id);
-	pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived = false;
 	pNeighborRoamInfo->uOsRequestedHandoff = 0;
 }
 

core/sme/src/csr/csr_util.c

@@ -3790,25 +3790,6 @@ void csr_clear_channel_status(struct mac_context *mac)
 	return;
 }
 
-bool csr_is_channel_present_in_list(uint32_t *pChannelList,
-				    int numChannels, uint32_t chan_freq)
-{
-	int i = 0;
-
-	/* Check for NULL pointer */
-	if (!pChannelList || (numChannels == 0))
-		return false;
-
-	/* Look for the channel in the list */
-	for (i = 0; (i < numChannels) &&
-	     (i < CFG_VALID_CHANNEL_LIST_LEN); i++) {
-		if (pChannelList[i] == chan_freq)
-			return true;
-	}
-
-	return false;
-}
-
 /**
  * sme_bsstype_to_string() - converts bss type to string.
  * @bss_type: bss type enum

core/sme/src/qos/sme_qos.c

@@ -3887,9 +3887,6 @@ static QDF_STATUS sme_qos_add_ts_req(struct mac_context *mac,
 	tSirAddtsReq *pMsg = NULL;
 	struct sme_qos_sessioninfo *pSession;
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
-#ifdef FEATURE_WLAN_ESE
-	struct csr_roam_session *pCsrSession = CSR_GET_SESSION(mac, sessionId);
-#endif
 #ifdef FEATURE_WLAN_DIAG_SUPPORT
 	WLAN_HOST_DIAG_EVENT_DEF(qos, host_event_wlan_qos_payload_type);
 #endif
@@ -3970,7 +3967,7 @@ static QDF_STATUS sme_qos_add_ts_req(struct mac_context *mac,
 		  __func__, __LINE__,
 		  pTspec_Info->ts_info.up, pTspec_Info->ts_info.tid);
 #ifdef FEATURE_WLAN_ESE
-	if (pCsrSession->connectedProfile.isESEAssoc) {
+	if (wlan_cm_get_ese_assoc(mac->pdev, sessionId)) {
 		pMsg->req.tsrsIE.tsid = pTspec_Info->ts_info.up;
 		pMsg->req.tsrsPresent = 1;
 	}