qcacld-3.0: Move LFR2 FT logic to vdev mlme

Move LFR2 FT logic to vdev mlme.

Change-Id: I77435ec78a6eeacf47b26aec214d08ad056ebabe
CRs-Fixed: 2935076

components/mlme/core/inc/wlan_mlme_main.h

@@ -257,11 +257,53 @@ struct mscs_req_info {
 };
 #endif
 
+#ifdef WLAN_FEATURE_HOST_ROAM
+/**
+ * enum ft_ie_state - ft state
+ * @FT_START_READY: Start before and after 11r assoc
+ * @FT_AUTH_REQ_READY: When we have recvd the 1st or nth auth req
+ * @FT_REASSOC_REQ_WAIT: waiting for reassoc
+ * @FT_SET_KEY_WAIT: waiting for key
+ */
+enum ft_ie_state {
+	FT_START_READY,
+	FT_AUTH_REQ_READY,
+	FT_REASSOC_REQ_WAIT,
+	FT_SET_KEY_WAIT,
+};
+#endif
+
+/**
+ * struct ft_context - ft related information
+ * @r0kh_id_len: rokh id len
+ * @r0kh_id: rokh id
+ * @auth_ft_ie: auth ft ies received during preauth phase
+ * @auth_ie_len: auth ie lengt
+ * @reassoc_ft_ie: reassoc ft ies received during reassoc phas
+ * @reassoc_ie_len: reassoc ie length
+ * ric_ies: ric ie
+ * ric_ies_length: ric ie len
+ * @set_ft_preauth_state: preauth state
+ * @ft_state: ft state
+ * @add_mdie: add mdie in assoc req
+ */
 struct ft_context {
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 	uint32_t r0kh_id_len;
 	uint8_t r0kh_id[ROAM_R0KH_ID_MAX_LEN];
 #endif
+#ifdef WLAN_FEATURE_HOST_ROAM
+	uint8_t auth_ft_ie[MAX_FTIE_SIZE];
+	uint16_t auth_ie_len;
+	uint8_t reassoc_ft_ie[MAX_FTIE_SIZE];
+	uint16_t reassoc_ie_len;
+	uint8_t ric_ies[MAX_FTIE_SIZE];
+	uint16_t ric_ies_length;
+	bool set_ft_preauth_state;
+	enum ft_ie_state ft_state;
+	bool add_mdie;
+#endif
+
 };
 
 /**

core/hdd/inc/wlan_hdd_main.h

@@ -1075,8 +1075,6 @@ struct hdd_ap_ctx {
 	uint8_t broadcast_sta_id;
 	uint8_t privacy;
 	eCsrEncryptionType encryption_type;
-	tCsrRoamSetKey group_key;
-	tCsrRoamSetKey wep_key[CSR_MAX_NUM_KEY];
 	uint8_t wep_def_key_idx;
 	struct sap_context *sap_context;
 	struct sap_config sap_config;

core/hdd/src/wlan_hdd_hostapd.c

@@ -1799,7 +1799,6 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 	union iwreq_data wrqu;
 	uint8_t *we_custom_event_generic = NULL;
 	int we_event = 0;
-	int i = 0;
 	uint8_t sta_id;
 	QDF_STATUS qdf_status;
 	bool bAuthRequired = true;
@@ -2073,21 +2072,6 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 
 		hdd_medium_assess_deinit();
 
-		if ((BSS_STOP_DUE_TO_MCC_SCC_SWITCH !=
-			ap_ctx->bss_stop_reason) &&
-		    (BSS_STOP_DUE_TO_VENDOR_CONFIG_CHAN !=
-			ap_ctx->bss_stop_reason)) {
-			/*
-			 * when MCC to SCC switching or vendor subcmd
-			 * setting sap config channel happens, key storage
-			 * should not be cleared due to hostapd will not
-			 * repopulate the original keys
-			 */
-			ap_ctx->group_key.keyLength = 0;
-			for (i = 0; i < CSR_MAX_NUM_KEY; i++)
-				ap_ctx->wep_key[i].keyLength = 0;
-		}
-
 		/* clear the reason code in case BSS is stopped
 		 * in another place
 		 */

core/mac/src/pe/include/lim_ft_defs.h

@@ -71,8 +71,6 @@ typedef struct sSirFTPreAuthRsp {
 	QDF_STATUS status;
 	uint16_t ft_ies_length;
 	uint8_t ft_ies[MAX_FTIE_SIZE];
-	uint16_t ric_ies_length;
-	uint8_t ric_ies[MAX_FTIE_SIZE];
 } tSirFTPreAuthRsp, *tpSirFTPreAuthRsp;
 
 /*--------------------------------------------------------------------------

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

@@ -81,7 +81,6 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 	uint8_t vdev_id = 0;
 	bool vht_enabled = false;
 	tpSirMacMgmtHdr mac_hdr;
-	tftSMEContext *ft_sme_context;
 	struct mlme_legacy_priv *mlme_priv;
 
 	if (!pe_session)
@@ -281,13 +280,12 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 #endif
 	}
 
-	ft_sme_context = &mac_ctx->roam.roamSession[vdev_id].ftSmeContext;
 	if (pe_session->htCapability &&
 	    mac_ctx->lim.htCapabilityPresentInBeacon) {
 		populate_dot11f_ht_caps(mac_ctx, pe_session, &frm->HTCaps);
 	}
 	if (pe_session->pLimReAssocReq->bssDescription.mdiePresent &&
-	    (ft_sme_context->addMDIE == true)
+	    (mlme_priv->connect_info.ft_info.add_mdie)
 #if defined FEATURE_WLAN_ESE
 	    && !pe_session->isESEconnection
 #endif
@@ -341,10 +339,10 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 	bytes = payload + sizeof(tSirMacMgmtHdr) + add_ie_len;
 
 	pe_debug("FT IE Reassoc Req %d",
-		ft_sme_context->reassoc_ft_ies_length);
+		 mlme_priv->connect_info.ft_info.reassoc_ie_len);
 
 	if (pe_session->is11Rconnection)
-		ft_ies_length = ft_sme_context->reassoc_ft_ies_length;
+		ft_ies_length = mlme_priv->connect_info.ft_info.reassoc_ie_len;
 
 	qdf_status = cds_packet_alloc((uint16_t) bytes + ft_ies_length,
 				 (void **)&frame, (void **)&packet);
@@ -392,6 +390,7 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 		payload += add_ie_len;
 	}
 
+#ifdef FEATURE_CM_ENABLE
 	pe_session->assoc_req = qdf_mem_malloc(payload);
 	if (pe_session->assoc_req) {
 		/*
@@ -402,15 +401,19 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 			     frame + sizeof(tSirMacMgmtHdr), payload);
 		pe_session->assocReqLen = payload;
 	}
+#endif
 
-	if (pe_session->is11Rconnection && ft_sme_context->reassoc_ft_ies) {
+	if (pe_session->is11Rconnection &&
+	    mlme_priv->connect_info.ft_info.reassoc_ie_len) {
 		int i = 0;
 
 		body = frame + bytes;
 		for (i = 0; i < ft_ies_length; i++) {
-			*body = ft_sme_context->reassoc_ft_ies[i];
+			*body =
+			   mlme_priv->connect_info.ft_info.reassoc_ft_ie[i];
 			body++;
 		}
+		payload += ft_ies_length;
 	}
 	pe_debug("Re-assoc Req Frame is:");
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
@@ -425,6 +428,18 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 		 pe_session->opmode == QDF_P2P_GO_MODE)
 		tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
 
+#ifdef FEATURE_CM_ENABLE
+	pe_session->assoc_req = qdf_mem_malloc(payload);
+	if (pe_session->assoc_req) {
+		/*
+		 * Store the Assoc request. This is sent to csr/hdd in
+		 * join cnf response.
+		 */
+		qdf_mem_copy(pe_session->assoc_req,
+			     frame + sizeof(tSirMacMgmtHdr), payload);
+		pe_session->assocReqLen = payload;
+	}
+#else
 	if (pe_session->assoc_req) {
 		qdf_mem_free(pe_session->assoc_req);
 		pe_session->assoc_req = NULL;
@@ -440,14 +455,15 @@ void lim_send_reassoc_req_with_ft_ies_mgmt_frame(struct mac_context *mac_ctx,
 			 * join cnf response.
 			 */
 			qdf_mem_copy(pe_session->assoc_req,
-				     ft_sme_context->reassoc_ft_ies,
-				     ft_ies_length);
+				mlme_priv->connect_info.ft_info.reassoc_ft_ie,
+				ft_ies_length);
 			pe_session->assocReqLen = ft_ies_length;
 		}
 	} else {
 		pe_debug("FT IEs not present");
 		pe_session->assocReqLen = 0;
 	}
