qcacld-3.0: Cleanup the struct sCsrNeighborRoamControlInfo

Cleanup the struct sCsrNeighborRoamControlInfo and move params in
vdev ext object.

Change-Id: If5a490c68137622838afc831a4da0e1da7fa49c4
CRs-Fixed: 2850991

components/mlme/core/inc/wlan_mlme_main.h

@@ -263,6 +263,7 @@ struct mlme_connect_info {
  * @mscs_req_info: Information related to mscs request
  * @he_config: he config
  * @he_sta_obsspd: he_sta_obsspd
+ * @rso_cfg: per vdev RSO config to be sent to FW
  * @connect_info: mlme connect information
  */
 struct mlme_legacy_priv {
@@ -297,6 +298,9 @@ struct mlme_legacy_priv {
 #ifdef WLAN_FEATURE_11AX
 	tDot11fIEhe_cap he_config;
 	uint32_t he_sta_obsspd;
+#endif
+#ifndef FEATURE_CM_ENABLE
+	struct rso_config rso_cfg;
 #endif
 	struct mlme_connect_info connect_info;
 };

components/mlme/core/src/wlan_mlme_vdev_mgr_interface.c

@@ -1160,6 +1160,22 @@ static QDF_STATUS mlme_get_vdev_types(enum QDF_OPMODE mode, uint8_t *type,
 	return status;
 }
 
+static void mlme_ext_handler_destroy(struct vdev_mlme_obj *vdev_mlme)
+{
+	if (!vdev_mlme || !vdev_mlme->ext_vdev_ptr)
+		return;
+	mlme_free_self_disconnect_ies(vdev_mlme->vdev);
+	mlme_free_peer_disconnect_ies(vdev_mlme->vdev);
+	mlme_free_sae_auth_retry(vdev_mlme->vdev);
+	/* This is temp ifdef will be removed in near future */
+#ifndef FEATURE_CM_ENABLE
+	wlan_cm_rso_config_deinit(vdev_mlme->vdev);
+#endif
+	qdf_mem_free(vdev_mlme->ext_vdev_ptr->fils_con_info);
+	vdev_mlme->ext_vdev_ptr->fils_con_info = NULL;
+	qdf_mem_free(vdev_mlme->ext_vdev_ptr);
+	vdev_mlme->ext_vdev_ptr = NULL;
+}
 /**
  * vdevmgr_mlme_ext_hdl_create () - Create mlme legacy priv object
  * @vdev_mlme: vdev mlme object
@@ -1180,7 +1196,10 @@ QDF_STATUS vdevmgr_mlme_ext_hdl_create(struct vdev_mlme_obj *vdev_mlme)
 
 	mlme_init_rate_config(vdev_mlme);
 	vdev_mlme->ext_vdev_ptr->fils_con_info = NULL;
-
+	/* This is temp ifdef will be removed in near future */
+#ifndef FEATURE_CM_ENABLE
+	wlan_cm_rso_config_init(vdev_mlme->vdev);
+#endif
 	sme_get_vdev_type_nss(wlan_vdev_mlme_get_opmode(vdev_mlme->vdev),
 			      &vdev_mlme->proto.generic.nss_2g,
 			      &vdev_mlme->proto.generic.nss_5g);
@@ -1190,7 +1209,7 @@ QDF_STATUS vdevmgr_mlme_ext_hdl_create(struct vdev_mlme_obj *vdev_mlme)
 				     &vdev_mlme->mgmt.generic.subtype);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		mlme_err("Get vdev type failed; status:%d", status);
-		qdf_mem_free(vdev_mlme->ext_vdev_ptr);
+		mlme_ext_handler_destroy(vdev_mlme);
 		return status;
 	}
 
@@ -1198,7 +1217,7 @@ QDF_STATUS vdevmgr_mlme_ext_hdl_create(struct vdev_mlme_obj *vdev_mlme)
 	if (QDF_IS_STATUS_ERROR(status)) {
 		mlme_err("Failed to create vdev for vdev id %d",
 			 wlan_vdev_get_id(vdev_mlme->vdev));
-		qdf_mem_free(vdev_mlme->ext_vdev_ptr);
+		mlme_ext_handler_destroy(vdev_mlme);
 		return status;
 	}
 
@@ -1232,15 +1251,7 @@ QDF_STATUS vdevmgr_mlme_ext_hdl_destroy(struct vdev_mlme_obj *vdev_mlme)
 		wma_vdev_detach_callback(&rsp);
 	}
 
-	mlme_free_self_disconnect_ies(vdev_mlme->vdev);
-	mlme_free_peer_disconnect_ies(vdev_mlme->vdev);
-	mlme_free_sae_auth_retry(vdev_mlme->vdev);
-
-	qdf_mem_free(vdev_mlme->ext_vdev_ptr->fils_con_info);
-	vdev_mlme->ext_vdev_ptr->fils_con_info = NULL;
-
-	qdf_mem_free(vdev_mlme->ext_vdev_ptr);
-	vdev_mlme->ext_vdev_ptr = NULL;
+	mlme_ext_handler_destroy(vdev_mlme);
 
 	return QDF_STATUS_SUCCESS;
 }

components/mlme/dispatcher/inc/wlan_mlme_public_struct.h

