qcacmn: Add support to send PASN commands

Add support to send below PASN commands:
WMI_RTT_PASN_AUTH_STATUS_CMD
WMI_RTT_PASN_DEAUTH_CMD
WMI_VDEV_SET_LTF_KEY_SEED_CMDID

Change-Id: I5a50a634317d0a692feee5be5a36da22b4c5d713
CRs-Fixed: 3154530

umac/cmn_services/cmn_defs/inc/wlan_cmn_ieee80211.h

@@ -1019,6 +1019,9 @@ enum wlan_status_code {
 #define KCK_192BIT_KEY_LEN 24
 #define KEK_256BIT_KEY_LEN 32
 
+#define WLAN_MAX_SECURE_LTF_KEYSEED_LEN 48
+#define WLAN_MIN_SECURE_LTF_KEYSEED_LEN 32
+
 #define WLAN_WPA_OUI 0xf25000
 #define WLAN_WPA_OUI_TYPE 0x01
 #define WPA_VERSION 1

umac/cmn_services/crypto/inc/wlan_crypto_global_api.h

@@ -967,6 +967,19 @@ static inline void wlan_crypto_reset_vdev_prarams(struct wlan_objmgr_vdev *vdev)
 }
 #endif /* CRYPTO_SET_KEY_CONVERGED */
 