+#endif
 
 	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
 			 pe_session->peSessionId, mac_hdr->fc.subType));

core/sme/inc/csr_api.h

@@ -996,17 +996,6 @@ struct csr_per_chain_rssi_stats_info {
 	tSirMacAddr peer_mac_addr;
 };
 
-typedef struct tagCsrRoamSetKey {
-	eCsrEncryptionType encType;
-	tAniKeyDirection keyDirection;  /* Tx, Rx or Tx-and-Rx */
-	struct qdf_mac_addr peerMac;    /* Peer MAC. ALL 1's for group key */
-	uint8_t paeRole;        /* 0 for supplicant */
-	uint8_t keyId;          /* Key index */
-	uint16_t keyLength;     /* Number of bytes containing the key in pKey */
-	uint8_t Key[CSR_MAX_KEY_LEN];
-	uint8_t keyRsc[WLAN_CRYPTO_RSC_SIZE];
-} tCsrRoamSetKey;
-
 typedef void *tScanResultHandle;
 
 typedef enum {

core/sme/inc/csr_internal.h

@@ -507,6 +507,7 @@ struct csr_roam_session {
 	enum csr_roaming_reason roamingReason;
 	bool fCancelRoaming;
 	uint8_t bRefAssocStartCnt;      /* Tracking assoc start indication */
+	tftSMEContext ftSmeContext;
 #endif /* ndef FEATURE_CM_ENABLE */
 #ifdef WLAN_BCN_RECV_FEATURE
 	bool is_bcn_recv_start;
@@ -527,7 +528,6 @@ struct csr_roam_session {
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 	struct roam_offload_synch_ind *roam_synch_data;
 #endif
-	tftSMEContext ftSmeContext;
 	bool ch_switch_in_progress;
 	uint8_t nss;
 	bool dhcp_done;

core/sme/inc/sme_ft_api.h

@@ -19,25 +19,9 @@
 #if !defined(__SME_FTAPI_H)
 #define __SME_FTAPI_H
 
-typedef enum eFTIEState {
-	eFT_START_READY,        /* Start before and after 11r assoc */
-	eFT_AUTH_REQ_READY,     /* When we have recvd the 1st or nth auth req */
-	/*
-	 * Sent auth1 and waiting auth2 We are now ready for FT phase,
-	 * send auth1, recd auth2
-	 */
-	eFT_WAIT_AUTH2,
-	eFT_AUTH_COMPLETE,
-	/* Now we have sent Auth Rsp to the supplicant and waiting */
-	/* Reassoc Req from the supplicant. */
-	eFT_REASSOC_REQ_WAIT,
-	/*
-	 * We have received the Reassoc request from supplicant.
-	 * Waiting for the keys.
-	 */
-	eFT_SET_KEY_WAIT,
-} tFTIEStates;
+#ifdef WLAN_FEATURE_HOST_ROAM
 
+#ifndef FEATURE_CM_ENABLE
 /* FT neighbor roam callback user context */
 typedef struct sFTRoamCallbackUsrCtx {
 	struct mac_context *mac;
@@ -45,46 +29,47 @@ typedef struct sFTRoamCallbackUsrCtx {
 } tFTRoamCallbackUsrCtx, *tpFTRoamCallbackUsrCtx;
 
 typedef struct sFTSMEContext {
-	/* Received and processed during pre-auth */
-	uint8_t *auth_ft_ies;
-	uint32_t auth_ft_ies_length;
-	/* Received and processed during re-assoc */
-	uint8_t *reassoc_ft_ies;
-	uint16_t reassoc_ft_ies_length;
-	/* Pre-Auth info */
-	tFTIEStates FTState;    /* The state of FT in the current 11rAssoc */
-	tSirMacAddr preAuthbssId;       /* BSSID to preauth to */
-	uint32_t vdev_id;
 	/* Saved pFTPreAuthRsp */
 	tpSirFTPreAuthRsp psavedFTPreAuthRsp;
-	bool setFTPreAuthState;
-#ifndef FEATURE_CM_ENABLE
 	/* Time to trigger reassoc once pre-auth is successful */
 	qdf_mc_timer_t preAuthReassocIntvlTimer;
-#endif
-	bool addMDIE;
+	tSirMacAddr preAuthbssId;       /* BSSID to preauth to */
 	/* User context for the timer callback */
 	tpFTRoamCallbackUsrCtx pUsrCtx;
 } tftSMEContext, *tpftSMEContext;
 
+
 /*--------------------------------------------------------------------------
   Prototype functions
   ------------------------------------------------------------------------*/
-void sme_ft_open(mac_handle_t mac_handle, uint32_t sessionId);
-void sme_ft_close(mac_handle_t mac_handle, uint32_t sessionId);
-void sme_ft_reset(mac_handle_t mac_handle, uint32_t sessionId);
-void sme_set_ft_ies(mac_handle_t mac_handle, uint32_t sessionId,
-		    const uint8_t *ft_ies, uint16_t ft_ies_length);
-QDF_STATUS sme_ft_update_key(mac_handle_t mac_handle, uint32_t sessionId,
-			     tCsrRoamSetKey *pFTKeyInfo);
-#ifndef FEATURE_CM_ENABLE
-void sme_get_ft_pre_auth_response(mac_handle_t mac_handle, uint32_t sessionId,
+void sme_ft_open(mac_handle_t mac_handle, uint8_t sessionId);
+void sme_ft_close(mac_handle_t mac_handle, uint8_t sessionId);
+void sme_get_ft_pre_auth_response(mac_handle_t mac_handle, uint8_t sessionId,
 				  uint8_t *ft_ies, uint32_t ft_ies_ip_len,
 				  uint16_t *ft_ies_length);
-void sme_get_rici_es(mac_handle_t mac_handle, uint32_t sessionId,
+void sme_get_rici_es(mac_handle_t mac_handle, uint8_t sessionId,
 		     uint8_t *ric_ies,
 		     uint32_t ric_ies_ip_len, uint32_t *ric_ies_length);
-#endif
+void sme_preauth_reassoc_intvl_timer_callback(void *context);
+#endif /* FEATURE_CM_ENABLE */
+
+void sme_ft_reset(mac_handle_t mac_handle, uint8_t sessionId);
+
+/**
+ * sme_set_ft_ies() - to set FT IEs
+ * @mac_handle: opaque handle to the global MAC context
+ * @session_id: sme session id
+ * @ft_ies: pointer to FT IEs
+ * @ft_ies_length: length of FT IEs
+ *
+ * Each time the supplicant sends down the FT IEs to the driver. This function
+ * is called in SME. This function packages and sends the FT IEs to PE.
+ *
+ * Return: none
+ */
+void sme_set_ft_ies(mac_handle_t mac_handle, uint8_t sessionId,
+		    const uint8_t *ft_ies, uint16_t ft_ies_length);
+
 /**
  * sme_check_ft_status() - Check for key wait status in FT mode
  * @mac_handle: MAC handle
@@ -92,9 +77,8 @@ void sme_get_rici_es(mac_handle_t mac_handle, uint32_t sessionId,
  *
  * Return: QDF_STATUS
  */
-QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle, uint32_t session_id);
+QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle, uint8_t session_id);
 
-#ifdef WLAN_FEATURE_HOST_ROAM
 /**
  * sme_ft_key_ready_for_install() - API to check ft key ready for install
  * @mac_handle: MAC handle
@@ -104,14 +88,53 @@ QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle, uint32_t session_id);
  *
  * Return: true when ft key is ready otherwise false
  */
-bool sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint32_t session_id);
-#else
+bool sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint8_t session_id);
+void sme_set_ft_pre_auth_state(mac_handle_t mac_handle, uint8_t sessionId,
+			       bool state);
+bool sme_get_ft_pre_auth_state(mac_handle_t mac_handle, uint8_t sessionId);
+
+#else /* WLAN_FEATURE_HOST_ROAM */
+
+#ifndef FEATURE_CM_ENABLE
+static inline void sme_ft_open(mac_handle_t mac_handle, uint8_t sessionId) {}
+static inline void sme_ft_close(mac_handle_t mac_handle, uint8_t sessionId) {}
+static inline  void sme_get_ft_pre_auth_response(mac_handle_t mac_handle,
+						 uint8_t sessionId,
+						 uint8_t *ft_ies,
+						 uint32_t ft_ies_ip_len,
+						 uint16_t *ft_ies_length) {}
+static inline void sme_get_rici_es(mac_handle_t mac_handle, uint8_t sessionId,
+				   uint8_t *ric_ies,
+				   uint32_t ric_ies_ip_len,
+				   uint32_t *ric_ies_length) {}
+static inline void sme_preauth_reassoc_intvl_timer_callback(void *context) {}
+#endif
+
+static inline void sme_ft_reset(mac_handle_t mac_handle, uint8_t sessionId) {}
+static inline
+void sme_set_ft_ies(mac_handle_t mac_handle, uint8_t sessionId,
+		    const uint8_t *ft_ies, uint16_t ft_ies_length) {}
+
+static inline QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle,
+					     uint8_t session_id)
+{
+	return QDF_STATUS_E_FAILURE;
+}
+
 static inline bool
-sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint32_t session_id)
+sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint8_t session_id)
 {
 	return false;
 }