@@ -1721,6 +1721,7 @@ struct fw_scan_channels {
  * @saved_freq_list: Valid channel list
  * @sae_single_pmk_feature_enabled: Contains value of ini
  * sae_single_pmk_feature_enabled
+ * @rso_user_config: RSO user config
  */
 struct wlan_mlme_lfr_cfg {
 	bool mawc_roam_enabled;
@@ -1836,6 +1837,7 @@ struct wlan_mlme_lfr_cfg {
 #if defined(WLAN_SAE_SINGLE_PMK) && defined(WLAN_FEATURE_ROAM_OFFLOAD)
 	bool sae_single_pmk_feature_enabled;
 #endif
+	struct rso_config_params rso_user_config;
 };
 
 /**

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

@@ -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
@@ -402,6 +402,137 @@ static void cm_roam_set_roam_reason_better_ap(struct wlan_objmgr_psoc *psoc,
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 }
 
+/**
+ * cm_roam_scan_offload_rssi_thresh() - set roam offload scan rssi
+ * parameters
+ * @psoc: psoc ctx
+ * @vdev_id: vdev id
+ * @params:  roam offload scan rssi related parameters
+ * @rso_cfg: rso config
+ *
+ * This function is used to set roam offload scan rssi related parameters
+ *
+ * Return: None
+ */
+static void
+cm_roam_scan_offload_rssi_thresh(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
+			struct wlan_roam_offload_scan_rssi_params *params,
+			struct rso_config *rso_cfg)
+{
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+	struct wlan_mlme_lfr_cfg *lfr_cfg;
+	struct rso_config_params *rso_config;
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return;
+	rso_config = &mlme_obj->cfg.lfr.rso_user_config;
+
+	lfr_cfg = &mlme_obj->cfg.lfr;
+
+	if (rso_config->alert_rssi_threshold)
+		params->rssi_thresh = rso_config->alert_rssi_threshold;
+	else
+		params->rssi_thresh =
+			(int8_t)rso_cfg->cfg_param.neighbor_lookup_threshold *
+			(-1);
+
+	params->vdev_id = vdev_id;
+	params->rssi_thresh_diff =
+		rso_cfg->cfg_param.opportunistic_threshold_diff & 0x000000ff;
+	params->hi_rssi_scan_max_count =
+		rso_cfg->cfg_param.hi_rssi_scan_max_count;
+	/*
+	 * If the current operation channel is 5G frequency band, then
+	 * there is no need to enable the HI_RSSI feature. This feature
+	 * is useful only if we are connected to a 2.4 GHz AP and we wish
+	 * to connect to a better 5GHz AP is available.
+	 */
+	if (rso_cfg->disable_hi_rssi)
+		params->hi_rssi_scan_rssi_delta = 0;
+	else
+		params->hi_rssi_scan_rssi_delta =
+			rso_cfg->cfg_param.hi_rssi_scan_rssi_delta;
+	params->hi_rssi_scan_rssi_ub =
+		rso_cfg->cfg_param.hi_rssi_scan_rssi_ub;
+	params->raise_rssi_thresh_5g = lfr_cfg->rssi_boost_threshold_5g;
+	params->dense_rssi_thresh_offset = lfr_cfg->roam_dense_rssi_thre_offset;
+	params->dense_min_aps_cnt = lfr_cfg->roam_dense_min_aps;
+	params->traffic_threshold = lfr_cfg->roam_dense_traffic_threshold;
+
+	/* Set initial dense roam status */
+	if (rso_cfg->roam_candidate_count > params->dense_min_aps_cnt)
+		params->initial_dense_status = true;
+
+	params->bg_scan_bad_rssi_thresh =
+			lfr_cfg->roam_bg_scan_bad_rssi_threshold;
+	params->bg_scan_client_bitmap = lfr_cfg->roam_bg_scan_client_bitmap;
+	params->roam_bad_rssi_thresh_offset_2g =
+			lfr_cfg->roam_bg_scan_bad_rssi_offset_2g;
+	params->roam_data_rssi_threshold_triggers =
+		lfr_cfg->roam_data_rssi_threshold_triggers;
+	params->roam_data_rssi_threshold = lfr_cfg->roam_data_rssi_threshold;
+	params->rx_data_inactivity_time = lfr_cfg->rx_data_inactivity_time;
+
+	params->drop_rssi_thresh_5g = lfr_cfg->rssi_penalize_threshold_5g;
+
+	params->raise_factor_5g = lfr_cfg->rssi_boost_factor_5g;
+	params->drop_factor_5g = lfr_cfg->rssi_penalize_factor_5g;
+	params->max_raise_rssi_5g = lfr_cfg->max_rssi_boost_5g;
+	params->max_drop_rssi_5g = lfr_cfg->max_rssi_penalize_5g;
+
+	if (rso_config->good_rssi_roam)
+		params->good_rssi_threshold = NOISE_FLOOR_DBM_DEFAULT;
+	else
+		params->good_rssi_threshold = 0;
+
+	params->early_stop_scan_enable = lfr_cfg->early_stop_scan_enable;
+	if (params->early_stop_scan_enable) {
+		params->roam_earlystop_thres_min =
+			lfr_cfg->early_stop_scan_min_threshold;
+		params->roam_earlystop_thres_max =
+			lfr_cfg->early_stop_scan_max_threshold;
+	}
+
+	params->rssi_thresh_offset_5g =
+		rso_cfg->cfg_param.rssi_thresh_offset_5g;
+}
+
+/**
+ * cm_roam_scan_offload_scan_period() - set roam offload scan period
+ * parameters
+ * @vdev_id: vdev id
+ * @params:  roam offload scan period related parameters
+ * @rso_cfg: rso config
+ *
+ * This function is used to set roam offload scan period related parameters
+ *
+ * Return: None
+ */
+static void
+cm_roam_scan_offload_scan_period(uint8_t vdev_id,
+				 struct wlan_roam_scan_period_params *params,
+				 struct rso_config *rso_cfg)
+{
+	struct rso_cfg_params *cfg_params;
+
+	cfg_params = &rso_cfg->cfg_param;
+
+	params->vdev_id = vdev_id;
+	params->empty_scan_refresh_period =
+				cfg_params->empty_scan_refresh_period;
+	params->scan_period = params->empty_scan_refresh_period;
+	params->scan_age = (3 * params->empty_scan_refresh_period);
+	params->roam_scan_inactivity_time =
+				cfg_params->roam_scan_inactivity_time;
+	params->roam_inactive_data_packet_count =
+			cfg_params->roam_inactive_data_packet_count;
+	params->roam_scan_period_after_inactivity =
+			cfg_params->roam_scan_period_after_inactivity;
+	params->full_scan_period =
+			cfg_params->full_roam_scan_period;
+}
+
 /**
  * cm_roam_start_req() - roam start request handling
  * @psoc: psoc pointer
@@ -415,12 +546,24 @@ cm_roam_start_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 		  uint8_t reason)
 {
 	struct wlan_roam_start_config *start_req;
-	QDF_STATUS status;
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
+	struct rso_config *rso_cfg;
+	struct wlan_objmgr_vdev *vdev;
 
 	start_req = qdf_mem_malloc(sizeof(*start_req));
 	if (!start_req)
 		return QDF_STATUS_E_NOMEM;
 
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
+						    WLAN_MLME_CM_ID);
+	if (!vdev) {
+		mlme_err("vdev object is NULL for vdev %d", vdev_id);
+		goto free_mem;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		goto rel_vdev_ref;
+
 	cm_roam_set_roam_reason_better_ap(psoc, vdev_id, false);
 	/* fill from mlme directly */
 	cm_roam_scan_bmiss_cnt(psoc, vdev_id, &start_req->beacon_miss_cnt);
@@ -432,6 +575,11 @@ cm_roam_start_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	cm_roam_bss_load_config(psoc, vdev_id, &start_req->bss_load_config);
 	cm_roam_disconnect_params(psoc, vdev_id, &start_req->disconnect_params);
 	cm_roam_idle_params(psoc, vdev_id, &start_req->idle_params);
+	cm_roam_scan_offload_rssi_thresh(psoc, vdev_id,
+					 &start_req->rssi_params, rso_cfg);
+	cm_roam_scan_offload_scan_period(vdev_id,
+					 &start_req->scan_period_params,
+					 rso_cfg);
 
 	/* fill from legacy through this API */
 	wlan_cm_roam_fill_start_req(psoc, vdev_id, start_req, reason);
@@ -440,6 +588,9 @@ cm_roam_start_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	if (QDF_IS_STATUS_ERROR(status))
 		mlme_debug("fail to send roam start");
 
+rel_vdev_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+free_mem:
 	qdf_mem_free(start_req);
 
 	return status;
@@ -458,7 +609,9 @@ cm_roam_update_config_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 			  uint8_t reason)
 {
 	struct wlan_roam_update_config *update_req;
-	QDF_STATUS status;
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
+	struct rso_config *rso_cfg;
+	struct wlan_objmgr_vdev *vdev;
 
 	cm_roam_set_roam_reason_better_ap(psoc, vdev_id, false);
 
@@ -466,6 +619,16 @@ cm_roam_update_config_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	if (!update_req)
 		return QDF_STATUS_E_NOMEM;
 
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
+						    WLAN_MLME_CM_ID);
+	if (!vdev) {
+		mlme_err("vdev object is NULL for vdev %d", vdev_id);
+		goto free_mem;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		goto rel_vdev_ref;
+
 	/* fill from mlme directly */
 	cm_roam_scan_bmiss_cnt(psoc, vdev_id, &update_req->beacon_miss_cnt);
 	cm_roam_fill_rssi_change_params(psoc, vdev_id,
@@ -478,6 +641,11 @@ cm_roam_update_config_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 		cm_roam_triggers(psoc, vdev_id,
 				 &update_req->roam_triggers);
 	}
+	cm_roam_scan_offload_rssi_thresh(psoc, vdev_id,
+					 &update_req->rssi_params, rso_cfg);
+	cm_roam_scan_offload_scan_period(vdev_id,
+					 &update_req->scan_period_params,
+					 rso_cfg);
 
 	/* fill from legacy through this API */
 	wlan_cm_roam_fill_update_config_req(psoc, vdev_id, update_req, reason);
@@ -486,6 +654,9 @@ cm_roam_update_config_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	if (QDF_IS_STATUS_ERROR(status))
 		mlme_debug("fail to send update config");
 
+rel_vdev_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+free_mem:
 	qdf_mem_free(update_req);
 
 	return status;

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

@@ -28,6 +28,8 @@
 #include <wlan_cm_public_struct.h>
 #include "scheduler_api.h"
 #include "connection_mgr/core/src/wlan_cm_main.h"
+#include "connection_mgr/core/src/wlan_cm_main_api.h"
+#include <wlan_cm_roam_api.h>
 
 /**
  * struct cm_vdev_join_req - connect req from legacy CM to vdev manager
@@ -105,21 +107,12 @@ struct cm_peer_create_req {
 	struct qdf_mac_addr peer_mac;
 };
 
-/**
- * struct cm_connect_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
- */
-struct cm_connect_config {
-	uint8_t rsn_cap;
-};
-
 /**
  * struct cm_ext_obj - Connection manager legacy object
- * @connect_config: connect info to be used in RSO.
+ * @rso_cfg: connect info to be used in RSO.
  */
 struct cm_ext_obj {
-	struct cm_connect_config connect_config;
+	struct rso_config rso_cfg;
 };
 
 static inline QDF_STATUS cm_ext_hdl_create(struct cnx_mgr *cm_ctx)
@@ -128,11 +121,14 @@ static inline QDF_STATUS cm_ext_hdl_create(struct cnx_mgr *cm_ctx)
 	if (!cm_ctx->ext_cm_ptr)
 		return QDF_STATUS_E_NOMEM;
 
+	wlan_cm_rso_config_init(cm_ctx->vdev);
+
 	return QDF_STATUS_SUCCESS;
 }
 
 static inline QDF_STATUS cm_ext_hdl_destroy(struct cnx_mgr *cm_ctx)
 {
+	wlan_cm_rso_config_deinit(cm_ctx->vdev);
 	qdf_mem_free(cm_ctx->ext_cm_ptr);
 
 	return QDF_STATUS_SUCCESS;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-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 above
@@ -327,6 +327,41 @@ wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 			   enum roam_cfg_param roam_cfg_type,
 			   struct cm_roam_values_copy *src_config);
 
+/**
+ * wlan_cm_get_rso_config  - get per vdev RSO config
+ * @vdev: vdev pointer
+ *
+ * Return: rso config pointer
+ */
+struct rso_config *wlan_cm_get_rso_config(struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_cm_set_disable_hi_rssi  - set disable hi rssi config
+ * @pdev: pdev pointer
+ * @vdev_id: vdev id
+ * @value: value to set
+ *
+ * Return: void
+ */
+void wlan_cm_set_disable_hi_rssi(struct wlan_objmgr_pdev *pdev,
+				 uint8_t vdev_id, bool value);
+
+/**
+ * wlan_cm_rso_config_init  - initialize RSO config
+ * @vdev: vdev pointer
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_cm_rso_config_init(struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_cm_rso_config_deinit  - deinit RSO config
+ * @vdev: vdev pointer
+ *
+ * Return: void
+ */
+void wlan_cm_rso_config_deinit(struct wlan_objmgr_vdev *vdev);
+
 #ifdef WLAN_FEATURE_FILS_SK
 /**
  * wlan_cm_get_fils_connection_info  - Copy fils connection information from

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-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 above
@@ -97,17 +97,137 @@
 #define DEFAULT_ROAM_SCAN_SCHEME_BITMAP 0
 #define ROAM_MAX_CFG_VALUE 0xffffffff
 
+/**
+ * struct rso_chan_info - chan info
+ * @num_chan: number of channels
+ * @freq_list: freq list
+ */
+struct rso_chan_info {
+	uint8_t num_chan;
+	qdf_freq_t *freq_list;
+};
+
+/**
+ * struct rso_cfg_params - per vdev rso cfg
+ */
+struct rso_cfg_params {
+	uint32_t neighbor_scan_period;
+	uint32_t neighbor_scan_min_period;
+	struct rso_chan_info specific_chan_info;
+	uint8_t neighbor_lookup_threshold;
+	int8_t rssi_thresh_offset_5g;
+	uint32_t min_chan_scan_time;
+	uint32_t max_chan_scan_time;
+	uint16_t neighbor_results_refresh_period;
+	uint16_t empty_scan_refresh_period;
+	uint8_t opportunistic_threshold_diff;
+	uint8_t roam_rescan_rssi_diff;
+	uint8_t roam_bmiss_first_bcn_cnt;
+	uint8_t roam_bmiss_final_cnt;
+	uint32_t hi_rssi_scan_max_count;
+	uint32_t hi_rssi_scan_rssi_delta;
+	uint32_t hi_rssi_scan_delay;
+	int32_t hi_rssi_scan_rssi_ub;
+	struct rso_chan_info pref_chan_info;
+	uint32_t full_roam_scan_period;
+	bool enable_scoring_for_roam;
+	uint8_t roam_rssi_diff;
+	uint8_t bg_rssi_threshold;
+	uint16_t roam_scan_home_away_time;
+	uint8_t roam_scan_n_probes;
+	uint32_t roam_scan_inactivity_time;
+	uint32_t roam_inactive_data_packet_count;
+	uint32_t roam_scan_period_after_inactivity;
+};
+
+/**
+ * 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
+ *			 driver/firmware successfully. The same shall be
+ *			 returned to userspace whenever queried for roam
+ *			 control config status.
+ * @rescan_rssi_delta: Roam scan rssi delta. Start new rssi triggered scan only
+ * if it changes by rescan_rssi_delta value.
+ * @beacon_rssi_weight: Number of beacons to be used to calculate the average
+ * rssi of the AP.
+ * @hi_rssi_scan_delay: Roam scan delay in ms for High RSSI roam trigger.
+ * @roam_scan_scheme_bitmap: Bitmap of roam triggers for which partial channel
+ * map scan scheme needs to be enabled. Each bit in the bitmap corresponds to
+ * the bit position in the order provided by the enum roam_trigger_reason
+ * Ex: roam_scan_scheme_bitmap - 0x00110 will enable partial scan for below
+ * triggers:
+ * ROAM_TRIGGER_REASON_PER, ROAM_TRIGGER_REASON_BMISS
+ * @cfg_param: per vdev config params
+ */
+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;
+	uint32_t hi_rssi_scan_delay;
+	uint32_t roam_scan_scheme_bitmap;
+	struct rso_cfg_params cfg_param;
+};
+
+/**
+ * struct rso_params - global RSO params
+ * @good_rssi_roam: Lazy Roam
+ * @alert_rssi_threshold: Alert RSSI
+ */
+struct rso_config_params {
+	int good_rssi_roam;
+	int alert_rssi_threshold;
+};
+
 /**
  * enum roam_cfg_param  - Type values for roaming parameters used as index
  * for get/set of roaming config values(pNeighborRoamInfo in legacy)
  * @RSSI_CHANGE_THRESHOLD: Rssi change threshold
  * @BEACON_RSSI_WEIGHT: Beacon Rssi weight parameter
  * @HI_RSSI_DELAY_BTW_SCANS: High Rssi delay between scans
+ * @EMPTY_SCAN_REFRESH_PERIOD: empty scan refresh period
+ * @FULL_ROAM_SCAN_PERIOD: Full roam scan period
+ * @ENABLE_SCORING_FOR_ROAM: enable scoring
+ * @SCAN_MIN_CHAN_TIME: scan min chan time
+ * @SCAN_MAX_CHAN_TIME: scan max chan time
+ * @NEIGHBOR_SCAN_PERIOD: neighbour scan period
+ * @ROAM_CONFIG_ENABLE: Roam config enable
+ * @ROAM_PREFERRED_CHAN: preferred channel list
+ * @ROAM_SPECIFIC_CHAN: spedific channel list
+ * @ROAM_RSSI_DIFF: rssi diff
+ * @NEIGHBOUR_LOOKUP_THRESHOLD: lookup threshold
+ * @SCAN_N_PROBE: scan n probe
+ * @SCAN_HOME_AWAY: scan and away
+ * @NEIGHBOUR_SCAN_REFRESH_PERIOD: scan refresh
+ * @ROAM_CONTROL_ENABLE: roam control enable
  */
 enum roam_cfg_param {
 	RSSI_CHANGE_THRESHOLD,
 	BEACON_RSSI_WEIGHT,
 	HI_RSSI_DELAY_BTW_SCANS,
+	EMPTY_SCAN_REFRESH_PERIOD,
+	FULL_ROAM_SCAN_PERIOD,
+	ENABLE_SCORING_FOR_ROAM,
+	SCAN_MIN_CHAN_TIME,
+	SCAN_MAX_CHAN_TIME,
+	NEIGHBOR_SCAN_PERIOD,
+	ROAM_CONFIG_ENABLE,
+	ROAM_PREFERRED_CHAN,
+	ROAM_SPECIFIC_CHAN,
+	ROAM_RSSI_DIFF,
+	NEIGHBOUR_LOOKUP_THRESHOLD,
+	SCAN_N_PROBE,
+	SCAN_HOME_AWAY,
+	NEIGHBOUR_SCAN_REFRESH_PERIOD,
+	ROAM_CONTROL_ENABLE,
 };
 
 /**
@@ -1324,41 +1444,16 @@ enum roam_scan_freq_scheme {
 	ROAM_SCAN_FREQ_SCHEME_FULL_SCAN = 2,
 };
 
-/**
- * struct wlan_cm_rso_configs  - Roam scan offload related per vdev
- * configuration parameters.
- * @rescan_rssi_delta: Roam scan rssi delta. Start new rssi triggered scan only
- * if it changes by rescan_rssi_delta value.
- * @beacon_rssi_weight: Number of beacons to be used to calculate the average
- * rssi of the AP.
- * @hi_rssi_scan_delay: Roam scan delay in ms for High RSSI roam trigger.
- * @roam_scan_scheme_bitmap: Bitmap of roam triggers for which partial channel
- * map scan scheme needs to be enabled. Each bit in the bitmap corresponds to
- * the bit position in the order provided by the enum roam_trigger_reason
- * Ex: roam_scan_scheme_bitmap - 0x00110 will enable partial scan for below
- * triggers:
- * ROAM_TRIGGER_REASON_PER, ROAM_TRIGGER_REASON_BMISS
- */
-struct wlan_cm_rso_configs {
-	uint8_t rescan_rssi_delta;
-	uint8_t beacon_rssi_weight;
-	uint32_t hi_rssi_scan_delay;
-	uint32_t roam_scan_scheme_bitmap;
-};
-
 /**
  * struct wlan_cm_roam  - Connection manager roam configs, state and roam
  * data related structure
  * @pcl_vdev_cmd_active:  Flag to check if vdev level pcl command needs to be
  * sent or PDEV level PCL command needs to be sent
  * @control_param: vendor configured roam control param
- * @vdev_rso_config: Roam scan offload related configurations. Equivalent to the
- * legacy tpCsrNeighborRoamControlInfo structure.
  */
 struct wlan_cm_roam {
 	bool pcl_vdev_cmd_active;
 	struct wlan_cm_roam_vendor_btm_params vendor_btm_param;
-	struct wlan_cm_rso_configs vdev_rso_config;
 };
 
 /**
@@ -1366,11 +1461,12 @@ struct wlan_cm_roam {
  * @uint_value: Unsigned integer value to be copied
  * @int_value: Integer value
  * @bool_value: boolean value
+ * @chan_info: chan info
  */
 struct cm_roam_values_copy {
 	uint32_t uint_value;
 	int32_t int_value;
 	bool bool_value;
-
+	struct rso_chan_info chan_info;
 };
 #endif

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-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 above
@@ -25,6 +25,7 @@
 #include "wlan_mlme_main.h"
 #include "wlan_policy_mgr_api.h"
 #include <wmi_unified_priv.h>
+#include <../../core/src/wlan_cm_vdev_api.h>
 
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
 QDF_STATUS
@@ -482,9 +483,14 @@ QDF_STATUS wlan_cm_roam_cfg_get_value(struct wlan_objmgr_psoc *psoc,
 				      struct cm_roam_values_copy *dst_config)
 {
 	struct wlan_objmgr_vdev *vdev;
-	struct mlme_legacy_priv *mlme_priv;
-	struct wlan_cm_rso_configs *src_config;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *src_cfg;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return QDF_STATUS_E_FAILURE;
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_MLME_NB_ID);
@@ -493,23 +499,55 @@ QDF_STATUS wlan_cm_roam_cfg_get_value(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
-	if (!mlme_priv) {
-		mlme_err("vdev legacy private object is NULL");
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
 		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 		return QDF_STATUS_E_FAILURE;
 	}
-
-	src_config = &mlme_priv->cm_roam.vdev_rso_config;
+	src_cfg = &rso_cfg->cfg_param;
 	switch (roam_cfg_type) {
 	case RSSI_CHANGE_THRESHOLD:
-		dst_config->int_value = src_config->rescan_rssi_delta;
+		dst_config->int_value = rso_cfg->rescan_rssi_delta;
 		break;
 	case BEACON_RSSI_WEIGHT:
-		dst_config->uint_value = src_config->beacon_rssi_weight;
+		dst_config->uint_value = rso_cfg->beacon_rssi_weight;
 		break;
 	case HI_RSSI_DELAY_BTW_SCANS:
-		dst_config->uint_value = src_config->hi_rssi_scan_delay;
+		dst_config->uint_value = rso_cfg->hi_rssi_scan_delay;
+		break;
+	case EMPTY_SCAN_REFRESH_PERIOD:
+		dst_config->uint_value = src_cfg->empty_scan_refresh_period;
+		break;
+	case SCAN_MIN_CHAN_TIME:
+		dst_config->uint_value = src_cfg->min_chan_scan_time;
+		break;
+	case SCAN_MAX_CHAN_TIME:
+		dst_config->uint_value = src_cfg->max_chan_scan_time;
+		break;
+	case NEIGHBOR_SCAN_PERIOD:
+		dst_config->uint_value = src_cfg->neighbor_scan_period;
+		break;
+	case FULL_ROAM_SCAN_PERIOD:
+		dst_config->uint_value = src_cfg->full_roam_scan_period;
+		break;
+	case ROAM_RSSI_DIFF:
+		dst_config->uint_value = src_cfg->roam_rssi_diff;
+		break;
+	case NEIGHBOUR_LOOKUP_THRESHOLD:
+		dst_config->uint_value = src_cfg->neighbor_lookup_threshold;
+		break;
+	case SCAN_N_PROBE:
+		dst_config->uint_value = src_cfg->roam_scan_n_probes;
+		break;
+	case SCAN_HOME_AWAY:
+		dst_config->uint_value = src_cfg->roam_scan_home_away_time;
+		break;
+	case NEIGHBOUR_SCAN_REFRESH_PERIOD:
+		dst_config->uint_value =
+				src_cfg->neighbor_results_refresh_period;
+		break;
+	case ROAM_CONTROL_ENABLE:
+		dst_config->bool_value = rso_cfg->roam_control_enable;
 		break;
 	default:
 		mlme_err("Invalid roam config requested:%d", roam_cfg_type);
@@ -522,15 +560,164 @@ QDF_STATUS wlan_cm_roam_cfg_get_value(struct wlan_objmgr_psoc *psoc,
 	return status;
 }
 
+void wlan_cm_set_disable_hi_rssi(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->disable_hi_rssi = value;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_CM_ID);
+}
+
+static QDF_STATUS
+cm_roam_update_cfg(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
+		   uint8_t reason)
+{
+	QDF_STATUS status;
+
+	status = cm_roam_acquire_lock();
+	if (QDF_IS_STATUS_ERROR(status))
+		return status;
+	if (!MLME_IS_ROAM_STATE_RSO_ENABLED(psoc, vdev_id)) {
+		mlme_debug("Update cfg received while ROAM RSO not started");
+		cm_roam_release_lock();
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = cm_roam_send_rso_cmd(psoc, vdev_id,
+				      ROAM_SCAN_OFFLOAD_UPDATE_CFG, reason);
+	cm_roam_release_lock();
+
+	return status;
+}
+
+static void cm_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;
+		}
+	}
+
+	mlme_debug("frequency list [%u]: %s", i, channel_list);
+	qdf_mem_free(channel_list);
+}
+
+static uint8_t
+cm_append_pref_chan_list(struct rso_chan_info *chan_info, qdf_freq_t *freq_list,
+			 uint8_t num_chan)
+{
+	uint8_t i = 0, j = 0;
+
+	for (i = 0; i < chan_info->num_chan; i++) {
+		for (j = 0; j < num_chan; j++)
+			if (chan_info->freq_list[i] == freq_list[j])
+				break;
+
+		if (j < num_chan)
+			continue;
+		if (num_chan == ROAM_MAX_CHANNELS)
+			break;
+		freq_list[num_chan++] = chan_info->freq_list[i];
+	}
+
+	return num_chan;
+}
+
+static QDF_STATUS cm_create_bg_scan_roam_channel_list(struct rso_chan_info *chan_info,
+						const qdf_freq_t *chan_freq_lst,
+						const uint8_t num_chan)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	uint8_t i;
+
+	chan_info->freq_list = qdf_mem_malloc(sizeof(qdf_freq_t) * num_chan);
+	if (!chan_info->freq_list)
+		return QDF_STATUS_E_NOMEM;
+
+	chan_info->num_chan = num_chan;
+	for (i = 0; i < num_chan; i++)
+		chan_info->freq_list[i] = chan_freq_lst[i];
+
+	return status;
+}
+
+static void cm_flush_roam_channel_list(struct rso_chan_info *channel_info)
+{
+	/* Free up the memory first (if required) */
+	if (channel_info->freq_list) {
+		qdf_mem_free(channel_info->freq_list);
+		channel_info->freq_list = NULL;
+		channel_info->num_chan = 0;
+	}
+}
+
+static QDF_STATUS
+cm_update_roam_scan_channel_list(uint8_t vdev_id,
+				 struct rso_chan_info *chan_info,
+				 qdf_freq_t *freq_list, uint8_t num_chan,
+				 bool update_preferred_chan)
+{
+	uint16_t pref_chan_cnt = 0;
+
+	if (chan_info->num_chan) {
+		mlme_debug("Current channels:");
+		cm_dump_freq_list(chan_info);
+	}
+
+	if (update_preferred_chan) {
+		pref_chan_cnt = cm_append_pref_chan_list(chan_info, freq_list,
+							 num_chan);
+		num_chan = pref_chan_cnt;
+	}
+	cm_flush_roam_channel_list(chan_info);
+	cm_create_bg_scan_roam_channel_list(chan_info, freq_list, num_chan);
+
+	mlme_debug("New channels:");
+	cm_dump_freq_list(chan_info);
+
+	return QDF_STATUS_SUCCESS;
+}
+
 QDF_STATUS
 wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 			   enum roam_cfg_param roam_cfg_type,
 			   struct cm_roam_values_copy *src_config)
 {
 	struct wlan_objmgr_vdev *vdev;
-	struct mlme_legacy_priv *mlme_priv;
-	struct wlan_cm_rso_configs *dst_config;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *dst_cfg;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return QDF_STATUS_E_FAILURE;
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_MLME_NB_ID);
@@ -539,23 +726,127 @@ wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
-	if (!mlme_priv) {
-		mlme_err("vdev legacy private object is NULL");
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
 		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 		return QDF_STATUS_E_FAILURE;
 	}