+/**
+ * wlan_crypto_vdev_set_param() - Send vdev set param to firmware.
+ * @psoc: Pointer to PSOC object
+ * @vdev_id: vdev id
+ * @param_id: Param id
+ * @param_value: Param value
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wlan_crypto_vdev_set_param(struct wlan_objmgr_psoc *psoc, uint32_t vdev_id,
+			   uint32_t param_id, uint32_t param_value);
+
 /**
  * wlan_crypto_get_peer_pmksa() - called to get pmksa based on pmksa parameter
  * @vdev: vdev
@@ -1101,6 +1114,19 @@ wlan_crypto_set_sae_single_pmk_info(struct wlan_objmgr_vdev *vdev,
 }
 #endif
 
+#if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+QDF_STATUS
+wlan_crypto_set_ltf_keyseed(struct wlan_objmgr_psoc *psoc,
+			    struct wlan_crypto_ltf_keyseed_data *data);
+#else
+static inline QDF_STATUS
+wlan_crypto_set_ltf_keyseed(struct wlan_objmgr_psoc *psoc,
+			    struct wlan_crypto_ltf_keyseed_data *data)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
 #ifdef WLAN_FEATURE_FILS_SK
 /**
  * lim_create_fils_rik()- This API create rik using rrk coming from

umac/cmn_services/crypto/inc/wlan_crypto_global_def.h

@@ -193,6 +193,22 @@ enum wlan_crypto_rsnx_cap {
 	WLAN_CRYPTO_RSNX_CAP_PROTECTED_TWT = 0x10,
 	WLAN_CRYPTO_RSNX_CAP_SAE_H2E = 0x20,
 	WLAN_CRYPTO_RSNX_CAP_SAE_PK = 0x40,
+	WLAN_CRYPTO_RSNX_CAP_SECURE_LTF = 0x400,
+	WLAN_CRYPTO_RSNX_CAP_SECURE_RTT = 0x1000,
+	WLAN_CRYPTO_RSNX_CAP_URNM_MFPR = 0x2000,
+};
+
+/**
+ * wlan_crypto_vdev_pasn_caps  - PASN peer related vdev
+ * crypto parameters
+ * @WLAN_CRYPTO_URNM_MFPR: URNM MFP required in RSNXE
+ * @WLAN_CRYPTO_MFPC: MFP capable bit from RSN IE
+ * @WLAN_CRYPTO_MFPR: MFP required from RSNIE
+ */
+enum wlan_crypto_vdev_pasn_caps {
+	WLAN_CRYPTO_URNM_MFPR = BIT(0),
+	WLAN_CRYPTO_MFPC = BIT(1),
+	WLAN_CRYPTO_MFPR = BIT(2),
 };
 
 typedef enum wlan_crypto_key_mgmt {
@@ -323,6 +339,24 @@ struct wlan_crypto_params {
 	uint16_t rsn_caps;
 };
 
+/**
+ * struct wlan_crypto_ltf_keyseed_data - LTF keyseed parameters
+ * @vdev_id: Vdev id
+ * @peer_mac_addr: Peer mac address
+ * @src_mac_addr: Source mac address
+ * @rsn_authmode: Cipher suite
+ * @key_seed: Secure LTF key seed
+ * @key_seed_len: Key seed length
+ */
+struct wlan_crypto_ltf_keyseed_data {
+	uint8_t vdev_id;
+	struct qdf_mac_addr peer_mac_addr;
+	struct qdf_mac_addr src_mac_addr;
+	uint8_t rsn_authmode;
+	uint8_t key_seed[WLAN_MAX_SECURE_LTF_KEYSEED_LEN];
+	uint16_t key_seed_len;
+};
+
 typedef enum wlan_crypto_param_type {
 	WLAN_CRYPTO_PARAM_AUTH_MODE,
 	WLAN_CRYPTO_PARAM_UCAST_CIPHER,
@@ -342,6 +376,7 @@ typedef enum wlan_crypto_param_type {
  * @keyix:          key id
  * @cipher_type:    cipher type being used for this key
  * @mac_addr:       MAC address of the peer
+ * @src_addr:       Source mac address associated with the key
  * @cipher_table:   table which stores cipher related info
  * @private:        private pointer to save cipher context
  * @keylock:        spin lock
@@ -363,6 +398,7 @@ struct wlan_crypto_key {
 	uint16_t    keyix;
 	enum wlan_crypto_cipher_type cipher_type;
 	uint8_t     macaddr[QDF_MAC_ADDR_SIZE];
+	struct qdf_mac_addr src_addr;
 	void        *cipher_table;
 	void        *private;
 	qdf_spinlock_t	keylock;
@@ -423,6 +459,8 @@ struct wlan_crypto_req_key {
  * @defaultkey: function pointer to set default key
  * @set_key: converged function pointer to set key in hw
  * @getpn: function pointer to get current pn value of peer
+ * @set_ltf_keyseed: Set LTF keyseed
+ * @set_vdev_param: Set the vdev crypto parameter
  * @register_events: function pointer to register wmi event handler
  * @deregister_events: function pointer to deregister wmi event handler
  */
@@ -444,6 +482,11 @@ struct wlan_lmac_if_crypto_tx_ops {
 			      enum wlan_crypto_key_type key_type);
 	QDF_STATUS(*getpn)(struct wlan_objmgr_vdev *vdev,
 			   uint8_t *macaddr, uint32_t key_type);
+	QDF_STATUS (*set_ltf_keyseed)(struct wlan_objmgr_psoc *psoc,
+				      struct wlan_crypto_ltf_keyseed_data *ks);
+	QDF_STATUS (*set_vdev_param)(struct wlan_objmgr_psoc *psoc,
+				     uint32_t vdev_id, uint32_t param_id,
+				     uint32_t param_value);
 	QDF_STATUS (*register_events)(struct wlan_objmgr_psoc *psoc);
 	QDF_STATUS (*deregister_events)(struct wlan_objmgr_psoc *psoc);
 };

umac/cmn_services/crypto/src/wlan_crypto_def_i.h

@@ -104,8 +104,12 @@ static inline void wlan_crypto_put_be64(u8 *a, u64 val)
 	((tx_ops)->crypto_tx_ops.defaultkey)
 #define WLAN_CRYPTO_TX_OPS_SET_KEY(tx_ops) \
 	((tx_ops)->crypto_tx_ops.set_key)
+#define WLAN_CRYPTO_TX_OPS_SET_VDEV_PARAM(tx_ops) \
+	((tx_ops)->crypto_tx_ops.set_vdev_param)
 #define WLAN_CRYPTO_TX_OPS_GETPN(tx_ops) \
 	((tx_ops)->crypto_tx_ops.getpn)
+#define WLAN_CRYPTO_TX_OPS_SET_LTF_KEYSEED(tx_ops) \
+	((tx_ops)->crypto_tx_ops.set_ltf_keyseed)
 #define WLAN_CRYPTO_TX_OPS_REGISTER_EVENTS(tx_ops) \
 	((tx_ops)->crypto_tx_ops.register_events)
 #define WLAN_CRYPTO_TX_OPS_DEREGISTER_EVENTS(tx_ops) \

umac/cmn_services/crypto/src/wlan_crypto_global_api.c

@@ -4803,3 +4803,46 @@ QDF_STATUS wlan_crypto_create_fils_rik(uint8_t *rrk, uint8_t rrk_len,
 	return QDF_STATUS_SUCCESS;
 }
 #endif /* WLAN_FEATURE_FILS_SK */
+
+#if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+QDF_STATUS
+wlan_crypto_set_ltf_keyseed(struct wlan_objmgr_psoc *psoc,
+			    struct wlan_crypto_ltf_keyseed_data *data)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_lmac_if_tx_ops *tx_ops;
+
+	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
+	if (!tx_ops) {
+		crypto_err("tx_ops is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (WLAN_CRYPTO_TX_OPS_SET_LTF_KEYSEED(tx_ops))
+		status = WLAN_CRYPTO_TX_OPS_SET_LTF_KEYSEED(tx_ops)(psoc, data);
+
+	return status;
+}
+#endif
+
+QDF_STATUS
+wlan_crypto_vdev_set_param(struct wlan_objmgr_psoc *psoc, uint32_t vdev_id,
+			   uint32_t param_id, uint32_t param_value)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_lmac_if_tx_ops *tx_ops;
+
+	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
+	if (!tx_ops) {
+		crypto_err("tx_ops is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (WLAN_CRYPTO_TX_OPS_SET_VDEV_PARAM(tx_ops))
+		status = WLAN_CRYPTO_TX_OPS_SET_VDEV_PARAM(tx_ops) (psoc,
+								    vdev_id,
+								    param_id,
+								    param_value);
+
+	return status;
+}

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -890,6 +890,8 @@ struct wlan_lmac_if_iot_sim_tx_ops {
  * @wifi_pos_get_vht_ch_width: Function pointer to get max supported bw by FW
  * @wifi_pos_parse_measreq_chan_info: Parse channel info from LOWI measurement
  *                                    request buffer.
+ * @send_rtt_pasn_auth_status: Send PASN peers authentication status
+ * @send_rtt_pasn_deauth: Send PASN peer deauth command
  */
 struct wlan_lmac_if_wifi_pos_tx_ops {
 	QDF_STATUS (*wifi_pos_register_events)(struct wlan_objmgr_psoc *psoc);
@@ -907,7 +909,11 @@ struct wlan_lmac_if_wifi_pos_tx_ops {
 	QDF_STATUS (*wifi_pos_parse_measreq_chan_info)(
 			struct wlan_objmgr_pdev *pdev, uint32_t data_len,
 			uint8_t *data, struct rtt_channel_info *chinfo);
-
+	QDF_STATUS (*send_rtt_pasn_auth_status)
+			(struct wlan_objmgr_psoc *psoc,
+			 struct wlan_pasn_auth_status *data);
+	QDF_STATUS (*send_rtt_pasn_deauth)(struct wlan_objmgr_psoc *psoc,
+					   struct qdf_mac_addr *peer_mac);
 };
 #endif
 

umac/wifi_pos/inc/wifi_pos_api.h

@@ -640,6 +640,15 @@ QDF_STATUS wifi_pos_convert_host_pdev_id_to_target(
 	uint32_t *target_pdev_id);
 
 #ifdef WIFI_POS_CONVERGED
+/**
+ * wifi_pos_get_peer_private_object() - Wifi Pos get peer private object
+ * @peer: Peer object pointer
+ *
+ * Return: Peer private object pointer
+ */
+struct wlan_wifi_pos_peer_priv_obj *
+wifi_pos_get_peer_private_object(struct wlan_objmgr_peer *peer);
+
 /**
  * wifi_pos_register_osif_callbacks() - Register OSIF callbacks
  * @psoc: Pointer to psoc object

umac/wifi_pos/inc/wifi_pos_pasn_api.h

@@ -27,6 +27,26 @@
 #include "wifi_pos_public_struct.h"
 
 #if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+/**
+ * wifi_pos_set_peer_ltf_keyseed_required() - Set LTF keyseed required
+ * for the peer
+ * @peer:  Peer object
+ * @value: Value to set
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wifi_pos_set_peer_ltf_keyseed_required(struct wlan_objmgr_peer *peer,
+				       bool value);
+/**
+ * wifi_pos_is_ltf_keyseed_required_for_peer() - Is LTF keyseed required for
+ * the given peer
+ * @peer: Peer object
+ *
+ * Return: true or false
+ */
+bool wifi_pos_is_ltf_keyseed_required_for_peer(struct wlan_objmgr_peer *peer);
+
 /**
  * wifi_pos_handle_ranging_peer_create() - Handle ranging peer create
  * @psoc: Pointer to PSOC
@@ -92,6 +112,28 @@ wifi_pos_handle_ranging_peer_delete(struct wlan_objmgr_psoc *psoc,
 				    struct wlan_pasn_request *req,
 				    uint8_t vdev_id,
 				    uint8_t total_entries);
+
+/**
+ * wifi_pos_send_pasn_auth_status  - Send PASN auth status to firmware
+ * @psoc: Pointer to PSOC object
+ * @data: pointer  to auth status data
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wifi_pos_send_pasn_auth_status(struct wlan_objmgr_psoc *psoc,
+			       struct wlan_pasn_auth_status *data);
+
+/**
+ * wifi_pos_send_pasn_peer_deauth  - Send PASN peer deauth
+ * @psoc: Pointer to PSOC object
+ * @peer_mac: Peer mac address
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wifi_pos_send_pasn_peer_deauth(struct wlan_objmgr_psoc *psoc,
+			       struct qdf_mac_addr *peer_mac);
 #else
 static inline
 QDF_STATUS wifi_pos_handle_ranging_peer_create(struct wlan_objmgr_psoc *psoc,
@@ -130,5 +172,12 @@ wifi_pos_handle_ranging_peer_delete(struct wlan_objmgr_psoc *psoc,
 {
 	return QDF_STATUS_SUCCESS;
 }
+
+static inline QDF_STATUS
+wifi_pos_send_pasn_peer_deauth(struct wlan_objmgr_psoc *psoc,
+			       struct qdf_mac_addr *peer_mac)
+{
+	return QDF_STATUS_SUCCESS;
+}
 #endif /* WIFI_POS_CONVERGED && WLAN_FEATURE_RTT_11AZ_SUPPORT */
 #endif /* _WIFI_POS_PASN_API_H_ */

umac/wifi_pos/inc/wifi_pos_public_struct.h

@@ -67,6 +67,7 @@ enum wifi_pos_pasn_peer_delete_actions {
  * derivation
  * @force_self_mac_usage: If this flag is true, the supplicant
  * should use the provided self mac address
+ * @is_ltf_keyseed_required: Is set LTF keyseed required
  * @control_flags: Control flags to indicate if its required to flush
  * the keys
  */
@@ -75,6 +76,7 @@ struct wlan_pasn_request {
 	enum wifi_pos_pasn_peer_type peer_type;
 	struct qdf_mac_addr self_mac;
 	bool force_self_mac_usage;
+	bool is_ltf_keyseed_required;
 	uint16_t control_flags;
 };
 
@@ -106,4 +108,54 @@ struct wifi_pos_11az_context {
 struct wifi_pos_vdev_priv_obj {
 	struct wifi_pos_11az_context pasn_context;
 };
+
+/**
+ * enum wlan_pasn_auth_status_code  - PASN auth status code
+ * @WLAN_PASN_AUTH_STATUS_SUCCESS: PASN auth is successful
+ * @WLAN_PASN_AUTH_STATUS_PASN_FAILED: PASN authentication failed
+ * @WLAN_PASN_AUTH_STATUS_PEER_CREATE_FAILED: PASN peer create confirm received
+ * with failure status.
+ * @WLAN_PASN_AUTH_STATUS_PEER_ALREADY_EXISTS: Peer already exists
+ * @WLAN_PASN_AUTH_STATUS_HOST_INTERNAL_ERROR: WLAN driver internal error
+ */
+enum wlan_pasn_auth_status_code {
+	WLAN_PASN_AUTH_STATUS_SUCCESS = 0,
+	WLAN_PASN_AUTH_STATUS_PASN_FAILED = 1,
+	WLAN_PASN_AUTH_STATUS_PEER_CREATE_FAILED = 2,
+	WLAN_PASN_AUTH_STATUS_PEER_ALREADY_EXISTS = 3,
+	WLAN_PASN_AUTH_STATUS_HOST_INTERNAL_ERROR = 4,
+};
+
+/**
+ * struct wlan_pasn_auth_status_peer_info - PASN authentication status peer
+ * info
+ * @peer_mac: Peer mac address
+ * @self_mac: Self mac address
+ * @status: PASN auth status code
+ */
+struct wlan_pasn_auth_status_peer_info {
+	struct qdf_mac_addr peer_mac;
+	struct qdf_mac_addr self_mac;
+	enum wlan_pasn_auth_status_code status;
+};
+
+/**
+ * struct wlan_pasn_auth_status  - PASN authentication status
+ * @vdev_id:  vdev_id
+ * @num_peers: Number of peers for which auth status is to be sent
+ * @auth_status: Auth status details
+ */
+struct wlan_pasn_auth_status {
+	uint8_t vdev_id;
+	uint8_t num_peers;
+	struct wlan_pasn_auth_status_peer_info auth_status[WLAN_MAX_11AZ_PEERS];
+};
+
+/**
+ * struct wlan_wifi_pos_peer_priv_obj - WLAN wifi pos peer private object
+ * @is_ltf_keyseed_required: Is LTF keyseed required for peer
+ */
+struct wlan_wifi_pos_peer_priv_obj {
+	bool is_ltf_keyseed_required;
+};
 #endif /* _WIFI_POS_PUBLIC_STRUCT_H_ */

umac/wifi_pos/src/wifi_pos_api.c

@@ -144,8 +144,36 @@ QDF_STATUS wifi_pos_init(void)
 		goto fail_vdev_destroy_handler;
 	}
 
+	status =  wlan_objmgr_register_peer_create_handler(
+			WLAN_UMAC_COMP_WIFI_POS,
+			wifi_pos_peer_object_created_notification,
+			NULL);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		wifi_pos_err("peer create register notification failed");
+		goto fail_peer_create_handler;
+	}
+
+	status = wlan_objmgr_register_peer_destroy_handler(
+				WLAN_UMAC_COMP_WIFI_POS,
+				wifi_pos_peer_object_destroyed_notification,
+				NULL);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		wifi_pos_err("peer destroy register notification failed");
+		goto fail_peer_destroy_handler;
+	}
+
 	return status;
 
+fail_peer_destroy_handler:
+	wlan_objmgr_unregister_peer_create_handler(
+			WLAN_UMAC_COMP_WIFI_POS,
+			wifi_pos_peer_object_created_notification,
+			NULL);
+fail_peer_create_handler:
+	wlan_objmgr_unregister_vdev_destroy_handler(
+			WLAN_UMAC_COMP_WIFI_POS,
+			wifi_pos_vdev_destroyed_notification, NULL);
+
 fail_vdev_destroy_handler:
 	wlan_objmgr_unregister_vdev_create_handler(
 			WLAN_UMAC_COMP_WIFI_POS,
@@ -168,6 +196,20 @@ QDF_STATUS wifi_pos_deinit(void)
 {
 	QDF_STATUS status;
 
+	status = wlan_objmgr_unregister_peer_destroy_handler(
+				WLAN_UMAC_COMP_WIFI_POS,
+				wifi_pos_peer_object_destroyed_notification,
+				NULL);
+	if (QDF_IS_STATUS_ERROR(status))
+		wifi_pos_err("unable to unregister peer destroy handle");
+
+	status = wlan_objmgr_unregister_peer_create_handler(
+				WLAN_UMAC_COMP_WIFI_POS,
+				wifi_pos_peer_object_created_notification,
+				NULL);
+	if (QDF_IS_STATUS_ERROR(status))
+		wifi_pos_err("unable to unregister peer create handle");
+
 	status = wlan_objmgr_unregister_vdev_destroy_handler(
 				WLAN_UMAC_COMP_WIFI_POS,
 				wifi_pos_vdev_destroyed_notification, NULL);
@@ -246,6 +288,23 @@ QDF_STATUS wifi_pos_psoc_disable(struct wlan_objmgr_psoc *psoc)
 	return QDF_STATUS_SUCCESS;
 }
 
+struct wlan_wifi_pos_peer_priv_obj *
+wifi_pos_get_peer_private_object(struct wlan_objmgr_peer *peer)
+{
+	struct wlan_wifi_pos_peer_priv_obj *peer_priv;
+
+	if (!peer) {
+		wifi_pos_err("Peer is NULL");
+		return NULL;
+	}
+
+	peer_priv =
+		wlan_objmgr_peer_get_comp_private_obj(peer,
+						      WLAN_UMAC_COMP_WIFI_POS);
+
+	return peer_priv;
+}
+
 void wifi_pos_set_oem_target_type(struct wlan_objmgr_psoc *psoc, uint32_t val)
 {
 	struct wifi_pos_psoc_priv_obj *wifi_pos_psoc =

umac/wifi_pos/src/wifi_pos_main.c

@@ -36,6 +36,7 @@
 #include "wlan_objmgr_vdev_obj.h"
 #include "wlan_ptt_sock_svc.h"
 #include "target_if.h"
+#include "wlan_objmgr_peer_obj.h"
 
 #ifndef CNSS_GENL
 #include <wlan_objmgr_global_obj_i.h>
@@ -993,7 +994,8 @@ QDF_STATUS  wifi_pos_psoc_obj_destroyed_notification(
 	return status;
 }
 
-static void
+#if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+void
 wifi_pos_init_11az_context(struct wifi_pos_vdev_priv_obj *vdev_pos_obj)
 {
 	struct wifi_pos_11az_context *pasn_context;
@@ -1016,6 +1018,7 @@ wifi_pos_init_11az_context(struct wifi_pos_vdev_priv_obj *vdev_pos_obj)
 	pasn_context->num_unsecure_peers = 0;
 	pasn_context->num_failed_peers = 0;
 }
+#endif
 
 QDF_STATUS
 wifi_pos_vdev_created_notification(struct wlan_objmgr_vdev *vdev,
@@ -1067,6 +1070,64 @@ wifi_pos_vdev_destroyed_notification(struct wlan_objmgr_vdev *vdev,
 	return status;
 }
 
+QDF_STATUS
+wifi_pos_peer_object_created_notification(struct wlan_objmgr_peer *peer,
+					  void *arg)
+{
+	struct wlan_wifi_pos_peer_priv_obj *peer_priv;
+	QDF_STATUS status;
+
+	if (!peer) {
+		wifi_pos_err("Peer is NULL");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	peer_priv = qdf_mem_malloc(sizeof(*peer_priv));
+	if (!peer_priv)
+		return QDF_STATUS_E_NOMEM;
+
+	status = wlan_objmgr_peer_component_obj_attach(peer,
+						       WLAN_UMAC_COMP_WIFI_POS,
+						       (void *)peer_priv,
+						       QDF_STATUS_SUCCESS);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		wifi_pos_err("unable to attach peer_priv obj to peer obj");
+		qdf_mem_free(peer_priv);
+	}
+
+	return status;
+}
+
+QDF_STATUS
+wifi_pos_peer_object_destroyed_notification(struct wlan_objmgr_peer *peer,
+					    void *arg)
+{
+	struct wlan_wifi_pos_peer_priv_obj *peer_priv;
+	QDF_STATUS status;
+
+	if (!peer) {
+		wifi_pos_err("Peer is NULL");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	peer_priv = wlan_objmgr_peer_get_comp_private_obj(peer,
+							  WLAN_UMAC_COMP_WIFI_POS);
+	if (!peer_priv) {
+		wifi_pos_err("peer MLME component object is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	status = wlan_objmgr_peer_component_obj_detach(peer,
+						       WLAN_UMAC_COMP_WIFI_POS,
+						       (void *)peer_priv);
+	if (QDF_IS_STATUS_ERROR(status))
+		wifi_pos_err("unable to dettach peer_priv obj to peer obj");
+
+	qdf_mem_free(peer_priv);
+
+	return status;
+}
+
 int wifi_pos_oem_rsp_handler(struct wlan_objmgr_psoc *psoc,
 			     struct oem_data_rsp *oem_rsp)
 {

umac/wifi_pos/src/wifi_pos_main_i.h

@@ -34,6 +34,21 @@
 /* forward reference */
 struct wlan_objmgr_psoc;
 
+#if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+/**
+ * wifi_pos_init_11az_context  - Initialize 11az context
+ * @vdev_pos_obj: Vdev private object of WIFI Pos component
+ *
+ * Return: None
+ */
+void
+wifi_pos_init_11az_context(struct wifi_pos_vdev_priv_obj *vdev_pos_obj);
+#else
+static inline void
+wifi_pos_init_11az_context(struct wifi_pos_vdev_priv_obj *vdev_pos_obj)
+{}
+#endif
+
 /**
  * wifi_pos_psoc_obj_created_notification: callback registered to be called when
  * psoc object is created.
@@ -85,6 +100,30 @@ QDF_STATUS
 wifi_pos_vdev_destroyed_notification(struct wlan_objmgr_vdev *vdev,
 				     void *arg_list);
 
+/**
+ * wifi_pos_peer_object_created_notification() - Handle peer object created
+ * notification.
+ * @peer: Objmgr peer
+ * @arg: Argument
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wifi_pos_peer_object_created_notification(struct wlan_objmgr_peer *peer,
+					  void *arg);
+
+/**
+ * wifi_pos_peer_object_destroyed_notification() - Handler for peer object
+ * deleted notification
+ * @peer: Objmgr peer
+ * @arg: Argument
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wifi_pos_peer_object_destroyed_notification(struct wlan_objmgr_peer *peer,
+					    void *arg);
+
 /**
  * wifi_pos_oem_rsp_handler: lmac rx ops registered
  * @psoc: pointer to psoc object

umac/wifi_pos/src/wifi_pos_pasn_api.c

@@ -369,6 +369,18 @@ QDF_STATUS wifi_pos_handle_ranging_peer_create(struct wlan_objmgr_psoc *psoc,
 			continue;
 		}
 
+		if (req[i].is_ltf_keyseed_required) {
+			peer = wlan_objmgr_get_peer_by_mac(psoc,
+							   req[i].peer_mac.bytes,
+							   WLAN_WIFI_POS_CORE_ID);
+			if (peer) {
+				wifi_pos_set_peer_ltf_keyseed_required(peer,
+								       true);
+				wlan_objmgr_peer_release_ref(peer,
+							     WLAN_WIFI_POS_CORE_ID);
+			}
+		}
+
 		/* Track the peers only for I-STA mode */
 		if (wlan_vdev_mlme_get_opmode(vdev) == QDF_STA_MODE)
 			wifi_pos_add_peer_to_list(vdev, &req[i], true);
@@ -523,3 +535,108 @@ no_peer:
 
 	return status;
 }
+
+QDF_STATUS
+wifi_pos_send_pasn_auth_status(struct wlan_objmgr_psoc *psoc,
+			       struct wlan_pasn_auth_status *data)
+{
+	struct wlan_lmac_if_wifi_pos_tx_ops *tx_ops;
+	QDF_STATUS status;
+	uint8_t vdev_id = data->vdev_id;
+	struct wifi_pos_vdev_priv_obj *vdev_pos_obj;
+	struct wifi_pos_11az_context *pasn_context;
+	struct wlan_objmgr_vdev *vdev;
+	uint8_t i, failed_peers_counter = 0, total_peers_to_fill = 0;
+
+	tx_ops = wifi_pos_get_tx_ops(psoc);
+	if (!tx_ops || !tx_ops->send_rtt_pasn_auth_status) {
+		wifi_pos_err("%s is null",
+			     tx_ops ? "Tx_ops" : "send_auth_status cb");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
+						    WLAN_WIFI_POS_CORE_ID);
+	if (!vdev) {
+		wifi_pos_err("vdev obj is null");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev_pos_obj = wifi_pos_get_vdev_priv_obj(vdev);
+	if (!vdev_pos_obj) {
+		wifi_pos_err("Wifi pos vdev priv obj is null");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_WIFI_POS_CORE_ID);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	pasn_context = &vdev_pos_obj->pasn_context;
+	total_peers_to_fill = data->num_peers + pasn_context->num_failed_peers;
+	for (i = data->num_peers; i < total_peers_to_fill; i++) {
+		data->auth_status[i].peer_mac =
+			pasn_context->failed_peer_list[failed_peers_counter];
+		data->auth_status[i].status =
+			WLAN_PASN_AUTH_STATUS_PEER_CREATE_FAILED;
+
+		failed_peers_counter++;
+		if (failed_peers_counter >= pasn_context->num_failed_peers)
+			break;
+	}
+
+	status = tx_ops->send_rtt_pasn_auth_status(psoc, data);
+	if (QDF_IS_STATUS_ERROR(status))
+		wifi_pos_err("Failed to send PASN authentication status");
+
+	wifi_pos_init_11az_context(vdev_pos_obj);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_WIFI_POS_CORE_ID);
+
+	return status;
+}
+
+QDF_STATUS
+wifi_pos_send_pasn_peer_deauth(struct wlan_objmgr_psoc *psoc,
+			       struct qdf_mac_addr *peer_mac)
+{
+	struct wlan_lmac_if_wifi_pos_tx_ops *tx_ops;
+	QDF_STATUS status;
+
+	tx_ops = wifi_pos_get_tx_ops(psoc);
+	if (!tx_ops || !tx_ops->send_rtt_pasn_deauth) {
+		wifi_pos_err("%s is null",
+			     tx_ops ? "Tx_ops" : "send_pasn deauth cb");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	status = tx_ops->send_rtt_pasn_deauth(psoc, peer_mac);
+
+	return status;
+}
+
+QDF_STATUS
+wifi_pos_set_peer_ltf_keyseed_required(struct wlan_objmgr_peer *peer,
+				       bool value)
+{
+	struct wlan_wifi_pos_peer_priv_obj *peer_priv;
+
+	peer_priv = wifi_pos_get_peer_private_object(peer);
+	if (!peer_priv) {
+		wifi_pos_err("peer private object is null");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	peer_priv->is_ltf_keyseed_required = value;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+bool wifi_pos_is_ltf_keyseed_required_for_peer(struct wlan_objmgr_peer *peer)
+{
+	struct wlan_wifi_pos_peer_priv_obj *peer_priv;
+
+	peer_priv = wifi_pos_get_peer_private_object(peer);
+	if (!peer_priv) {
+		wifi_pos_err("peer private object is null");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return peer_priv->is_ltf_keyseed_required;
+}

umac/wifi_pos/src/wifi_pos_ucfg_i.h

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2017, 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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
@@ -27,6 +28,9 @@
 
 #include "qdf_types.h"
 #include "qdf_status.h"
+#include "os_if_wifi_pos_utils.h"
+#include "wifi_pos_pasn_api.h"
+#include "wifi_pos_api.h"
 
 struct wlan_objmgr_psoc;
 struct wifi_pos_req_msg;
@@ -44,4 +48,47 @@ QDF_STATUS ucfg_wifi_pos_process_req(struct wlan_objmgr_psoc *psoc,
 				     struct wifi_pos_req_msg *req,
 				     wifi_pos_send_rsp_handler send_rsp_cb);
 
+#ifdef WIFI_POS_CONVERGED
+/**
+ * ucfg_wifi_pos_register_osif_callbacks() - Register WIFI pos module OSIF
+ * callbacks
+ * @psoc: Pointer to PSOC object
+ * @osif_ops: Pointer to OSIF callbacks
+ *
+ * Return: QDF_STATUS
+ */
+static inline QDF_STATUS
+ucfg_wifi_pos_register_osif_callbacks(struct wlan_objmgr_psoc *psoc,
+				      struct wifi_pos_osif_ops *osif_ops)
+{
+	return wifi_pos_register_osif_callbacks(psoc, osif_ops);
+}
+
+/**
+ * ucfg_wifi_pos_deregister_osif_callbacks() - De-Register WIFI pos module OSIF
+ * callbacks
+ * @psoc: Pointer to PSOC object
+ *
+ * Return: QDF_STATUS
+ */
+static inline QDF_STATUS
+ucfg_wifi_pos_deregister_osif_callbacks(struct wlan_objmgr_psoc *psoc)
+{
+	return wifi_pos_register_osif_callbacks(psoc, NULL);
+}
+#else
+static inline QDF_STATUS
+ucfg_wifi_pos_deregister_osif_callbacks(struct wlan_objmgr_psoc *psoc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif /* WIFI_POS_CONVERGED */
+
+#if defined(WIFI_POS_CONVERGED) && defined(WLAN_FEATURE_RTT_11AZ_SUPPORT)
+static inline bool
+ucfg_wifi_pos_is_ltf_keyseed_required_for_peer(struct wlan_objmgr_peer *peer)
+{
+	return wifi_pos_is_ltf_keyseed_required_for_peer(peer);
+}
+#endif
 #endif /* _WIFI_POS_UCFG_H_ */