-#endif
+
+static inline void sme_set_ft_pre_auth_state(mac_handle_t mac_handle,
+					     uint8_t sessionId, bool state) {}
+static inline bool sme_get_ft_pre_auth_state(mac_handle_t mac_handle,
+					     uint8_t sessionId)
+{
+	return false;
+}
+#endif /* WLAN_FEATURE_HOST_ROAM */
 
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 /**
@@ -121,17 +144,9 @@ sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint32_t session_id)
  *
  * Return: None
  */
-void sme_reset_key(mac_handle_t mac_handle, uint32_t vdev_id);
+void sme_reset_key(mac_handle_t mac_handle, uint8_t vdev_id);
 #else
-static inline void sme_reset_key(mac_handle_t mac_handle, uint32_t vdev_id)
-{
-}
-#endif
+static inline void sme_reset_key(mac_handle_t mac_handle, uint8_t vdev_id) {}
+#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
 
-#ifndef FEATURE_CM_ENABLE
-void sme_preauth_reassoc_intvl_timer_callback(void *context);
-#endif
-void sme_set_ft_pre_auth_state(mac_handle_t mac_handle, uint32_t sessionId,
-			       bool state);
-bool sme_get_ft_pre_auth_state(mac_handle_t mac_handle, uint32_t sessionId);
 #endif

core/sme/src/common/sme_ft_api.c

@@ -22,13 +22,14 @@
 #include <csr_neighbor_roam.h>
 #include <sir_api.h>
 
+#ifdef WLAN_FEATURE_HOST_ROAM
+
+#ifndef FEATURE_CM_ENABLE
 /* Initialize the FT context. */
-void sme_ft_open(mac_handle_t mac_handle, uint32_t sessionId)
+void sme_ft_open(mac_handle_t mac_handle, uint8_t sessionId)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-#ifndef FEATURE_CM_ENABLE
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-#endif
 	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
 
 	if (pSession) {
@@ -40,7 +41,6 @@ void sme_ft_open(mac_handle_t mac_handle, uint32_t sessionId)
 		if (!pSession->ftSmeContext.pUsrCtx)
 			return;
 
-#ifndef FEATURE_CM_ENABLE
 		pSession->ftSmeContext.pUsrCtx->mac = mac;
 		pSession->ftSmeContext.pUsrCtx->sessionId = sessionId;
 
@@ -56,22 +56,23 @@ void sme_ft_open(mac_handle_t mac_handle, uint32_t sessionId)
 			pSession->ftSmeContext.pUsrCtx = NULL;
 			return;
 		}
-#endif
 	}
 }
 
 /* Cleanup the SME FT Global context. */
-void sme_ft_close(mac_handle_t mac_handle, uint32_t sessionId)
+void sme_ft_close(mac_handle_t mac_handle, uint8_t sessionId)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 	struct csr_roam_session *pSession = NULL;
 