-
-	dst_config = &mlme_priv->cm_roam.vdev_rso_config;
+	dst_cfg = &rso_cfg->cfg_param;
+	mlme_debug("roam_cfg_type %d, uint val %d int val %d bool val %d num chan %d",
+		   roam_cfg_type, src_config->uint_value, src_config->int_value,
+		   src_config->bool_value, src_config->chan_info.num_chan);
 	switch (roam_cfg_type) {
 	case RSSI_CHANGE_THRESHOLD:
-		dst_config->rescan_rssi_delta  = src_config->uint_value;
+		rso_cfg->rescan_rssi_delta  = src_config->uint_value;
 		break;
 	case BEACON_RSSI_WEIGHT:
-		dst_config->beacon_rssi_weight = src_config->uint_value;
+		rso_cfg->beacon_rssi_weight = src_config->uint_value;
 		break;
 	case HI_RSSI_DELAY_BTW_SCANS:
-		dst_config->hi_rssi_scan_delay = src_config->uint_value;
+		rso_cfg->hi_rssi_scan_delay = src_config->uint_value;
+		break;
+	case EMPTY_SCAN_REFRESH_PERIOD:
+		dst_cfg->empty_scan_refresh_period = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					  REASON_EMPTY_SCAN_REF_PERIOD_CHANGED);
+		break;
+	case FULL_ROAM_SCAN_PERIOD:
+		dst_cfg->full_roam_scan_period = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					  REASON_ROAM_FULL_SCAN_PERIOD_CHANGED);
+		break;
+	case ENABLE_SCORING_FOR_ROAM:
+		dst_cfg->enable_scoring_for_roam = src_config->bool_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_SCORING_CRITERIA_CHANGED);
+		break;
+	case SCAN_MIN_CHAN_TIME:
+		mlme_obj->cfg.lfr.neighbor_scan_min_chan_time =
+							src_config->uint_value;
+		dst_cfg->min_chan_scan_time = src_config->uint_value;
+		break;
+	case SCAN_MAX_CHAN_TIME:
+		dst_cfg->max_chan_scan_time = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_SCAN_CH_TIME_CHANGED);
+		break;
+	case NEIGHBOR_SCAN_PERIOD:
+		dst_cfg->neighbor_scan_period = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_SCAN_HOME_TIME_CHANGED);
+		break;
+	case ROAM_CONFIG_ENABLE:
+		rso_cfg->roam_control_enable = src_config->bool_value;
+		if (!rso_cfg->roam_control_enable)
+			break;
+		dst_cfg->roam_scan_period_after_inactivity = 0;
+		dst_cfg->roam_inactive_data_packet_count = 0;
+		dst_cfg->roam_scan_inactivity_time = 0;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_ROAM_CONTROL_CONFIG_ENABLED);
+		break;
+	case ROAM_PREFERRED_CHAN:
+		if (dst_cfg->specific_chan_info.num_chan) {
+			mlme_err("Specific channel list is already configured");
+			break;
+		}
+		status = cm_update_roam_scan_channel_list(vdev_id,
+					&dst_cfg->pref_chan_info,
+					src_config->chan_info.freq_list,
+					src_config->chan_info.num_chan,
+					true);
+		if (QDF_IS_STATUS_ERROR(status))
+			break;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_CHANNEL_LIST_CHANGED);
+		break;
+	case ROAM_SPECIFIC_CHAN:
+		cm_update_roam_scan_channel_list(vdev_id,
+					&dst_cfg->specific_chan_info,
+					src_config->chan_info.freq_list,
+					src_config->chan_info.num_chan,
+					false);
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_CHANNEL_LIST_CHANGED);
+		break;
+	case ROAM_RSSI_DIFF:
+		dst_cfg->roam_rssi_diff = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_RSSI_DIFF_CHANGED);
+		break;
+	case NEIGHBOUR_LOOKUP_THRESHOLD:
+		dst_cfg->neighbor_lookup_threshold = src_config->uint_value;
+		break;
+	case SCAN_N_PROBE:
+		dst_cfg->roam_scan_n_probes = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_NPROBES_CHANGED);
+		break;
+	case SCAN_HOME_AWAY:
+		dst_cfg->roam_scan_home_away_time = src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled &&
+		    src_config->bool_value)
+			cm_roam_update_cfg(psoc, vdev_id,
+					   REASON_HOME_AWAY_TIME_CHANGED);
+		break;
+	case NEIGHBOUR_SCAN_REFRESH_PERIOD:
+		dst_cfg->neighbor_results_refresh_period =
+						src_config->uint_value;
+		mlme_obj->cfg.lfr.neighbor_scan_results_refresh_period =
+				src_config->uint_value;
+		if (mlme_obj->cfg.lfr.roam_scan_offload_enabled)
+			cm_roam_update_cfg(psoc, vdev_id,
+				REASON_NEIGHBOR_SCAN_REFRESH_PERIOD_CHANGED);
 		break;
 	default:
 		mlme_err("Invalid roam config requested:%d", roam_cfg_type);
@@ -568,6 +859,163 @@ wlan_cm_roam_cfg_set_value(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	return status;
 }
 