-	/* Clear the FT Context */
-	sme_ft_reset(mac_handle, sessionId);
-
 	pSession = CSR_GET_SESSION(mac, sessionId);
 	if (pSession) {
-#ifndef FEATURE_CM_ENABLE
+		if (pSession->ftSmeContext.psavedFTPreAuthRsp) {
+			qdf_mem_free(pSession->ftSmeContext.psavedFTPreAuthRsp);
+			pSession->ftSmeContext.psavedFTPreAuthRsp = NULL;
+		}
+		qdf_mem_zero(pSession->ftSmeContext.preAuthbssId,
+			     QDF_MAC_ADDR_SIZE);
 		/* check if the timer is running */
 		if (QDF_TIMER_STATE_RUNNING ==
 		    qdf_mc_timer_get_current_state(&pSession->ftSmeContext.
@@ -82,7 +83,6 @@ void sme_ft_close(mac_handle_t mac_handle, uint32_t sessionId)
 
 		qdf_mc_timer_destroy(&pSession->ftSmeContext.
 					preAuthReassocIntvlTimer);
-#endif
 		if (pSession->ftSmeContext.pUsrCtx) {
 			qdf_mem_free(pSession->ftSmeContext.pUsrCtx);
 			pSession->ftSmeContext.pUsrCtx = NULL;
@@ -90,100 +90,210 @@ void sme_ft_close(mac_handle_t mac_handle, uint32_t sessionId)
 	}
 }
 
-void sme_set_ft_pre_auth_state(mac_handle_t mac_handle, uint32_t sessionId,
-			       bool state)
+/*
+ * HDD Interface to SME. SME now sends the Auth 2 and RIC IEs up to the
+ * supplicant. The supplicant will then proceed to send down the
+ * Reassoc Req.
+ */
+void sme_get_ft_pre_auth_response(mac_handle_t mac_handle, uint8_t sessionId,
+				  uint8_t *ft_ies, uint32_t ft_ies_ip_len,
+				  uint16_t *ft_ies_length)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
+
+	*ft_ies_length = 0;
+
+	if (!pSession) {
+		sme_err("pSession is NULL");
+		return;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
+
+	status = sme_acquire_global_lock(&mac->sme);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto end;
+
+	/* All or nothing - proceed only if both BSSID and FT IE fit */
+	if ((QDF_MAC_ADDR_SIZE +
+	     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length) >
+	    ft_ies_ip_len) {
+		sme_release_global_lock(&mac->sme);
+		goto end;
+	}
+	/* hdd needs to pack the bssid also along with the */
+	/* auth response to supplicant */
+	qdf_mem_copy(ft_ies, pSession->ftSmeContext.preAuthbssId,
+		     QDF_MAC_ADDR_SIZE);
+
+	/* Copy the auth resp FTIEs */
+	qdf_mem_copy(&(ft_ies[QDF_MAC_ADDR_SIZE]),
+		     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies,
+		     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length);
+
+	*ft_ies_length = QDF_MAC_ADDR_SIZE +
+		pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length;
+
+	sme_debug("Filled auth resp: %d", *ft_ies_length);
+	sme_release_global_lock(&mac->sme);
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
-	if (pSession)
-		pSession->ftSmeContext.setFTPreAuthState = state;
 }
 
-bool sme_get_ft_pre_auth_state(mac_handle_t mac_handle, uint32_t sessionId)
+/*
+ * SME now sends the RIC IEs up to the supplicant.
+ * The supplicant will then proceed to send down the
+ * Reassoc Req.
+ */
+void sme_get_rici_es(mac_handle_t mac_handle, uint8_t sessionId,
+		     uint8_t *ric_ies,
+		     uint32_t ric_ies_ip_len, uint32_t *ric_ies_length)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
+
+	*ric_ies_length = 0;
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return;
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv) {
+		goto end;
+	}
+
+	/* All or nothing */
+	if (mlme_priv->connect_info.ft_info.ric_ies_length > ric_ies_ip_len)
+		goto end;
+
+	qdf_mem_copy(ric_ies,
+		     mlme_priv->connect_info.ft_info.ric_ies,
+		     mlme_priv->connect_info.ft_info.ric_ies_length);
+
+	*ric_ies_length = mlme_priv->connect_info.ft_info.ric_ies_length;
 
-	if (pSession)
-		return pSession->ftSmeContext.setFTPreAuthState;
+	sme_debug("Filled ric ies: %d", *ric_ies_length);
+end:
 
-	return false;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
-/**
- * sme_set_ft_ies() - to set FT IEs
- * @mac_handle: opaque handle to the global MAC context
- * @session_id: sme session id
- * @ft_ies: pointer to FT IEs
- * @ft_ies_length: length of FT IEs
- *
- * Each time the supplicant sends down the FT IEs to the driver. This function
- * is called in SME. This function packages and sends the FT IEs to PE.
- *
- * Return: none
+/*
+ * Timer callback for the timer that is started between the preauth completion
+ * and reassoc request to the PE. In this interval, it is expected that the
+ * pre-auth response and RIC IEs are passed up to the WPA supplicant and
+ * received back the necessary FTIEs required to be sent in the reassoc request
  */
-void sme_set_ft_ies(mac_handle_t mac_handle, uint32_t session_id,
+void sme_preauth_reassoc_intvl_timer_callback(void *context)
+{
+	tFTRoamCallbackUsrCtx *pUsrCtx = (tFTRoamCallbackUsrCtx *) context;
+
+	if (pUsrCtx)
+		csr_neighbor_roam_request_handoff(pUsrCtx->mac,
+						  pUsrCtx->sessionId);
+}
+
+#endif
+
+void sme_set_ft_pre_auth_state(mac_handle_t mac_handle, uint8_t sessionId,
+			       bool state)
+{
+	struct mac_context *mac = MAC_CONTEXT(mac_handle);
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
+
+	mlme_priv->connect_info.ft_info.set_ft_preauth_state = state;
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+}
+
+bool sme_get_ft_pre_auth_state(mac_handle_t mac_handle, uint8_t sessionId)
+{
+	struct mac_context *mac = MAC_CONTEXT(mac_handle);
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
+	bool val = false;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return val;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
+
+	val = mlme_priv->connect_info.ft_info.set_ft_preauth_state;
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+
+	return val;
+}
+
+void sme_set_ft_ies(mac_handle_t mac_handle, uint8_t session_id,
 		    const uint8_t *ft_ies, uint16_t ft_ies_length)
 {
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *session = CSR_GET_SESSION(mac_ctx, session_id);
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
-	if (!session || !ft_ies) {
-		sme_err("ft ies or session is NULL");
+	if (!ft_ies) {
+		sme_err("ft ies is NULL");
 		return;
 	}
 
-	status = sme_acquire_global_lock(&mac_ctx->sme);
-	if (!(QDF_IS_STATUS_SUCCESS(status)))
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, session_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
 		return;
 
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
+
+	status = sme_acquire_global_lock(&mac_ctx->sme);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto end;
+
 	sme_debug("FT IEs Req is received in state %d",
-		  session->ftSmeContext.FTState);
+		  mlme_priv->connect_info.ft_info.ft_state);
 
 	/* Global Station FT State */
-	switch (session->ftSmeContext.FTState) {
-	case eFT_START_READY:
-	case eFT_AUTH_REQ_READY:
+	switch (mlme_priv->connect_info.ft_info.ft_state) {
+	case FT_START_READY:
+	case FT_AUTH_REQ_READY:
 		sme_debug("ft_ies_length: %d", ft_ies_length);
-		if ((session->ftSmeContext.auth_ft_ies) &&
-			(session->ftSmeContext.auth_ft_ies_length)) {
-			/* Free the one we recvd last from supplicant */
-			qdf_mem_free(session->ftSmeContext.auth_ft_ies);
-			session->ftSmeContext.auth_ft_ies_length = 0;
-			session->ftSmeContext.auth_ft_ies = NULL;
-		}
 		ft_ies_length = QDF_MIN(ft_ies_length, MAX_FTIE_SIZE);
-		/* Save the FT IEs */
-		session->ftSmeContext.auth_ft_ies =
-					qdf_mem_malloc(ft_ies_length);
-		if (!session->ftSmeContext.auth_ft_ies) {
-			sme_release_global_lock(&mac_ctx->sme);
-			return;
-		}
-		session->ftSmeContext.auth_ft_ies_length = ft_ies_length;
-		qdf_mem_copy((uint8_t *)session->ftSmeContext.auth_ft_ies,
-				ft_ies, ft_ies_length);
-		session->ftSmeContext.FTState = eFT_AUTH_REQ_READY;
-		break;
-
-	case eFT_AUTH_COMPLETE:
-		/*
-		 * We will need to re-start preauth. If we received FT
-		 * IEs in eFT_PRE_AUTH_DONE state, it implies there was
-		 * a rekey in our pre-auth state. Hence this implies we
-		 * need Pre-auth again. OK now inform SME we have no
-		 * pre-auth list. Delete the pre-auth node locally. Set
-		 * your self back to restart pre-auth
-		 */
-		sme_debug("Preauth done & rcving AUTHREQ in state %d",
-			  session->ftSmeContext.FTState);
-		sme_debug("Unhandled reception of FT IES in state %d",
-			  session->ftSmeContext.FTState);
+		mlme_priv->connect_info.ft_info.auth_ie_len = ft_ies_length;
+		qdf_mem_copy(mlme_priv->connect_info.ft_info.auth_ft_ie,
+			     ft_ies, ft_ies_length);
+		mlme_priv->connect_info.ft_info.ft_state = FT_AUTH_REQ_READY;
 		break;
 
-	case eFT_REASSOC_REQ_WAIT:
+	case FT_REASSOC_REQ_WAIT:
 		/*
 		 * We are done with pre-auth, hence now waiting for
 		 * reassoc req. This is the new FT Roaming in place At
@@ -193,208 +303,136 @@ void sme_set_ft_ies(mac_handle_t mac_handle, uint32_t session_id,
 		ft_ies_length = QDF_MIN(ft_ies_length, MAX_FTIE_SIZE);
 
 		sme_debug("New Reassoc Req: %pK in state %d",
-			ft_ies, session->ftSmeContext.FTState);
-		if ((session->ftSmeContext.reassoc_ft_ies) &&
-			(session->ftSmeContext.reassoc_ft_ies_length)) {
-			/* Free the one we recvd last from supplicant */
-			qdf_mem_free(session->ftSmeContext.reassoc_ft_ies);
-			session->ftSmeContext.reassoc_ft_ies_length = 0;
-		}
-		/* Save the FT IEs */
-		session->ftSmeContext.reassoc_ft_ies =
-					qdf_mem_malloc(ft_ies_length);
-		if (!session->ftSmeContext.reassoc_ft_ies) {
-			sme_release_global_lock(&mac_ctx->sme);
-			return;
-		}
-		session->ftSmeContext.reassoc_ft_ies_length =
+			ft_ies, mlme_priv->connect_info.ft_info.ft_state);
+		mlme_priv->connect_info.ft_info.reassoc_ie_len =
 							ft_ies_length;
-		qdf_mem_copy((uint8_t *)session->ftSmeContext.reassoc_ft_ies,
+		qdf_mem_copy(mlme_priv->connect_info.ft_info.reassoc_ft_ie,
 				ft_ies, ft_ies_length);
 
-		session->ftSmeContext.FTState = eFT_SET_KEY_WAIT;
+		mlme_priv->connect_info.ft_info.ft_state = FT_SET_KEY_WAIT;
 		sme_debug("ft_ies_length: %d state: %d", ft_ies_length,
-			  session->ftSmeContext.FTState);
-
+			  mlme_priv->connect_info.ft_info.ft_state);
 		break;
 
 	default:
-		sme_warn("Unhandled state: %d", session->ftSmeContext.FTState);
+		sme_warn("Unhandled state: %d",
+			 mlme_priv->connect_info.ft_info.ft_state);
 		break;
 	}
 	sme_release_global_lock(&mac_ctx->sme);
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
-QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle, uint32_t session_id)
+QDF_STATUS sme_check_ft_status(mac_handle_t mac_handle, uint8_t session_id)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *session = CSR_GET_SESSION(mac, session_id);
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
-	if (!session) {
-		sme_err("pSession is NULL");
-		return QDF_STATUS_E_FAILURE;
-	}
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, session_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return status;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
 
 	status = sme_acquire_global_lock(&mac->sme);
-	if (!(QDF_IS_STATUS_SUCCESS(status)))
-		return QDF_STATUS_E_FAILURE;
+	if (QDF_IS_STATUS_ERROR(status))
+		goto end;
 
 	sme_debug("FT update key is received in state %d",
-		  session->ftSmeContext.FTState);
+		  mlme_priv->connect_info.ft_info.ft_state);
 
 	/* Global Station FT State */
-	switch (session->ftSmeContext.FTState) {
-	case eFT_SET_KEY_WAIT:
-		if (sme_get_ft_pre_auth_state(mac_handle, session_id) == true) {
-			session->ftSmeContext.FTState = eFT_START_READY;
-			sme_debug("state changed to %d status %d",
-				  session->ftSmeContext.FTState, status);
-			sme_release_global_lock(&mac->sme);
-			return QDF_STATUS_SUCCESS;
+	switch (mlme_priv->connect_info.ft_info.ft_state) {
+	case FT_SET_KEY_WAIT:
+		if (sme_get_ft_pre_auth_state(mac_handle, session_id)) {
+			mlme_priv->connect_info.ft_info.ft_state = FT_START_READY;
+			sme_debug("state changed to %d",
+				  mlme_priv->connect_info.ft_info.ft_state);
+			break;
 		}
 		/* fallthrough */
 	default:
-		sme_debug("Unhandled state:%d", session->ftSmeContext.FTState);
+		sme_debug("Unhandled state:%d",
+			  mlme_priv->connect_info.ft_info.ft_state);
 		status = QDF_STATUS_E_FAILURE;
 		break;
 	}
 	sme_release_global_lock(&mac->sme);
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	return status;
 }
 
-#ifdef WLAN_FEATURE_HOST_ROAM
-bool sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint32_t session_id)
+bool sme_ft_key_ready_for_install(mac_handle_t mac_handle, uint8_t session_id)
 {
 	bool ret = false;
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *session = CSR_GET_SESSION(mac, session_id);
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
-	if (!session) {
-		sme_err("csr session is NULL");
-		return false;
-	}
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, session_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return ret;
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
 
 	if (sme_get_ft_pre_auth_state(mac_handle, session_id) &&
-	    session->ftSmeContext.FTState == eFT_START_READY) {
+	    mlme_priv->connect_info.ft_info.ft_state == FT_START_READY) {
 		ret = true;
 		sme_set_ft_pre_auth_state(mac_handle, session_id, false);
 	}
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 
 	return ret;
 }
-#endif
 