+static void cm_rso_chan_to_freq_list(struct wlan_objmgr_pdev *pdev,
+				     qdf_freq_t *freq_list,
+				     const uint8_t *chan_list,
+				     uint32_t chan_list_len)
+{
+	uint32_t count;
+
+	for (count = 0; count < chan_list_len; count++)
+		freq_list[count] =
+			wlan_reg_chan_to_freq(pdev, chan_list[count]);
+}
+
+QDF_STATUS wlan_cm_rso_config_init(struct wlan_objmgr_vdev *vdev)
+{
+	struct rso_chan_info *chan_info;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_objmgr_psoc *psoc;
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev)
+		return QDF_STATUS_E_INVAL;
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc)
+		return QDF_STATUS_E_INVAL;
+
+	mlme_obj = mlme_get_psoc_ext_obj(psoc);
+	if (!mlme_obj)
+		return QDF_STATUS_E_INVAL;
+
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		return QDF_STATUS_E_INVAL;
+	cfg_params = &rso_cfg->cfg_param;
+	cfg_params->max_chan_scan_time =
+		mlme_obj->cfg.lfr.neighbor_scan_max_chan_time;
+	cfg_params->min_chan_scan_time =
+		mlme_obj->cfg.lfr.neighbor_scan_min_chan_time;
+	cfg_params->neighbor_lookup_threshold =
+		mlme_obj->cfg.lfr.neighbor_lookup_rssi_threshold;
+	cfg_params->rssi_thresh_offset_5g =
+		mlme_obj->cfg.lfr.rssi_threshold_offset_5g;
+	cfg_params->opportunistic_threshold_diff =
+		mlme_obj->cfg.lfr.opportunistic_scan_threshold_diff;
+	cfg_params->roam_rescan_rssi_diff =
+		mlme_obj->cfg.lfr.roam_rescan_rssi_diff;
+
+	cfg_params->roam_bmiss_first_bcn_cnt =
+		mlme_obj->cfg.lfr.roam_bmiss_first_bcnt;
+	cfg_params->roam_bmiss_final_cnt =
+		mlme_obj->cfg.lfr.roam_bmiss_final_bcnt;
+
+	cfg_params->neighbor_scan_period =
+		mlme_obj->cfg.lfr.neighbor_scan_timer_period;
+	cfg_params->neighbor_scan_min_period =
+		mlme_obj->cfg.lfr.neighbor_scan_min_timer_period;
+	cfg_params->neighbor_results_refresh_period =
+		mlme_obj->cfg.lfr.neighbor_scan_results_refresh_period;
+	cfg_params->empty_scan_refresh_period =
+		mlme_obj->cfg.lfr.empty_scan_refresh_period;
+	cfg_params->full_roam_scan_period =
+		mlme_obj->cfg.lfr.roam_full_scan_period;
+	cfg_params->enable_scoring_for_roam =
+		mlme_obj->cfg.roam_scoring.enable_scoring_for_roam;
+	cfg_params->roam_scan_n_probes =
+		mlme_obj->cfg.lfr.roam_scan_n_probes;
+	cfg_params->roam_scan_home_away_time =
+		mlme_obj->cfg.lfr.roam_scan_home_away_time;
+	cfg_params->roam_scan_inactivity_time =
+		mlme_obj->cfg.lfr.roam_scan_inactivity_time;
+	cfg_params->roam_inactive_data_packet_count =
+		mlme_obj->cfg.lfr.roam_inactive_data_packet_count;
+	cfg_params->roam_scan_period_after_inactivity =
+		mlme_obj->cfg.lfr.roam_scan_period_after_inactivity;
+
+	chan_info = &cfg_params->specific_chan_info;
+	chan_info->num_chan =
+		mlme_obj->cfg.lfr.neighbor_scan_channel_list_num;
+	mlme_debug("number of channels: %u", chan_info->num_chan);
+	if (chan_info->num_chan) {
+		chan_info->freq_list =
+			qdf_mem_malloc(sizeof(qdf_freq_t) *
+				       chan_info->num_chan);
+		if (!chan_info->freq_list) {
+			chan_info->num_chan = 0;
+			return QDF_STATUS_E_NOMEM;
+		}
+		/* Update the roam global structure from CFG */
+		cm_rso_chan_to_freq_list(pdev, chan_info->freq_list,
+			mlme_obj->cfg.lfr.neighbor_scan_channel_list,
+			mlme_obj->cfg.lfr.neighbor_scan_channel_list_num);
+	} else {
+		chan_info->freq_list = NULL;
+	}
+
+	cfg_params->hi_rssi_scan_max_count =
+		mlme_obj->cfg.lfr.roam_scan_hi_rssi_maxcount;
+	cfg_params->hi_rssi_scan_rssi_delta =
+		mlme_obj->cfg.lfr.roam_scan_hi_rssi_delta;
+
+	cfg_params->hi_rssi_scan_delay =
+		mlme_obj->cfg.lfr.roam_scan_hi_rssi_delay;
+
+	cfg_params->hi_rssi_scan_rssi_ub =
+		mlme_obj->cfg.lfr.roam_scan_hi_rssi_ub;
+	cfg_params->roam_rssi_diff =
+		mlme_obj->cfg.lfr.roam_rssi_diff;
+	cfg_params->bg_rssi_threshold =
+		mlme_obj->cfg.lfr.bg_rssi_threshold;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+void wlan_cm_rso_config_deinit(struct wlan_objmgr_vdev *vdev)
+{
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
+
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		return;
+
+	cfg_params = &rso_cfg->cfg_param;
+
+	cm_flush_roam_channel_list(&cfg_params->specific_chan_info);
+	cm_flush_roam_channel_list(&cfg_params->pref_chan_info);
+}
+
+#ifdef FEATURE_CM_ENABLE
+struct rso_config *wlan_cm_get_rso_config(struct wlan_objmgr_vdev *vdev)
+{
+	struct cm_ext_obj *cm_ext_obj;
+
+	cm_ext_obj = cm_get_ext_hdl(vdev);
+	if (!cm_ext_obj)
+		return NULL;
+
+	return &cm_ext_obj->rso_cfg;
+}
+#else
+struct rso_config *wlan_cm_get_rso_config(struct wlan_objmgr_vdev *vdev)
+{
+	struct mlme_legacy_priv *mlme_priv;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv) {
+		mlme_err("vdev legacy private object is NULL");
+		return NULL;
+	}
+
+	return &mlme_priv->rso_cfg;
+}
+#endif
+
 #ifdef WLAN_FEATURE_FILS_SK
 QDF_STATUS wlan_cm_update_mlme_fils_connection_info(
 		struct wlan_objmgr_psoc *psoc,
@@ -688,7 +1136,7 @@ wlan_cm_update_roam_scan_scheme_bitmap(struct wlan_objmgr_psoc *psoc,
 				       uint32_t roam_scan_scheme_bitmap)
 {
 	struct wlan_objmgr_vdev *vdev;
-	struct mlme_legacy_priv *mlme_priv;
+	struct rso_config *rso_cfg;
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_MLME_NB_ID);
@@ -698,15 +1146,12 @@ wlan_cm_update_roam_scan_scheme_bitmap(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
-	if (!mlme_priv) {
-		mlme_err("vdev%d: vdev legacy private object is NULL", vdev_id);
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
 		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 		return QDF_STATUS_E_FAILURE;
 	}
-
-	mlme_priv->cm_roam.vdev_rso_config.roam_scan_scheme_bitmap =
-						roam_scan_scheme_bitmap;
+	rso_cfg->roam_scan_scheme_bitmap = roam_scan_scheme_bitmap;
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 
 	return QDF_STATUS_SUCCESS;
@@ -716,8 +1161,8 @@ uint32_t wlan_cm_get_roam_scan_scheme_bitmap(struct wlan_objmgr_psoc *psoc,
 					     uint8_t vdev_id)
 {
 	struct wlan_objmgr_vdev *vdev;
-	struct mlme_legacy_priv *mlme_priv;
 	uint32_t roam_scan_scheme_bitmap;
+	struct rso_config *rso_cfg;
 
 	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
 						    WLAN_MLME_NB_ID);
@@ -727,15 +1172,13 @@ uint32_t wlan_cm_get_roam_scan_scheme_bitmap(struct wlan_objmgr_psoc *psoc,
 		return 0;
 	}
 
-	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
-	if (!mlme_priv) {
-		mlme_err("vdev%d: vdev legacy private object is NULL", vdev_id);
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
 		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 		return 0;
 	}
 
-	roam_scan_scheme_bitmap =
-		mlme_priv->cm_roam.vdev_rso_config.roam_scan_scheme_bitmap;
+	roam_scan_scheme_bitmap = rso_cfg->roam_scan_scheme_bitmap;
 
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_NB_ID);
 

core/mac/inc/sir_api.h

@@ -1826,7 +1826,6 @@ typedef struct sSirSmeProbeReqInd {
 	tSirWPSPBCProbeReq WPSPBCProbeReq;
 } tSirSmeProbeReqInd, *tpSirSmeProbeReqInd;
 
-#define SIR_ROAM_MAX_CHANNELS            80
 #define SIR_ROAM_SCAN_MAX_PB_REQ_SIZE    450
 /* Occupied channel list remains static */
 #define CHANNEL_LIST_STATIC                   1
@@ -1982,7 +1981,7 @@ typedef struct {
 	uint8_t mcencryption;
 	tAniEdType gp_mgmt_cipher_suite;
 	uint8_t ChannelCount;
-	uint32_t chan_freq_cache[SIR_ROAM_MAX_CHANNELS];
+	uint32_t chan_freq_cache[ROAM_MAX_CHANNELS];
 #ifdef WLAN_FEATURE_11W
 	bool mfp_enabled;
 #endif
@@ -4434,7 +4433,7 @@ struct obss_ht40_scanind {
 	uint8_t bss_id;
 	uint8_t fortymhz_intolerent;
 	uint8_t channel_count;
-	uint32_t chan_freq_list[SIR_ROAM_MAX_CHANNELS];
+	uint32_t chan_freq_list[ROAM_MAX_CHANNELS];
 	uint8_t current_operatingclass;
 	uint16_t iefield_len;
 	uint8_t  iefield[SIR_ROAM_SCAN_MAX_PB_REQ_SIZE];

core/mac/src/pe/lim/lim_send_messages.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-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
@@ -511,7 +511,7 @@ QDF_STATUS lim_send_ht40_obss_scanind(struct mac_context *mac_ctx,
 	/* Extract 24G channel list */
 	channel24gnum = 0;
 	for (count = 0; count < channelnum &&
-		(channel24gnum < SIR_ROAM_MAX_CHANNELS); count++) {
+		(channel24gnum < ROAM_MAX_CHANNELS); count++) {
 		chan_freq =
 			mac_ctx->mlme_cfg->reg.valid_channel_freq_list[count];
 		if (wlan_reg_is_24ghz_ch_freq(chan_freq)) {

core/sme/inc/csr_api.h

@@ -850,7 +850,6 @@ struct csr_neighbor_report_offload_params {
 struct csr_config_params {
 	/* keep this uint32_t. This gets converted to ePhyChannelBondState */
 	uint32_t channelBondingMode24GHz;
-	uint8_t nud_fail_behaviour;
 	uint32_t channelBondingMode5GHz;
 	eCsrPhyMode phyMode;
 	uint32_t HeartbeatThresh50;
@@ -875,11 +874,6 @@ struct csr_config_params {
 	 */
 	uint8_t fAllowMCCGODiffBI;
 	tCsr11dinfo Csr11dinfo;
-#ifdef FEATURE_WLAN_ESE
-	uint8_t isEseIniFeatureEnabled;
-#endif
-	uint8_t isFastRoamIniFeatureEnabled;
-	struct mawc_params csr_mawc_config;
 	/*
 	 * Customer wants to optimize the scan time. Avoiding scans(passive)
 	 * on DFS channels while swipping through both bands can save some time
@@ -891,7 +885,6 @@ struct csr_config_params {
 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
 	uint8_t cc_switch_mode;
 #endif
-	uint8_t allowDFSChannelRoam;
 	bool obssEnabled;
 	uint8_t conc_custom_rule1;
 	uint8_t conc_custom_rule2;
@@ -902,13 +895,6 @@ struct csr_config_params {
 #ifdef FEATURE_AP_MCC_CH_AVOIDANCE
 	bool sap_channel_avoidance;
 #endif /* FEATURE_AP_MCC_CH_AVOIDANCE */
-	uint32_t roam_dense_rssi_thresh_offset;
-	uint32_t roam_dense_min_aps;
-	int8_t roam_bg_scan_bad_rssi_thresh;
-	uint8_t roam_bad_rssi_thresh_offset_2g;
-	uint32_t roam_data_rssi_threshold_triggers;
-	int32_t roam_data_rssi_threshold;
-	uint32_t rx_data_inactivity_time;
 	struct csr_sta_roam_policy_params sta_roam_policy_params;
 	enum force_1x1_type is_force_1x1;
 	uint32_t offload_11k_enable_bitmask;

core/sme/inc/csr_internal.h

@@ -602,7 +602,6 @@ struct csr_roam_session {
 	bool supported_nss_1x1;
 	uint8_t vdev_nss;
 	uint8_t nss;
-	bool disable_hi_rssi;
 	bool dhcp_done;
 #ifndef FEATURE_CM_ENABLE
 	enum wlan_reason_code disconnect_reason;
@@ -617,7 +616,6 @@ struct csr_roam_session {
 	bool discon_in_progress;
 	bool is_adaptive_11r_connection;
 	struct csr_disconnect_stats disconnect_stats;
-	qdf_mc_timer_t join_retry_timer;
 };
 
 struct csr_roamstruct {

core/sme/inc/csr_neighbor_roam.h

@@ -42,39 +42,6 @@ typedef enum {
 	eNEIGHBOR_STATE_MAX
 } eCsrNeighborRoamState;
 
-/* Parameters that are obtained from CFG */
-typedef struct sCsrNeighborRoamCfgParams {
-	uint32_t neighborScanPeriod;
-	uint32_t neighbor_scan_min_period;
-	tCsrChannelInfo specific_chan_info;
-	uint8_t neighborLookupThreshold;
-	int8_t rssi_thresh_offset_5g;
-	uint8_t neighborReassocThreshold;
-	uint32_t minChannelScanTime;
-	uint32_t maxChannelScanTime;
-	uint16_t neighborResultsRefreshPeriod;
-	uint16_t emptyScanRefreshPeriod;
-	uint8_t nOpportunisticThresholdDiff;
-	uint8_t nRoamRescanRssiDiff;
-	uint8_t nRoamBmissFirstBcnt;
-	uint8_t nRoamBmissFinalBcnt;
-	uint8_t delay_before_vdev_stop;
-	uint32_t hi_rssi_scan_max_count;
-	uint32_t hi_rssi_scan_rssi_delta;
-	uint32_t hi_rssi_scan_delay;
-	int32_t hi_rssi_scan_rssi_ub;
-	tCsrChannelInfo pref_chan_info;
-	uint32_t full_roam_scan_period;
-	bool enable_scoring_for_roam;
-	uint8_t roam_rssi_diff;
-	uint8_t bg_rssi_threshold;
-	uint16_t roam_scan_home_away_time;
-	uint8_t roam_scan_n_probes;
-	uint32_t roam_scan_inactivity_time;
-	uint32_t roam_inactive_data_packet_count;
-	uint32_t roam_scan_period_after_inactivity;
-} tCsrNeighborRoamCfgParams, *tpCsrNeighborRoamCfgParams;
-
 #define CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX    255
 typedef struct sCsrNeighborRoamChannelInfo {
 	/* Flag to mark reception of IAPP Neighbor list */
@@ -114,23 +81,13 @@ typedef struct sCsr11rAssocNeighborInfo {
 
 /**
  * struct sCsr11rAssocNeighborInfo - Control info for neighbor roam algorithm
- * @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
- *			 driver/firmware successfully. The same shall be
- *			 returned to userspace whenever queried for roam
- *			 control config status.
  */
 typedef struct sCsrNeighborRoamControlInfo {
 	eCsrNeighborRoamState neighborRoamState;
 	eCsrNeighborRoamState prevNeighborRoamState;
-	tCsrNeighborRoamCfgParams cfgParams;
 	struct qdf_mac_addr currAPbssid;  /* current assoc AP */
 	uint32_t curr_ap_op_chan_freq; /* current assoc AP */
 	tCsrNeighborRoamChannelInfo roamChannelInfo;
-	uint8_t currentNeighborLookupThreshold;
-	uint8_t currentOpportunisticThresholdDiff;
-	uint8_t currentRoamRescanRssiDiff;
 	tDblLinkList roamableAPList;    /* List of current FT candidates */
 	struct csr_roam_profile csrNeighborRoamProfile;
 	bool is11rAssoc;
@@ -150,11 +107,8 @@ typedef struct sCsrNeighborRoamControlInfo {
 	uint8_t uOsRequestedHandoff;
 	/* handoff related info came with upper layer's req for reassoc */
 	tCsrHandoffRequest handoffReqInfo;
-	uint8_t currentRoamBmissFirstBcnt;
-	uint8_t currentRoamBmissFinalBcnt;
 	uint8_t last_sent_cmd;
 	struct scan_result_list *scan_res_lfr2_roam_ap;
-	bool roam_control_enable;
 } tCsrNeighborRoamControlInfo, *tpCsrNeighborRoamControlInfo;
 
 /* All the necessary Function declarations are here */

core/sme/inc/sme_api.h

@@ -1207,7 +1207,7 @@ QDF_STATUS sme_get_roam_scan_channel_list(mac_handle_t mac_handle,
  *
  * Return: None
  */
-void sme_dump_freq_list(tCsrChannelInfo *chan_info);
+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);
@@ -4184,12 +4184,6 @@ QDF_STATUS sme_register_bcn_recv_pause_ind_cb(mac_handle_t mac_handle,
 QDF_STATUS sme_set_disconnect_ies(mac_handle_t mac_handle, uint8_t vdev_id,
 				  uint8_t *ie_data, uint16_t ie_len);
 
-void sme_chan_to_freq_list(
-			struct wlan_objmgr_pdev *pdev,
-			uint32_t *freq_list,
-			const uint8_t *chan_list,
-			uint32_t chan_list_len);
-
 /**
  * sme_set_roam_config_enable() - Cache roam config status in SME
  * @mac_handle: Opaque handle to the MAC context

core/sme/inc/sme_inside.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
@@ -190,21 +190,7 @@ QDF_STATUS sme_release_global_lock(struct sme_context *sme);
  *
  * Return: None
  */
-void csr_flush_cfg_bg_scan_roam_channel_list(tCsrChannelInfo *channel_info);
-
-/**
- * csr_create_bg_scan_roam_channel_list() - Create roam scan chan list
- * @mac: global mac context
- * @channel_info: Channel list to be populated for roam scan
- * @chan_freq_list: Channel list to be populated from
- * @num_chan: Number of channels
- *
- * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_FAILURE
- */
-QDF_STATUS csr_create_bg_scan_roam_channel_list(struct mac_context *mac,
-						tCsrChannelInfo *channel_info,
-						const uint32_t *chan_freq_list,
-						const uint8_t num_chan);
+void csr_flush_cfg_bg_scan_roam_channel_list(struct rso_chan_info *channel_info);
 
 #ifdef FEATURE_WLAN_ESE
 QDF_STATUS csr_create_roam_scan_channel_list(struct mac_context *mac,

core/sme/src/csr/csr_api_roam.c

@@ -1232,6 +1232,7 @@ QDF_STATUS csr_start(struct mac_context *mac)
 			break;
 
 		mac->roam.sPendingCommands = 0;
+
 		for (i = 0; i < WLAN_MAX_VDEVS; i++)
 			status = csr_neighbor_roam_init(mac, i);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -1276,8 +1277,8 @@ QDF_STATUS csr_stop(struct mac_context *mac)
 	 */
 	csr_purge_pdev_all_ser_cmd_list(mac);
 	for (sessionId = 0; sessionId < WLAN_MAX_VDEVS; sessionId++)
-		csr_prepare_vdev_delete(mac, sessionId, true);
 
+		csr_prepare_vdev_delete(mac, sessionId, true);
 	for (sessionId = 0; sessionId < WLAN_MAX_VDEVS; sessionId++)
 		csr_neighbor_roam_close(mac, sessionId);
 	for (sessionId = 0; sessionId < WLAN_MAX_VDEVS; sessionId++)
@@ -1732,13 +1733,13 @@ static void init_config_param(struct mac_context *mac)
 		WNI_CFG_VHT_CHANNEL_WIDTH_80MHZ + 1;
 }
 
-void csr_flush_cfg_bg_scan_roam_channel_list(tCsrChannelInfo *channel_info)
+void csr_flush_cfg_bg_scan_roam_channel_list(struct rso_chan_info *channel_info)
 {
 	/* Free up the memory first (if required) */
 	if (channel_info->freq_list) {
 		qdf_mem_free(channel_info->freq_list);
 		channel_info->freq_list = NULL;
-		channel_info->numOfChannels = 0;
+		channel_info->num_chan = 0;
 	}
 }
 
@@ -1754,34 +1755,25 @@ void csr_flush_cfg_bg_scan_roam_channel_list(tCsrChannelInfo *channel_info)
 static void
 csr_flush_roam_scan_chan_lists(struct mac_context *mac, uint8_t vdev_id)
 {
-	tCsrChannelInfo *chan_info;
-
-	chan_info =
-	&mac->roam.neighborRoamInfo[vdev_id].cfgParams.pref_chan_info;
-	csr_flush_cfg_bg_scan_roam_channel_list(chan_info);
-
-	chan_info =
-	&mac->roam.neighborRoamInfo[vdev_id].cfgParams.specific_chan_info;
-	csr_flush_cfg_bg_scan_roam_channel_list(chan_info);
-}
-
-QDF_STATUS csr_create_bg_scan_roam_channel_list(struct mac_context *mac,
-						tCsrChannelInfo *channel_info,
-						const uint32_t *chan_freq_list,
-						const uint8_t num_chan)
-{
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	uint8_t i;
-
-	channel_info->freq_list = qdf_mem_malloc(sizeof(uint32_t) * num_chan);
-	if (!channel_info->freq_list)
-		return QDF_STATUS_E_NOMEM;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
 
-	channel_info->numOfChannels = num_chan;
-	for (i = 0; i < num_chan; i++)
-		channel_info->freq_list[i] = chan_freq_list[i];
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return;
 
-	return status;
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
+	cfg_params = &rso_cfg->cfg_param;
+	csr_flush_cfg_bg_scan_roam_channel_list(&cfg_params->pref_chan_info);
+	csr_flush_cfg_bg_scan_roam_channel_list(
+					&cfg_params->specific_chan_info);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
@@ -2596,20 +2588,6 @@ QDF_STATUS csr_get_config_param(struct mac_context *mac,
 	pParam->wep_tkip_in_he = cfg_params->wep_tkip_in_he;
 	csr_set_channels(mac, pParam);
 	pParam->obssEnabled = cfg_params->obssEnabled;
-	pParam->roam_dense_min_aps =
-			cfg_params->roam_params.dense_min_aps_cnt;
-
-	pParam->roam_bg_scan_bad_rssi_thresh =
-		cfg_params->roam_params.bg_scan_bad_rssi_thresh;
-	pParam->roam_bad_rssi_thresh_offset_2g =
-		cfg_params->roam_params.roam_bad_rssi_thresh_offset_2g;
-	pParam->roam_data_rssi_threshold_triggers =
-		cfg_params->roam_params.roam_data_rssi_threshold_triggers;
-	pParam->roam_data_rssi_threshold =
-		cfg_params->roam_params.roam_data_rssi_threshold;
-	pParam->rx_data_inactivity_time =
-		cfg_params->roam_params.rx_data_inactivity_time;
-
 	pParam->conc_custom_rule1 = cfg_params->conc_custom_rule1;
 	pParam->conc_custom_rule2 = cfg_params->conc_custom_rule2;
 	pParam->is_sta_connection_in_5gz_enabled =
@@ -14727,11 +14705,11 @@ QDF_STATUS csr_send_join_req_msg(struct mac_context *mac, uint32_t sessionId,
 	bss_freq = pBssDescription->chan_freq;
 	if ((eWNI_SME_REASSOC_REQ == messageType) ||
 	    WLAN_REG_IS_5GHZ_CH_FREQ(bss_freq)) {
-		pSession->disable_hi_rssi = true;
+		wlan_cm_set_disable_hi_rssi(mac->pdev, sessionId, true);
 		sme_debug("Disabling HI_RSSI, AP freq=%d, rssi=%d",
 			  pBssDescription->chan_freq, pBssDescription->rssi);
 	} else {
-		pSession->disable_hi_rssi = false;
+		wlan_cm_set_disable_hi_rssi(mac->pdev, sessionId, false);
 	}
 
 	do {
@@ -15938,10 +15916,6 @@ QDF_STATUS csr_setup_vdev_session(struct vdev_mlme_obj *vdev_mlme)
 				   QDF_TIMER_TYPE_SW,
 				   csr_roam_roaming_offload_timeout_handler,
 				   &session->roamingTimerInfo);
-	if (QDF_IS_STATUS_ERROR(status)) {
-		sme_err("mem fail for roaming timer");
-		return status;
-	}
 
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sme_err("timer init failed for join failure timer");
@@ -16791,7 +16765,7 @@ QDF_STATUS csr_update_fils_config(struct mac_context *mac, uint8_t session_id,
  */
 static void csr_update_score_params(struct mac_context *mac_ctx,
 				    struct scoring_param *req_score_params,
-				    tpCsrNeighborRoamControlInfo roam_info)
+				    struct rso_config *rso_cfg)
 {
 	struct wlan_mlme_roam_scoring_cfg *roam_score_params;
 	struct weight_cfg *weight_config;
@@ -16807,7 +16781,7 @@ static void csr_update_score_params(struct mac_context *mac_ctx,
 	roam_score_params = &mac_ctx->mlme_cfg->roam_scoring;
 	weight_config = &score_config->weight_config;
 
-	if (!roam_info->cfgParams.enable_scoring_for_roam)
+	if (!rso_cfg->cfg_param.enable_scoring_for_roam)
 		req_score_params->disable_bitmap =
 			WLAN_ROAM_SCORING_DISABLE_ALL;
 
@@ -17066,139 +17040,6 @@ wlan_cm_roam_cmd_allowed(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 	return QDF_STATUS_SUCCESS;
 }
 
-/**
- * csr_cm_roam_scan_offload_rssi_thresh() - set roam offload scan rssi
- * parameters
- * @mac_ctx: global mac ctx
- * @session: csr roam session
- * @params:  roam offload scan rssi related parameters
- *
- * This function is used to set roam offload scan rssi related parameters
- *
- * Return: None
- */
-static void
-csr_cm_roam_scan_offload_rssi_thresh(struct mac_context *mac_ctx,
-			struct csr_roam_session *session,
-			struct wlan_roam_offload_scan_rssi_params *params)
-{
-	struct roam_ext_params *roam_params;
-		tpCsrNeighborRoamControlInfo roam_info =
-		&mac_ctx->roam.neighborRoamInfo[session->vdev_id];
-
-	roam_params = &mac_ctx->roam.configParam.roam_params;
-
-	if (roam_params->alert_rssi_threshold)
-		params->rssi_thresh = roam_params->alert_rssi_threshold;
-	else
-		params->rssi_thresh =
-			(int8_t)roam_info->cfgParams.neighborLookupThreshold *
-			(-1);
-
-	params->vdev_id = session->vdev_id;
-	params->rssi_thresh_diff =
-		roam_info->cfgParams.nOpportunisticThresholdDiff & 0x000000ff;
-	params->hi_rssi_scan_max_count =
-		roam_info->cfgParams.hi_rssi_scan_max_count;
-	/*
-	 * If the current operation channel is 5G frequency band, then
-	 * there is no need to enable the HI_RSSI feature. This feature
-	 * is useful only if we are connected to a 2.4 GHz AP and we wish
-	 * to connect to a better 5GHz AP is available.
-	 */
-	if (session->disable_hi_rssi)
-		params->hi_rssi_scan_rssi_delta = 0;
-	else
-		params->hi_rssi_scan_rssi_delta =
-			roam_info->cfgParams.hi_rssi_scan_rssi_delta;
-	params->hi_rssi_scan_rssi_ub =
-		roam_info->cfgParams.hi_rssi_scan_rssi_ub;
-	params->raise_rssi_thresh_5g =
-		mac_ctx->mlme_cfg->lfr.rssi_boost_threshold_5g;
-	params->dense_rssi_thresh_offset =
-		mac_ctx->mlme_cfg->lfr.roam_dense_rssi_thre_offset;
-	params->dense_min_aps_cnt = mac_ctx->mlme_cfg->lfr.roam_dense_min_aps;
-	params->traffic_threshold =
-			mac_ctx->mlme_cfg->lfr.roam_dense_traffic_threshold;
-
-	/* Set initial dense roam status */
-	if (mac_ctx->scan.roam_candidate_count[params->vdev_id] >
-	    params->dense_min_aps_cnt)
-		params->initial_dense_status = true;
-
-	params->bg_scan_bad_rssi_thresh =
-		mac_ctx->mlme_cfg->lfr.roam_bg_scan_bad_rssi_threshold;
-	params->bg_scan_client_bitmap =
-		mac_ctx->mlme_cfg->lfr.roam_bg_scan_client_bitmap;
-	params->roam_bad_rssi_thresh_offset_2g =
-			mac_ctx->mlme_cfg->lfr.roam_bg_scan_bad_rssi_offset_2g;
-	params->roam_data_rssi_threshold_triggers =
-		mac_ctx->mlme_cfg->lfr.roam_data_rssi_threshold_triggers;
-	params->roam_data_rssi_threshold =
-		mac_ctx->mlme_cfg->lfr.roam_data_rssi_threshold;
-	params->rx_data_inactivity_time =
-		mac_ctx->mlme_cfg->lfr.rx_data_inactivity_time;
-
-	params->drop_rssi_thresh_5g =
-		mac_ctx->mlme_cfg->lfr.rssi_penalize_threshold_5g;
-
-	params->raise_factor_5g = mac_ctx->mlme_cfg->lfr.rssi_boost_factor_5g;
-	params->drop_factor_5g = mac_ctx->mlme_cfg->lfr.rssi_penalize_factor_5g;
-	params->max_raise_rssi_5g = mac_ctx->mlme_cfg->lfr.max_rssi_boost_5g;
-	params->max_drop_rssi_5g = mac_ctx->mlme_cfg->lfr.max_rssi_penalize_5g;
-
-	if (roam_params->good_rssi_roam)
-		params->good_rssi_threshold = NOISE_FLOOR_DBM_DEFAULT;
-	else
-		params->good_rssi_threshold = 0;
-
-	params->early_stop_scan_enable =
-		mac_ctx->mlme_cfg->lfr.early_stop_scan_enable;
-	if (params->early_stop_scan_enable) {
-		params->roam_earlystop_thres_min =
-			mac_ctx->mlme_cfg->lfr.early_stop_scan_min_threshold;
-		params->roam_earlystop_thres_max =
-			mac_ctx->mlme_cfg->lfr.early_stop_scan_max_threshold;
-	}
-
-	params->rssi_thresh_offset_5g =
-		roam_info->cfgParams.rssi_thresh_offset_5g;
-}
-
-/**
- * csr_cm_roam_scan_offload_scan_period() - set roam offload scan period
- * parameters
- * @mac_ctx: global mac ctx
- * @vdev_id: vdev id
- * @params:  roam offload scan period related parameters
- *
- * This function is used to set roam offload scan period related parameters
- *
- * Return: None
- */
-static void
-csr_cm_roam_scan_offload_scan_period(struct mac_context *mac_ctx,
-				    uint8_t vdev_id,
-				    struct wlan_roam_scan_period_params *params)
-{
-	tpCsrNeighborRoamControlInfo roam_info =
-			&mac_ctx->roam.neighborRoamInfo[vdev_id];
-
-	params->vdev_id = vdev_id;
-	params->empty_scan_refresh_period =
-				roam_info->cfgParams.emptyScanRefreshPeriod;
-	params->scan_period = params->empty_scan_refresh_period;
-	params->scan_age = (3 * params->empty_scan_refresh_period);
-	params->roam_scan_inactivity_time =
-				roam_info->cfgParams.roam_scan_inactivity_time;
-	params->roam_inactive_data_packet_count =
-			roam_info->cfgParams.roam_inactive_data_packet_count;
-	params->roam_scan_period_after_inactivity =
-			roam_info->cfgParams.roam_scan_period_after_inactivity;
-	params->full_scan_period =
-			roam_info->cfgParams.full_roam_scan_period;
-}
-
 /**
  * csr_cm_roam_scan_offload_ap_profile() - set roam ap profile parameters
  * @mac_ctx: global mac ctx
@@ -17217,8 +17058,21 @@ csr_cm_roam_scan_offload_ap_profile(struct mac_context *mac_ctx,
 	struct ap_profile *profile = &params->profile;
 	struct roam_ext_params *roam_params_src =
 			&mac_ctx->roam.configParam.roam_params;
-	tpCsrNeighborRoamControlInfo roam_info =
-			&mac_ctx->roam.neighborRoamInfo[session->vdev_id];
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev,
+						    session->vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", session->vdev_id);
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
 
 	csr_cm_roam_fill_11w_params(mac_ctx, session->vdev_id, params);
 	params->vdev_id = session->vdev_id;
@@ -17239,9 +17093,8 @@ csr_cm_roam_scan_offload_ap_profile(struct mac_context *mac_ctx,
 			session->connectedProfile.mcEncryptionType);
 	/* Group management cipher suite */
 
-	profile->rssi_threshold = roam_info->cfgParams.roam_rssi_diff;
-	profile->bg_rssi_threshold =
-			roam_info->cfgParams.bg_rssi_threshold;
+	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.
@@ -17252,7 +17105,7 @@ csr_cm_roam_scan_offload_ap_profile(struct mac_context *mac_ctx,
 	profile->rssi_abs_thresh =
 			mac_ctx->mlme_cfg->lfr.roam_rssi_abs_threshold;
 
-	csr_update_score_params(mac_ctx, &params->param, roam_info);
+	csr_update_score_params(mac_ctx, &params->param, rso_cfg);
 
 	params->min_rssi_params[DEAUTH_MIN_RSSI] =
 			mac_ctx->mlme_cfg->trig_min_rssi[DEAUTH_MIN_RSSI];
@@ -17265,6 +17118,7 @@ csr_cm_roam_scan_offload_ap_profile(struct mac_context *mac_ctx,
 			mac_ctx->mlme_cfg->trig_score_delta[IDLE_ROAM_TRIGGER];
 	params->score_delta_param[BTM_ROAM_TRIGGER] =
 			mac_ctx->mlme_cfg->trig_score_delta[BTM_ROAM_TRIGGER];
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 /**
@@ -17279,7 +17133,7 @@ csr_cm_roam_scan_offload_ap_profile(struct mac_context *mac_ctx,
 static QDF_STATUS
 csr_cm_populate_roam_chan_list(struct mac_context *mac_ctx,
 			       struct wlan_roam_scan_channel_list *dst,
-			       tCsrChannelInfo *src)
+			       struct rso_chan_info *src)
 {
 	enum band_info band;
 	uint32_t band_cap;
@@ -17300,7 +17154,7 @@ csr_cm_populate_roam_chan_list(struct mac_context *mac_ctx,
 
 	band = wlan_reg_band_bitmap_to_band_info(band_cap);
 	num_channels = dst->chan_count;
-	for (i = 0; i < src->numOfChannels; i++) {
+	for (i = 0; i < src->num_chan; i++) {
 		if (csr_is_channel_present_in_list(dst->chan_freq_list,
 						   num_channels, *freq_lst)) {
 			freq_lst++;
@@ -17409,12 +17263,14 @@ static void csr_cm_fetch_ch_lst_from_occupied_lst(
 static QDF_STATUS csr_cm_add_ch_lst_from_roam_scan_list(
 			struct mac_context *mac_ctx,
 			struct wlan_roam_scan_channel_list *rso_chan_info,
-			tpCsrNeighborRoamControlInfo roam_info)
+			tpCsrNeighborRoamControlInfo roam_info,
+			struct rso_config *rso_cfg)
 {
 	QDF_STATUS status;
-	tCsrChannelInfo *pref_chan_info = &roam_info->cfgParams.pref_chan_info;
+	struct rso_chan_info *pref_chan_info =
+			&rso_cfg->cfg_param.pref_chan_info;
 
-	if (!pref_chan_info->numOfChannels)
+	if (!pref_chan_info->num_chan)
 		return QDF_STATUS_SUCCESS;
 
 	status = csr_cm_populate_roam_chan_list(mac_ctx,
@@ -17500,18 +17356,17 @@ csr_cm_fetch_valid_ch_lst(struct mac_context *mac_ctx,
  * @mac_ctx:      global mac ctx
  * @roam_info:    roam info struct
  * @rso_chan_info:
+ * @specific_chan_info: chan info
  *
  * Return: QDF_STATUS
  */
 static QDF_STATUS csr_cm_fetch_ch_lst_from_ini(
 			struct mac_context *mac_ctx,
 			tpCsrNeighborRoamControlInfo roam_info,
-			struct wlan_roam_scan_channel_list *rso_chan_info)
+			struct wlan_roam_scan_channel_list *rso_chan_info,
+			struct rso_chan_info *specific_chan_info)
 {
 	QDF_STATUS status;
-	tCsrChannelInfo *specific_chan_info;
-
-	specific_chan_info = &roam_info->cfgParams.specific_chan_info;
 
 	status = csr_cm_populate_roam_chan_list(mac_ctx, rso_chan_info,
 						specific_chan_info);
@@ -17531,15 +17386,28 @@ csr_cm_fill_rso_channel_list(struct mac_context *mac_ctx,
 {
 	tpCsrNeighborRoamControlInfo roam_info =
 			&mac_ctx->roam.neighborRoamInfo[vdev_id];
-	tCsrChannelInfo *specific_chan_info =
-			&roam_info->cfgParams.specific_chan_info;
 	tpCsrChannelInfo curr_ch_lst_info =
 		&roam_info->roamChannelInfo.currentChannelListInfo;
 	QDF_STATUS status;
 	bool ese_neighbor_list_recvd = false;
 	uint8_t ch_cache_str[128] = {0};
 	uint8_t i, j;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_chan_info *specific_chan_info;
 
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", vdev_id);
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
+	specific_chan_info = &rso_cfg->cfg_param.specific_chan_info;
 #ifdef FEATURE_WLAN_ESE
 	/*
 	 * this flag will be true if connection is ESE and no neighbor
@@ -17559,13 +17427,14 @@ csr_cm_fill_rso_channel_list(struct mac_context *mac_ctx,
 		 * channel list configured by the client.
 		 * Give Preference to INI Channels
 		 */
-		if (specific_chan_info->numOfChannels) {
+		if (specific_chan_info->num_chan) {
 			status = csr_cm_fetch_ch_lst_from_ini(mac_ctx,
 							      roam_info,
-							      rso_chan_info);
+							      rso_chan_info,
+							      specific_chan_info);
 			if (QDF_IS_STATUS_ERROR(status)) {
 				sme_err("Fetch channel list from ini failed");
-				return;
+				goto rel_ref;
 			}
 		} else if (reason == REASON_FLUSH_CHANNEL_LIST) {
 			rso_chan_info->chan_cache_type = CHANNEL_LIST_STATIC;
@@ -17581,7 +17450,8 @@ csr_cm_fill_rso_channel_list(struct mac_context *mac_ctx,
 			 */
 			csr_cm_add_ch_lst_from_roam_scan_list(mac_ctx,
 							      rso_chan_info,
-							      roam_info);
+							      roam_info,
+							      rso_cfg);
 		}
 	} else {
 		/*
@@ -17602,7 +17472,7 @@ csr_cm_fill_rso_channel_list(struct mac_context *mac_ctx,
 						   vdev_id);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			sme_err("Fetch channel list fail");
-			return;
+			goto rel_ref;
 		}
 	}
 
@@ -17618,6 +17488,8 @@ csr_cm_fill_rso_channel_list(struct mac_context *mac_ctx,
 	sme_debug("ChnlCacheType:%d, No of Chnls:%d,Channels: %s",
 		  rso_chan_info->chan_cache_type,
 		  rso_chan_info->chan_count, ch_cache_str);
+rel_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
@@ -17741,12 +17613,26 @@ static QDF_STATUS csr_cm_roam_scan_offload_fill_lfr3_config(
 	uint16_t rsn_caps = 0;
 	tpCsrNeighborRoamControlInfo roam_info =
 		&mac->roam.neighborRoamInfo[vdev_id];
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
 
 	rso_config->roam_offload_enabled =
 		mac->mlme_cfg->lfr.lfr3_roaming_offload;
 	if (!rso_config->roam_offload_enabled)
 		return QDF_STATUS_SUCCESS;
 
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", vdev_id);
+		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;
+	}
+
 	/* FILL LFR3 specific roam scan mode TLV parameters */
 	rso_config->rso_lfr3_params.roam_rssi_cat_gap =
 		mac->roam.configParam.bCatRssiOffset;
@@ -17766,9 +17652,10 @@ static QDF_STATUS csr_cm_roam_scan_offload_fill_lfr3_config(
 		mac->mlme_cfg->btm.rct_validity_timer;
 	rso_config->rso_lfr3_params.disable_self_roam =
 		!mac->mlme_cfg->lfr.enable_self_bss_roam;
-	if (!roam_info->roam_control_enable &&
+	if (!rso_cfg->roam_control_enable &&
 	    mac->mlme_cfg->lfr.roam_force_rssi_trigger)
 		*mode |= WMI_ROAM_SCAN_MODE_RSSI_CHANGE;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	/* Fill LFR3 specific self capabilities for roam scan mode TLV */
 	self_caps.ess = 1;
@@ -17926,16 +17813,35 @@ csr_cm_roam_scan_offload_fill_scan_params(
 {
 	struct wlan_roam_scan_params *scan_params =
 			&rso_mode_cfg->rso_scan_params;
-	tpCsrNeighborRoamControlInfo roam_info =
-		&mac->roam.neighborRoamInfo[session->vdev_id];
 	uint8_t channels_per_burst = 0;
 	uint16_t roam_scan_home_away_time;
 	eSirDFSRoamScanMode allow_dfs_ch_roam;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
+	struct wlan_mlme_psoc_ext_obj *mlme_obj;
 
 	qdf_mem_zero(scan_params, sizeof(*scan_params));
 	if (command == ROAM_SCAN_OFFLOAD_STOP)
 		return;
 
+	mlme_obj = mlme_get_psoc_ext_obj(mac->psoc);
+	if (!mlme_obj)
+		return;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, session->vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", session->vdev_id);
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
+	cfg_params = &rso_cfg->cfg_param;
+
 	/* Parameters updated after association is complete */
 	wlan_scan_cfg_get_passive_dwelltime(mac->psoc,
 					    &scan_params->dwell_time_passive);
@@ -17944,11 +17850,9 @@ csr_cm_roam_scan_offload_fill_scan_params(
 	 * T(HomeAway) = N * T(dwell) + (N+1) * T(cs)
 	 * where N is number of channels scanned in single burst
 	 */
-	scan_params->dwell_time_active =
-		roam_info->cfgParams.maxChannelScanTime;
+	scan_params->dwell_time_active = cfg_params->max_chan_scan_time;
 
-	roam_scan_home_away_time =
-		roam_info->cfgParams.roam_scan_home_away_time;
+	roam_scan_home_away_time = cfg_params->roam_scan_home_away_time;
 	if (roam_scan_home_away_time <
 	    (scan_params->dwell_time_active +
 	     (2 * ROAM_SCAN_CHANNEL_SWITCH_TIME))) {
@@ -17985,7 +17889,7 @@ csr_cm_roam_scan_offload_fill_scan_params(
 	}
 
 	allow_dfs_ch_roam =
-		(eSirDFSRoamScanMode)mac->mlme_cfg->lfr.roaming_dfs_channel;
+		(eSirDFSRoamScanMode)mlme_obj->cfg.lfr.roaming_dfs_channel;
 	/* Roaming on DFS channels is supported and it is not
 	 * app channel list. It is ok to override homeAwayTime
 	 * to accommodate DFS dwell time in burst
@@ -17998,19 +17902,18 @@ csr_cm_roam_scan_offload_fill_scan_params(
 			QDF_MAX(scan_params->burst_duration,
 				scan_params->dwell_time_passive);
 
-	scan_params->min_rest_time =
-		roam_info->cfgParams.neighbor_scan_min_period;
-	scan_params->max_rest_time = roam_info->cfgParams.neighborScanPeriod;
+	scan_params->min_rest_time = cfg_params->neighbor_scan_min_period;
+	scan_params->max_rest_time = cfg_params->neighbor_scan_period;
 	scan_params->repeat_probe_time =
-		(roam_info->cfgParams.roam_scan_n_probes > 0) ?
+		(cfg_params->roam_scan_n_probes > 0) ?
 			QDF_MAX(scan_params->dwell_time_active /
-				roam_info->cfgParams.roam_scan_n_probes, 1) : 0;
+				cfg_params->roam_scan_n_probes, 1) : 0;
 	scan_params->probe_spacing_time = 0;
 	scan_params->probe_delay = 0;
 	/* 30 seconds for full scan cycle */
 	scan_params->max_scan_time = ROAM_SCAN_HW_DEF_SCAN_MAX_DURATION;
 	scan_params->idle_time = scan_params->min_rest_time;
-	scan_params->n_probes = roam_info->cfgParams.roam_scan_n_probes;
+	scan_params->n_probes = cfg_params->roam_scan_n_probes;
 
 	if (allow_dfs_ch_roam == SIR_ROAMING_DFS_CHANNEL_DISABLED) {
 		scan_params->scan_ctrl_flags |= WMI_SCAN_BYPASS_DFS_CHN;
@@ -18035,7 +17938,8 @@ csr_cm_roam_scan_offload_fill_scan_params(
 	}
 
 	scan_params->rso_adaptive_dwell_mode =
-		mac->mlme_cfg->lfr.adaptive_roamscan_dwell_mode;
+		mlme_obj->cfg.lfr.adaptive_roamscan_dwell_mode;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 /**
@@ -18053,9 +17957,21 @@ static void csr_cm_roam_scan_offload_fill_rso_configs(
 			uint8_t command, uint16_t reason)
 {
 	uint8_t vdev_id = session->vdev_id;
-	tpCsrNeighborRoamControlInfo roam_info =
-			&mac->roam.neighborRoamInfo[vdev_id];
 	uint32_t mode = 0;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", vdev_id);
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg) {
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+		return;
+	}
 
 	qdf_mem_zero(rso_mode_cfg, sizeof(*rso_mode_cfg));
 
@@ -18065,8 +17981,9 @@ static void csr_cm_roam_scan_offload_fill_rso_configs(
 		mac->mlme_cfg->lfr.roaming_scan_policy;
 
 	/* Fill ROAM SCAN mode TLV parameters */
-	if (roam_info->cfgParams.emptyScanRefreshPeriod)
+	if (rso_cfg->cfg_param.empty_scan_refresh_period)
 		mode |= WMI_ROAM_SCAN_MODE_PERIODIC;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	rso_mode_cfg->rso_mode_info.min_delay_btw_scans =
 			mac->mlme_cfg->lfr.min_delay_btw_roam_scans;
@@ -18319,12 +18236,6 @@ wlan_cm_roam_fill_start_req(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	csr_cm_roam_scan_offload_rssi_thresh(mac_ctx, session,
-					     &req->rssi_params);
-
-	csr_cm_roam_scan_offload_scan_period(mac_ctx, vdev_id,
-					     &req->scan_period_params);
-
 	csr_cm_roam_scan_offload_ap_profile(mac_ctx, session,
 					    &req->profile_params);
 
@@ -18427,12 +18338,6 @@ wlan_cm_roam_fill_update_config_req(struct wlan_objmgr_psoc *psoc,
 	csr_cm_roam_scan_filter(mac_ctx, vdev_id, ROAM_SCAN_OFFLOAD_UPDATE_CFG,
 				reason, &req->scan_filter_params);
 
-	csr_cm_roam_scan_offload_rssi_thresh(mac_ctx, session,
-					     &req->rssi_params);
-
-	csr_cm_roam_scan_offload_scan_period(mac_ctx, vdev_id,
-					     &req->scan_period_params);
-
 	csr_cm_fill_rso_channel_list(mac_ctx, &req->rso_chan_info, vdev_id,
 				     reason);
 
@@ -20463,11 +20368,13 @@ csr_process_roam_sync_callback(struct mac_context *mac_ctx,
 			ucfg_pkt_capture_record_channel(vdev);
 
 		if (WLAN_REG_IS_5GHZ_CH_FREQ(bss_desc->chan_freq)) {
-			session->disable_hi_rssi = true;
+			wlan_cm_set_disable_hi_rssi(mac_ctx->pdev,
+						    session_id, true);
 			sme_debug("Disabling HI_RSSI, AP freq=%d, rssi=%d",
 				  bss_desc->chan_freq, bss_desc->rssi);
 		} else {
-			session->disable_hi_rssi = false;
+			wlan_cm_set_disable_hi_rssi(mac_ctx->pdev,
+						    session_id, false);
 		}
 
 		policy_mgr_check_n_start_opportunistic_timer(mac_ctx->psoc);

core/sme/src/csr/csr_api_scan.c

@@ -2469,39 +2469,51 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 	bool dual_sta_roam_active;
 	struct wlan_channel *chan;
 	struct wlan_objmgr_vdev *vdev;
-
-	tpCsrNeighborRoamControlInfo neighbor_roam_info =
-		&mac_ctx->roam.neighborRoamInfo[sessionId];
 	tCsrRoamConnectedProfile *profile = NULL;
 	QDF_STATUS status;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
 
 	if (!(mac_ctx && mac_ctx->roam.roamSession &&
 	      CSR_IS_SESSION_VALID(mac_ctx, sessionId))) {
 		sme_debug("Invalid session");
 		return;
 	}
-	if (neighbor_roam_info->cfgParams.specific_chan_info.numOfChannels) {
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", sessionId);
+		return;
+	}
+	rso_cfg = wlan_cm_get_rso_config(vdev);
+	if (!rso_cfg)
+		goto rel_vdev_ref;
+
+	cfg_params = &rso_cfg->cfg_param;
+
+	if (cfg_params->specific_chan_info.num_chan) {
 		/*
 		 * Ini file contains neighbor scan channel list, hence NO need
 		 * to build occupied channel list"
 		 */
 		sme_debug("Ini contains neighbor scan ch list");
-		return;
+		goto rel_vdev_ref;
 	}
 
 	profile = &mac_ctx->roam.roamSession[sessionId].connectedProfile;
 	if (!profile)
-		return;
+		goto rel_vdev_ref;
 
 	filter = qdf_mem_malloc(sizeof(*filter));
 	if (!filter)
-		return;
+		goto rel_vdev_ref;
 
 	status = csr_fill_filter_from_vdev_crypto(mac_ctx, filter, sessionId);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sme_err("fail to fill filter crypto");
 		qdf_mem_free(filter);
-		return;
+		goto rel_vdev_ref;
 	}
 	filter->num_of_ssid = 1;
 	filter->ssid_list[0].length = profile->SSID.length;
@@ -2514,7 +2526,7 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 	if (!pdev) {
 		sme_err("pdev is NULL");
 		qdf_mem_free(filter);
-		return;
+		goto rel_vdev_ref;
 	}
 
 	/* Empty occupied channels here */
@@ -2529,18 +2541,12 @@ void csr_init_occupied_channels_list(struct mac_context *mac_ctx,
 			true);
 	list = ucfg_scan_get_result(pdev, filter);
 	if (!list || (list && !qdf_list_size(list))) {
-		goto err;
-	}
-
-	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac_ctx->psoc, sessionId,
-						    WLAN_LEGACY_MAC_ID);
-	if (!vdev) {
-		sme_err("vdev null");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 		goto err;
 	}
 
 	chan = wlan_vdev_get_active_channel(vdev);
-	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 	if (!chan) {
 		sme_err("no active channel");
 		goto err;
@@ -2576,6 +2582,9 @@ err:
 		ucfg_scan_purge_results(list);
 	wlan_objmgr_pdev_release_ref(pdev, WLAN_LEGACY_MAC_ID);
 	return;
+
+rel_vdev_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 /**

core/sme/src/csr/csr_neighbor_roam.c

@@ -167,66 +167,77 @@ QDF_STATUS csr_neighbor_roam_update_config(struct mac_context *mac_ctx,
 {
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 	    &mac_ctx->roam.neighborRoamInfo[session_id];
-	tpCsrNeighborRoamCfgParams cfg_params;
 	struct cm_roam_values_copy src_cfg;
 	eCsrNeighborRoamState state;
 	uint8_t old_value;
+	struct wlan_objmgr_vdev *vdev;
+	struct rso_config *rso_cfg;
+	struct rso_cfg_params *cfg_params;
 
 	if (!pNeighborRoamInfo) {
 		sme_err("Invalid Session ID %d", session_id);
 		return QDF_STATUS_E_FAILURE;
 	}
-	cfg_params = &pNeighborRoamInfo->cfgParams;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, session_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		sme_err("vdev object is NULL for vdev %d", session_id);
+		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;
+	}
+	cfg_params = &rso_cfg->cfg_param;
 	state = pNeighborRoamInfo->neighborRoamState;
 	if ((state == eCSR_NEIGHBOR_ROAM_STATE_CONNECTED) ||
 			state == eCSR_NEIGHBOR_ROAM_STATE_INIT) {
 		switch (reason) {
 		case REASON_LOOKUP_THRESH_CHANGED:
-			old_value = cfg_params->neighborLookupThreshold;
-			cfg_params->neighborLookupThreshold = value;
-			pNeighborRoamInfo->currentNeighborLookupThreshold =
-				value;
+			old_value = cfg_params->neighbor_lookup_threshold;
+			cfg_params->neighbor_lookup_threshold = value;
 			break;
 		case REASON_OPPORTUNISTIC_THRESH_DIFF_CHANGED:
-			old_value = cfg_params->nOpportunisticThresholdDiff;
-			cfg_params->nOpportunisticThresholdDiff = value;
-			pNeighborRoamInfo->currentOpportunisticThresholdDiff =
-				value;
+			old_value = cfg_params->opportunistic_threshold_diff;
+			cfg_params->opportunistic_threshold_diff = value;
 			break;
 		case REASON_ROAM_RESCAN_RSSI_DIFF_CHANGED:
-			old_value = cfg_params->nRoamRescanRssiDiff;
-			cfg_params->nRoamRescanRssiDiff = value;
-			pNeighborRoamInfo->currentRoamRescanRssiDiff = value;
+			old_value = cfg_params->roam_rescan_rssi_diff;
+			cfg_params->roam_rescan_rssi_diff = value;
 			src_cfg.uint_value = value;
 			wlan_cm_roam_cfg_set_value(mac_ctx->psoc, session_id,
 						   RSSI_CHANGE_THRESHOLD,
 						   &src_cfg);
 			break;
 		case REASON_ROAM_BMISS_FIRST_BCNT_CHANGED:
-			old_value = cfg_params->nRoamBmissFirstBcnt;
-			cfg_params->nRoamBmissFirstBcnt = value;
-			pNeighborRoamInfo->currentRoamBmissFirstBcnt = value;
+			old_value = cfg_params->roam_bmiss_first_bcn_cnt;
+			cfg_params->roam_bmiss_first_bcn_cnt = value;
 			break;
 		case REASON_ROAM_BMISS_FINAL_BCNT_CHANGED:
-			old_value = cfg_params->nRoamBmissFinalBcnt;
-			cfg_params->nRoamBmissFinalBcnt = value;
-			pNeighborRoamInfo->currentRoamBmissFinalBcnt = value;
+			old_value = cfg_params->roam_bmiss_final_cnt;
+			cfg_params->roam_bmiss_final_cnt = value;
 			break;
 		default:
 			sme_debug("Unknown update cfg reason");
+			wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 			return QDF_STATUS_E_FAILURE;
 		}
 	} else {
 		sme_err("Unexpected state %s, return fail",
 			mac_trace_get_neighbour_roam_state(state));
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 		return QDF_STATUS_E_FAILURE;
 	}
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 	if (state == eCSR_NEIGHBOR_ROAM_STATE_CONNECTED) {
 		sme_debug("CONNECTED, send update cfg cmd");
 		csr_roam_update_cfg(mac_ctx, session_id, reason);
 	}
 	sme_debug("LFR config for %s changed from %d to %d",
-			lfr_get_config_item_string(reason), old_value, value);
+		  lfr_get_config_item_string(reason), old_value, value);
+
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -791,17 +802,6 @@ static void csr_neighbor_roam_info_ctx_init(struct mac_context *mac,
 			&session->connectedProfile.bssid);
 	ngbr_roam_info->curr_ap_op_chan_freq =
 				      session->connectedProfile.op_freq;
-	ngbr_roam_info->currentNeighborLookupThreshold =
-		ngbr_roam_info->cfgParams.neighborLookupThreshold;
-	ngbr_roam_info->currentOpportunisticThresholdDiff =
-		ngbr_roam_info->cfgParams.nOpportunisticThresholdDiff;
-	ngbr_roam_info->currentRoamRescanRssiDiff =
-		ngbr_roam_info->cfgParams.nRoamRescanRssiDiff;
-	ngbr_roam_info->currentRoamBmissFirstBcnt =
-		ngbr_roam_info->cfgParams.nRoamBmissFirstBcnt;
-	ngbr_roam_info->currentRoamBmissFinalBcnt =
-		ngbr_roam_info->cfgParams.nRoamBmissFinalBcnt;
-
 	/*
 	 * Update RSSI change params to vdev
 	 */
@@ -1030,122 +1030,26 @@ static QDF_STATUS csr_neighbor_roam_init11r_assoc_info(struct mac_context *mac)
 QDF_STATUS csr_neighbor_roam_init(struct mac_context *mac, uint8_t sessionId)
 {
 	QDF_STATUS status;
-	tCsrChannelInfo *specific_chan_info;
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 		&mac->roam.neighborRoamInfo[sessionId];
 
 	pNeighborRoamInfo->neighborRoamState = eCSR_NEIGHBOR_ROAM_STATE_CLOSED;
 	pNeighborRoamInfo->prevNeighborRoamState =
 		eCSR_NEIGHBOR_ROAM_STATE_CLOSED;
-	pNeighborRoamInfo->cfgParams.maxChannelScanTime =
-		mac->mlme_cfg->lfr.neighbor_scan_max_chan_time;
-	pNeighborRoamInfo->cfgParams.minChannelScanTime =
-		mac->mlme_cfg->lfr.neighbor_scan_min_chan_time;
-	pNeighborRoamInfo->cfgParams.neighborLookupThreshold =
-		mac->mlme_cfg->lfr.neighbor_lookup_rssi_threshold;
-	pNeighborRoamInfo->cfgParams.rssi_thresh_offset_5g =
-		mac->mlme_cfg->lfr.rssi_threshold_offset_5g;
-	pNeighborRoamInfo->cfgParams.delay_before_vdev_stop =
-		mac->mlme_cfg->lfr.delay_before_vdev_stop;
-	pNeighborRoamInfo->cfgParams.nOpportunisticThresholdDiff =
-		mac->mlme_cfg->lfr.opportunistic_scan_threshold_diff;
-	pNeighborRoamInfo->cfgParams.nRoamRescanRssiDiff =
-		mac->mlme_cfg->lfr.roam_rescan_rssi_diff;
-
-	pNeighborRoamInfo->cfgParams.nRoamBmissFirstBcnt =
-		mac->mlme_cfg->lfr.roam_bmiss_first_bcnt;
-	pNeighborRoamInfo->cfgParams.nRoamBmissFinalBcnt =
-		mac->mlme_cfg->lfr.roam_bmiss_final_bcnt;
-
-	pNeighborRoamInfo->cfgParams.neighborScanPeriod =
-		mac->mlme_cfg->lfr.neighbor_scan_timer_period;
-	pNeighborRoamInfo->cfgParams.neighbor_scan_min_period =
-		mac->mlme_cfg->lfr.neighbor_scan_min_timer_period;
-	pNeighborRoamInfo->cfgParams.neighborResultsRefreshPeriod =
-		mac->mlme_cfg->lfr.neighbor_scan_results_refresh_period;
-	pNeighborRoamInfo->cfgParams.emptyScanRefreshPeriod =
-		mac->mlme_cfg->lfr.empty_scan_refresh_period;
-	pNeighborRoamInfo->cfgParams.full_roam_scan_period =
-		mac->mlme_cfg->lfr.roam_full_scan_period;
-	pNeighborRoamInfo->cfgParams.enable_scoring_for_roam =
-		mac->mlme_cfg->roam_scoring.enable_scoring_for_roam;
-	pNeighborRoamInfo->cfgParams.roam_scan_n_probes =
-		mac->mlme_cfg->lfr.roam_scan_n_probes;
-	pNeighborRoamInfo->cfgParams.roam_scan_home_away_time =
-		mac->mlme_cfg->lfr.roam_scan_home_away_time;
-	pNeighborRoamInfo->cfgParams.roam_scan_inactivity_time =
-		mac->mlme_cfg->lfr.roam_scan_inactivity_time;
-	pNeighborRoamInfo->cfgParams.roam_inactive_data_packet_count =
-		mac->mlme_cfg->lfr.roam_inactive_data_packet_count;
-	pNeighborRoamInfo->cfgParams.roam_scan_period_after_inactivity =
-		mac->mlme_cfg->lfr.roam_scan_period_after_inactivity;
-
-	specific_chan_info = &pNeighborRoamInfo->cfgParams.specific_chan_info;
-	specific_chan_info->numOfChannels =
-		mac->mlme_cfg->lfr.neighbor_scan_channel_list_num;
-	sme_debug("number of channels: %u", specific_chan_info->numOfChannels);
-	if (specific_chan_info->numOfChannels != 0) {
-		specific_chan_info->freq_list =
-			qdf_mem_malloc(sizeof(uint32_t) *
-				       specific_chan_info->numOfChannels);
-		if (!specific_chan_info->freq_list) {
-			specific_chan_info->numOfChannels = 0;
-			return QDF_STATUS_E_NOMEM;
-		}
-
-	} else {
-		specific_chan_info->freq_list = NULL;
-	}
-
-	/* Update the roam global structure from CFG */
-	sme_chan_to_freq_list(mac->pdev,
-			      specific_chan_info->freq_list,
-			      mac->mlme_cfg->lfr.neighbor_scan_channel_list,
-			      mac->mlme_cfg->lfr.
-			      neighbor_scan_channel_list_num);
-
-	pNeighborRoamInfo->cfgParams.hi_rssi_scan_max_count =
-		mac->mlme_cfg->lfr.roam_scan_hi_rssi_maxcount;
-	pNeighborRoamInfo->cfgParams.hi_rssi_scan_rssi_delta =
-		mac->mlme_cfg->lfr.roam_scan_hi_rssi_delta;
-
-	pNeighborRoamInfo->cfgParams.hi_rssi_scan_delay =
-		mac->mlme_cfg->lfr.roam_scan_hi_rssi_delay;
-
-	pNeighborRoamInfo->cfgParams.hi_rssi_scan_rssi_ub =
-		mac->mlme_cfg->lfr.roam_scan_hi_rssi_ub;
-	pNeighborRoamInfo->cfgParams.roam_rssi_diff =
-		mac->mlme_cfg->lfr.roam_rssi_diff;
-	pNeighborRoamInfo->cfgParams.bg_rssi_threshold =
-		mac->mlme_cfg->lfr.bg_rssi_threshold;
 
 	qdf_zero_macaddr(&pNeighborRoamInfo->currAPbssid);
-	pNeighborRoamInfo->currentNeighborLookupThreshold =
-		pNeighborRoamInfo->cfgParams.neighborLookupThreshold;
-	pNeighborRoamInfo->currentOpportunisticThresholdDiff =
-		pNeighborRoamInfo->cfgParams.nOpportunisticThresholdDiff;
-	pNeighborRoamInfo->currentRoamRescanRssiDiff =
-		pNeighborRoamInfo->cfgParams.nRoamRescanRssiDiff;
-	pNeighborRoamInfo->currentRoamBmissFirstBcnt =
-		pNeighborRoamInfo->cfgParams.nRoamBmissFirstBcnt;
-	pNeighborRoamInfo->currentRoamBmissFinalBcnt =
-		pNeighborRoamInfo->cfgParams.nRoamBmissFinalBcnt;
 	qdf_mem_zero(&pNeighborRoamInfo->prevConnProfile,
 		    sizeof(tCsrRoamConnectedProfile));
 
 	status = csr_ll_open(&pNeighborRoamInfo->roamableAPList);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("LL Open of roam able AP List failed");
-		qdf_mem_free(specific_chan_info->freq_list);
-		specific_chan_info->freq_list = NULL;
-		specific_chan_info->numOfChannels = 0;
 		return QDF_STATUS_E_RESOURCES;
 	}
 
 	pNeighborRoamInfo->roamChannelInfo.currentChanIndex =
 		CSR_NEIGHBOR_ROAM_INVALID_CHANNEL_INDEX;
-	pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo.
-	numOfChannels = 0;
+	pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo.numOfChannels = 0;
 	pNeighborRoamInfo->roamChannelInfo.currentChannelListInfo.freq_list =
 		NULL;
 	pNeighborRoamInfo->roamChannelInfo.IAPPNeighborListReceived = false;
@@ -1153,9 +1057,6 @@ QDF_STATUS csr_neighbor_roam_init(struct mac_context *mac, uint8_t sessionId)
 	status = csr_neighbor_roam_init11r_assoc_info(mac);
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("LL Open of roam able AP List failed");
-		specific_chan_info->freq_list = NULL;
-		specific_chan_info->numOfChannels = 0;
-		csr_ll_close(&pNeighborRoamInfo->roamableAPList);
 		return QDF_STATUS_E_RESOURCES;
 	}
 
@@ -1180,7 +1081,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;
-	tCsrNeighborRoamCfgParams *cfg_params;
 	tpCsrNeighborRoamControlInfo pNeighborRoamInfo =
 		&mac->roam.neighborRoamInfo[sessionId];
 
@@ -1189,11 +1089,6 @@ void csr_neighbor_roam_close(struct mac_context *mac, uint8_t sessionId)
 		sme_warn("Neighbor Roam Algorithm Already Closed");
 		return;
 	}
-	cfg_params = &pNeighborRoamInfo->cfgParams;
-	if (cfg_params->specific_chan_info.freq_list)
-		qdf_mem_free(cfg_params->specific_chan_info.freq_list);
-	pNeighborRoamInfo->cfgParams.specific_chan_info.freq_list = NULL;
-	pNeighborRoamInfo->cfgParams.specific_chan_info.numOfChannels = 0;
 
 	/* Should free up the nodes in the list before closing the
 	 * double Linked list