-#ifndef FEATURE_CM_ENABLE
-/*
- * HDD Interface to SME. SME now sends the Auth 2 and RIC IEs up to the
- * supplicant. The supplicant will then proceed to send down the
- * Reassoc Req.
- */
-void sme_get_ft_pre_auth_response(mac_handle_t mac_handle, uint32_t sessionId,
-				  uint8_t *ft_ies, uint32_t ft_ies_ip_len,
-				  uint16_t *ft_ies_length)
+/* Reset the FT context. */
+void sme_ft_reset(mac_handle_t mac_handle, uint8_t sessionId)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
-	QDF_STATUS status = QDF_STATUS_E_FAILURE;
-
-	if (!pSession) {
-		sme_err("pSession is NULL");
-		return;
-	}
-
-	*ft_ies_length = 0;
-
-	status = sme_acquire_global_lock(&mac->sme);
-	if (!(QDF_IS_STATUS_SUCCESS(status)))
-		return;
+	struct csr_roam_session *pSession = NULL;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
-	/* All or nothing - proceed only if both BSSID and FT IE fit */
-	if ((QDF_MAC_ADDR_SIZE +
-	     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length) >
-	    ft_ies_ip_len) {
-		sme_release_global_lock(&mac->sme);
+	pSession = CSR_GET_SESSION(mac, sessionId);
+	if (!pSession)
 		return;
-	}
-	/* hdd needs to pack the bssid also along with the */
-	/* auth response to supplicant */
-	qdf_mem_copy(ft_ies, pSession->ftSmeContext.preAuthbssId,
-		     QDF_MAC_ADDR_SIZE);
-
-	/* Copy the auth resp FTIEs */
-	qdf_mem_copy(&(ft_ies[QDF_MAC_ADDR_SIZE]),
-		     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies,
-		     pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length);
-
-	*ft_ies_length = QDF_MAC_ADDR_SIZE +
-		pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length;
-
-	pSession->ftSmeContext.FTState = eFT_REASSOC_REQ_WAIT;
-
-	sme_debug("Filled auth resp: %d", *ft_ies_length);
-	sme_release_global_lock(&mac->sme);
-}
-
-/*
- * SME now sends the RIC IEs up to the supplicant.
- * The supplicant will then proceed to send down the
- * Reassoc Req.
- */
-void sme_get_rici_es(mac_handle_t mac_handle, uint32_t sessionId,
-		     uint8_t *ric_ies,
-		     uint32_t ric_ies_ip_len, uint32_t *ric_ies_length)
-{
-	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
-	QDF_STATUS status = QDF_STATUS_E_FAILURE;
-
-	if (!pSession) {
-		sme_err("pSession is NULL");
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac->pdev, sessionId,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
 		return;
-	}
-
-	*ric_ies_length = 0;
 
-	status = sme_acquire_global_lock(&mac->sme);
-	if (!(QDF_IS_STATUS_SUCCESS(status)))
-		return;
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
 
-	/* All or nothing */
-	if (pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length >
-	    ric_ies_ip_len) {
-		sme_release_global_lock(&mac->sme);
-		return;
+	qdf_mem_zero(&mlme_priv->connect_info.ft_info,
+		     sizeof(struct ft_context));
+#ifndef FEATURE_CM_ENABLE
+	if (pSession->ftSmeContext.psavedFTPreAuthRsp) {
+		qdf_mem_free(pSession->ftSmeContext.psavedFTPreAuthRsp);
+		pSession->ftSmeContext.psavedFTPreAuthRsp = NULL;
 	}
-
-	qdf_mem_copy(ric_ies,
-		     pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies,
-		     pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length);
-
-	*ric_ies_length =
-		pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length;
-
-	sme_debug("Filled ric ies: %d", *ric_ies_length);
-
-	sme_release_global_lock(&mac->sme);
+	qdf_mem_zero(pSession->ftSmeContext.preAuthbssId,
+		     QDF_MAC_ADDR_SIZE);
+#endif
+	mlme_priv->connect_info.ft_info.ft_state = FT_START_READY;
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
-/*
- * Timer callback for the timer that is started between the preauth completion
- * and reassoc request to the PE. In this interval, it is expected that the
- * pre-auth response and RIC IEs are passed up to the WPA supplicant and
- * received back the necessary FTIEs required to be sent in the reassoc request
- */
-void sme_preauth_reassoc_intvl_timer_callback(void *context)
-{
-	tFTRoamCallbackUsrCtx *pUsrCtx = (tFTRoamCallbackUsrCtx *) context;
-
-	if (pUsrCtx)
-		csr_neighbor_roam_request_handoff(pUsrCtx->mac,
-						  pUsrCtx->sessionId);
-}
-#endif
+#endif /* WLAN_FEATURE_HOST_ROAM */
 
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 #ifdef FEATURE_WLAN_ESE
@@ -426,7 +464,8 @@ static void sme_reset_esecckm_info(struct mac_context *mac, uint8_t vdev_id)
 {
 }
 #endif
-void sme_reset_key(mac_handle_t mac_handle, uint32_t vdev_id)
+
+void sme_reset_key(mac_handle_t mac_handle, uint8_t vdev_id)
 {
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 
@@ -438,43 +477,4 @@ void sme_reset_key(mac_handle_t mac_handle, uint32_t vdev_id)
 	wlan_cm_set_psk_pmk(mac->pdev, vdev_id, NULL, 0);
 	sme_reset_esecckm_info(mac, vdev_id);
 }
-#endif
-/* Reset the FT context. */
-void sme_ft_reset(mac_handle_t mac_handle, uint32_t sessionId)
-{
-	struct mac_context *mac = MAC_CONTEXT(mac_handle);
-	struct csr_roam_session *pSession = NULL;
-
-	if (!mac) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  FL("mac is NULL"));
-		return;
-	}
-
-	pSession = CSR_GET_SESSION(mac, sessionId);
-	if (pSession) {
-		if (pSession->ftSmeContext.auth_ft_ies) {
-			qdf_mem_free(pSession->ftSmeContext.auth_ft_ies);
-			pSession->ftSmeContext.auth_ft_ies = NULL;
-		}
-		pSession->ftSmeContext.auth_ft_ies_length = 0;
-
-		if (pSession->ftSmeContext.reassoc_ft_ies) {
-			qdf_mem_free(pSession->ftSmeContext.reassoc_ft_ies);
-			pSession->ftSmeContext.reassoc_ft_ies = NULL;
-		}
-		pSession->ftSmeContext.reassoc_ft_ies_length = 0;
-
-		if (pSession->ftSmeContext.psavedFTPreAuthRsp) {
-			qdf_mem_free(pSession->ftSmeContext.psavedFTPreAuthRsp);
-			pSession->ftSmeContext.psavedFTPreAuthRsp = NULL;
-		}
-		pSession->ftSmeContext.setFTPreAuthState = false;
-
-		qdf_mem_zero(pSession->ftSmeContext.preAuthbssId,
-			     QDF_MAC_ADDR_SIZE);
-		pSession->ftSmeContext.FTState = eFT_START_READY;
-	}
-}
-
-/* End of File */
+#endif /* WLAN_FEATURE_ROAM_OFFLOAD */

core/sme/src/csr/csr_api_roam.c

@@ -12434,20 +12434,7 @@ static inline void csr_qos_send_assoc_ind(struct mac_context *mac_ctx,
 	sme_qos_csr_event_ind(mac_ctx, vdev_id, SME_QOS_CSR_ASSOC_COMPLETE,
 			      assoc_info);
 }
-#else
-static inline void csr_qos_send_disconnect_ind(struct mac_context *mac_ctx,
-					       uint8_t vdev_id)
-{
-}
 
-static inline void csr_qos_send_assoc_ind(struct mac_context *mac_ctx,
-					  uint8_t vdev_id,
-					  sme_QosAssocInfo *assoc_info)
-{
-}
-#endif
-
-#ifdef WLAN_FEATURE_ROAM_OFFLOAD
 static void
 csr_qos_send_reassoc_ind(struct mac_context *mac_ctx,
 			 uint8_t vdev_id,
@@ -12470,6 +12457,14 @@ csr_qos_send_reassoc_ind(struct mac_context *mac_ctx,
 				      NULL);
 }
 #else
+static inline void csr_qos_send_disconnect_ind(struct mac_context *mac_ctx,
+					       uint8_t vdev_id)
+{}
+
+static inline void csr_qos_send_assoc_ind(struct mac_context *mac_ctx,
+					  uint8_t vdev_id,
+					  sme_QosAssocInfo *assoc_info)
+{}
 static inline void
 csr_qos_send_reassoc_ind(struct mac_context *mac_ctx,
 			 uint8_t vdev_id,
@@ -14113,13 +14108,11 @@ QDF_STATUS csr_setup_vdev_session(struct vdev_mlme_obj *vdev_mlme)
 	session->sessionActive = true;
 	session->sessionId = vdev_id;
 
-	/* Initialize FT related data structures only in STA mode */
-	sme_ft_open(MAC_HANDLE(mac_ctx), session->sessionId);
-
-
 	qdf_mem_copy(&session->self_mac_addr, mac_addr,
 		     sizeof(struct qdf_mac_addr));
 #ifndef FEATURE_CM_ENABLE
+	/* Initialize FT related data structures only in STA mode */
+	sme_ft_open(MAC_HANDLE(mac_ctx), session->sessionId);
 	status = qdf_mc_timer_init(&session->hTimerRoaming,
 				   QDF_TIMER_TYPE_SW,
 				   csr_roam_roaming_timer_handler,
@@ -14193,9 +14186,9 @@ void csr_cleanup_vdev_session(struct mac_context *mac, uint8_t vdev_id)
 #ifndef FEATURE_CM_ENABLE
 		csr_roam_stop_roaming_timer(mac, vdev_id);
 		csr_free_connect_bss_desc(mac, vdev_id);
-#endif
 		/* Clean up FT related data structures */
 		sme_ft_close(MAC_HANDLE(mac), vdev_id);
+#endif
 		csr_flush_roam_scan_chan_lists(mac, vdev_id);
 		csr_roam_free_connect_profile(&pSession->connectedProfile);
 		csr_roam_free_connected_info(mac, &pSession->connectedInfo);

core/sme/src/csr/csr_roam_preauth.c

@@ -529,6 +529,8 @@ QDF_STATUS csr_roam_issue_ft_preauth_req(struct mac_context *mac_ctx,
 	QDF_STATUS status;
 	struct csr_roam_session *csr_session = CSR_GET_SESSION(mac_ctx,
 				vdev_id);
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
 	if (!csr_session) {
 		sme_err("Session does not exist for vdev_id: %d", vdev_id);
@@ -552,9 +554,22 @@ QDF_STATUS csr_roam_issue_ft_preauth_req(struct mac_context *mac_ctx,
 		qdf_mem_free(preauth_req);
 		return QDF_STATUS_E_NOMEM;
 	}
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, vdev_id,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev) {
+		qdf_mem_free(preauth_req);
+		qdf_mem_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv) {
+		qdf_mem_free(preauth_req);
+		qdf_mem_free(buf);
+		status = QDF_STATUS_E_FAILURE;
+		goto end;
+	}
 
-	/* Save the SME Session ID. We need it while processing preauth resp */
-	csr_session->ftSmeContext.vdev_id = vdev_id;
 	preauth_req->messageType = eWNI_SME_FT_PRE_AUTH_REQ;
 	preauth_req->pre_auth_channel_freq = bss_desc->chan_freq;
 	preauth_req->dot11mode = dot11mode;
@@ -568,12 +583,13 @@ QDF_STATUS csr_roam_issue_ft_preauth_req(struct mac_context *mac_ctx,
 
 	if (csr_roam_is11r_assoc(mac_ctx, vdev_id) &&
 	     (mac_ctx->roam.roamSession[vdev_id].connectedProfile.AuthType !=
-	      eCSR_AUTH_TYPE_OPEN_SYSTEM)) {
+	      eCSR_AUTH_TYPE_OPEN_SYSTEM) &&
+	      mlme_priv->connect_info.ft_info.auth_ie_len) {
 		preauth_req->ft_ies_length =
-			(uint16_t) csr_session->ftSmeContext.auth_ft_ies_length;
+			mlme_priv->connect_info.ft_info.auth_ie_len;
 		qdf_mem_copy(preauth_req->ft_ies,
-				csr_session->ftSmeContext.auth_ft_ies,
-				csr_session->ftSmeContext.auth_ft_ies_length);
+			     mlme_priv->connect_info.ft_info.auth_ft_ie,
+			     mlme_priv->connect_info.ft_info.auth_ie_len);
 	} else {
 		preauth_req->ft_ies_length = 0;
 	}
@@ -585,6 +601,9 @@ QDF_STATUS csr_roam_issue_ft_preauth_req(struct mac_context *mac_ctx,
 	if (QDF_IS_STATUS_ERROR(status))
 		qdf_mem_free(buf);
 
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+
 	return status;
 }
 
@@ -598,6 +617,8 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 	struct csr_roam_session *csr_session = CSR_GET_SESSION(mac_ctx,
 				vdev_id);
 	tDot11fAuthentication *p_auth = NULL;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
 	if (!csr_session) {
 		sme_err("CSR session is NULL");
@@ -613,7 +634,15 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 
 	if (QDF_STATUS_SUCCESS != (QDF_STATUS) preauth_rsp->status)
 		return;
-	csr_session->ftSmeContext.FTState = eFT_AUTH_COMPLETE;
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev,
+						   preauth_rsp->vdev_id,
+						   WLAN_LEGACY_SME_ID);
+	if (!vdev)
+		return;
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv)
+		goto end;
+	mlme_priv->connect_info.ft_info.ft_state = FT_REASSOC_REQ_WAIT;
 	csr_session->ftSmeContext.psavedFTPreAuthRsp = preauth_rsp;
 	/* No need to notify qos module if this is a non 11r & ESE roam */
 	if (csr_roam_is11r_assoc(mac_ctx, preauth_rsp->vdev_id)
@@ -622,7 +651,7 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 #endif
 	   ) {
 		sme_qos_csr_event_ind(mac_ctx,
-			csr_session->ftSmeContext.vdev_id,
+			preauth_rsp->vdev_id,
 			SME_QOS_CSR_PREAUTH_SUCCESS_IND, NULL);
 	}
 	status =
@@ -632,12 +661,12 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 	if (QDF_STATUS_SUCCESS != status) {
 		sme_err("PreauthReassocInterval timer failed status %d",
 			status);
-		return;
+		goto end;
 	}
 
 	roam_info = qdf_mem_malloc(sizeof(*roam_info));
 	if (!roam_info)
-		return;
+		goto end;
 	qdf_mem_copy((void *)&csr_session->ftSmeContext.preAuthbssId,
 		(void *)preauth_rsp->preAuthbssId,
 		sizeof(struct qdf_mac_addr));
@@ -674,28 +703,23 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 	conn_Auth_type =
 		mac_ctx->roam.roamSession[vdev_id].connectedProfile.AuthType;
 
-	csr_session->ftSmeContext.addMDIE = false;
-
 	/* Done with it, init it. */
 	csr_session->ftSmeContext.psavedFTPreAuthRsp = NULL;
-
+	mlme_priv->connect_info.ft_info.add_mdie = false;
 	if (csr_roam_is11r_assoc(mac_ctx, preauth_rsp->vdev_id) &&
 			(conn_Auth_type == eCSR_AUTH_TYPE_OPEN_SYSTEM)) {
 		uint16_t ft_ies_length;
 
-		ft_ies_length = preauth_rsp->ric_ies_length;
+		ft_ies_length = mlme_priv->connect_info.ft_info.ric_ies_length;
 
-		if ((csr_session->ftSmeContext.reassoc_ft_ies) &&
-			(csr_session->ftSmeContext.reassoc_ft_ies_length)) {
-			qdf_mem_free(csr_session->ftSmeContext.reassoc_ft_ies);
-			csr_session->ftSmeContext.reassoc_ft_ies_length = 0;
-			csr_session->ftSmeContext.reassoc_ft_ies = NULL;
-		}
+		qdf_mem_zero(mlme_priv->connect_info.ft_info.reassoc_ft_ie,
+			     MAX_FTIE_SIZE);
+		mlme_priv->connect_info.ft_info.reassoc_ie_len = 0;
 		p_auth = (tDot11fAuthentication *) qdf_mem_malloc(
 						sizeof(tDot11fAuthentication));
 
 		if (!p_auth)
-			return;
+			goto end;
 
 		status = dot11f_unpack_authentication(mac_ctx,
 				preauth_rsp->ft_ies,
@@ -703,26 +727,23 @@ void csr_roam_ft_pre_auth_rsp_processor(struct mac_context *mac_ctx,
 		if (DOT11F_FAILED(status))
 			sme_err("Failed to parse an Authentication frame");
 		else if (p_auth->MobilityDomain.present)
-			csr_session->ftSmeContext.addMDIE = true;
+			mlme_priv->connect_info.ft_info.add_mdie = true;
 
 		qdf_mem_free(p_auth);
 
 		if (!ft_ies_length)
-			return;
-
-		csr_session->ftSmeContext.reassoc_ft_ies =
-			qdf_mem_malloc(ft_ies_length);
-		if (!csr_session->ftSmeContext.reassoc_ft_ies)
-			return;
+			goto end;
 
 		/* Copy the RIC IEs to reassoc IEs */
-		qdf_mem_copy(((uint8_t *) csr_session->ftSmeContext.
-					reassoc_ft_ies),
-					(uint8_t *) preauth_rsp->ric_ies,
-					preauth_rsp->ric_ies_length);
-		csr_session->ftSmeContext.reassoc_ft_ies_length = ft_ies_length;
-		csr_session->ftSmeContext.addMDIE = true;
+		qdf_mem_copy(mlme_priv->connect_info.ft_info.reassoc_ft_ie,
+			     mlme_priv->connect_info.ft_info.ric_ies,
+			     mlme_priv->connect_info.ft_info.ric_ies_length);
+		mlme_priv->connect_info.ft_info.reassoc_ie_len = ft_ies_length;
+		mlme_priv->connect_info.ft_info.add_mdie = true;
 	}
+
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
 }
 
 /**

core/sme/src/qos/sme_qos.c

@@ -3149,6 +3149,7 @@ uint8_t sme_qos_ese_retrieve_tspec_info(struct mac_context *mac_ctx,
 
 #endif
 
+#ifdef WLAN_FEATURE_HOST_ROAM
 static
 QDF_STATUS sme_qos_create_tspec_ricie(struct mac_context *mac,
 				      struct sme_qos_wmmtspecinfo *tspec_info,
@@ -3262,6 +3263,8 @@ QDF_STATUS sme_qos_create_tspec_ricie(struct mac_context *mac,
 	qdf_mem_free(ric_ie);
 	return status;
 }
+#endif
+
 /**
  * sme_qos_process_ft_reassoc_req_ev()- processes reassoc request
  *
@@ -5067,6 +5070,7 @@ static QDF_STATUS sme_qos_process_join_req_ev(struct mac_context *mac, uint8_t
 	return QDF_STATUS_SUCCESS;
 }
 
+#ifdef WLAN_FEATURE_HOST_ROAM
 /**
  * sme_qos_process_preauth_success_ind() - process preauth success indication
  * @mac_ctx: global MAC context
@@ -5092,6 +5096,8 @@ static QDF_STATUS sme_qos_process_preauth_success_ind(struct mac_context *mac_ct
 	uint8_t *ric_ie;
 	uint8_t tspec_mask_status = 0;
 	uint8_t tspec_pending_status = 0;
+	struct wlan_objmgr_vdev *vdev;
+	struct mlme_legacy_priv *mlme_priv;
 
 	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
 		  FL("invoked on SME session %d"), sessionid);
@@ -5131,11 +5137,14 @@ static QDF_STATUS sme_qos_process_preauth_success_ind(struct mac_context *mac_ct
 	if (!csr_roam_is11r_assoc(mac_ctx, sessionid))
 		return status;
 
-	/* Data is accessed from saved PreAuth Rsp */
-	if (!sme_session->ftSmeContext.psavedFTPreAuthRsp) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  FL("psavedFTPreAuthRsp is NULL"));
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(mac_ctx->pdev, sessionid,
+						    WLAN_LEGACY_SME_ID);
+	if (!vdev)
 		return QDF_STATUS_E_INVAL;
+	mlme_priv = wlan_vdev_mlme_get_ext_hdl(vdev);
+	if (!mlme_priv) {
+		status = QDF_STATUS_E_FAILURE;
+		goto end;
 	}
 
 	/*
@@ -5144,9 +5153,11 @@ static QDF_STATUS sme_qos_process_preauth_success_ind(struct mac_context *mac_ct
 	 * length of the whole RIC IEs. Filling of TSPEC info should start
 	 * from this length
 	 */
-	ric_ie = sme_session->ftSmeContext.psavedFTPreAuthRsp->ric_ies;
-	ric_offset =
-		sme_session->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length;
+	qdf_mem_zero(mlme_priv->connect_info.ft_info.ric_ies, MAX_FTIE_SIZE);
+	mlme_priv->connect_info.ft_info.ric_ies_length = 0;
+
+	ric_ie = mlme_priv->connect_info.ft_info.ric_ies;
+	ric_offset = mlme_priv->connect_info.ft_info.ric_ies_length;
 
 	/*
 	 * Now we have to process the currentTspeInfo inside this session and
@@ -5186,16 +5197,25 @@ static QDF_STATUS sme_qos_process_preauth_success_ind(struct mac_context *mac_ct
 			}
 add_next_ric:
 			ric_offset += ric_ielen;
-			sme_session->ftSmeContext.psavedFTPreAuthRsp->
-				ric_ies_length += ric_ielen;
+			mlme_priv->connect_info.ft_info.ric_ies_length = ric_ielen;
 			tspec_mask_status >>= 1;
 			tspec_pending_status >>= 1;
 			tspec_idx++;
 		} while (tspec_mask_status);
 	}
+end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_SME_ID);
+
 	return status;
 }
-
+#else
+static inline
+QDF_STATUS sme_qos_process_preauth_success_ind(struct mac_context *mac_ctx,
+				uint8_t sessionid, void *event_info)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
 /*
  * sme_qos_process_add_ts_failure_rsp() - Function to process the
  *  Addts request failure response came from PE