qcacld-2.0: Add support for NDP vendor commands and NDI Create

Add support for NDP vendor commands and implement NAN Data Interface
create.

CRs-Fixed: 962367
Change-Id: I84e9ac5ccfe8faaa00dfc448defb81fb792263d5

10 files changed, 1125 insertions, 53 deletions

diff --git a/CORE/HDD/inc/wlan_hdd_cfg80211.h b/CORE/HDD/inc/wlan_hdd_cfg80211.h
index bf26c998be53..f022930e08e8 100644
--- a/CORE/HDD/inc/wlan_hdd_cfg80211.h
+++ b/CORE/HDD/inc/wlan_hdd_cfg80211.h
@@ -238,6 +238,8 @@ enum qca_nl80211_vendor_subcmds {
 
     QCA_NL80211_VENDOR_SUBCMD_OFFLOADED_PACKETS = 79,
     QCA_NL80211_VENDOR_SUBCMD_MONITOR_RSSI = 80,
+    QCA_NL80211_VENDOR_SUBCMD_NDP = 81,
+
 
     /* NS Offload enable/disable cmd */
     QCA_NL80211_VENDOR_SUBCMD_ND_OFFLOAD = 82,
@@ -325,12 +327,15 @@ enum qca_nl80211_vendor_subcmds_index {
     QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_SSID_FOUND_INDEX,
     QCA_NL80211_VENDOR_SUBCMD_EXTSCAN_HOTLIST_SSID_LOST_INDEX,
 #endif
-	/* OCB events */
-	QCA_NL80211_VENDOR_SUBCMD_DCC_STATS_EVENT_INDEX,
+    /* OCB events */
+    QCA_NL80211_VENDOR_SUBCMD_DCC_STATS_EVENT_INDEX,
 #ifdef WLAN_FEATURE_MEMDUMP
     QCA_NL80211_VENDOR_SUBCMD_WIFI_LOGGER_MEMORY_DUMP_INDEX,
 #endif /* WLAN_FEATURE_MEMDUMP */
     QCA_NL80211_VENDOR_SUBCMD_MONITOR_RSSI_INDEX,
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+    QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+#endif /* WLAN_FEATURE_NAN_DATAPATH */
 };
 
 /* EXT TDLS */
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 3954fe55c307..81144222e5d2 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -60,6 +60,9 @@
 #ifdef WLAN_FEATURE_MBSSID
 #include "sapApi.h"
 #endif
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+#include "wlan_hdd_nan_datapath.h"
+#endif
 
 /*---------------------------------------------------------------------------
   Preprocessor definitions and constants
@@ -1087,6 +1090,9 @@ struct hdd_adapter_s
    union {
       hdd_station_ctx_t station;
       hdd_ap_ctx_t  ap;
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+      struct nan_datapath_ctx ndp_ctx;
+#endif
    }sessionCtx;
 
 #ifdef WLAN_FEATURE_TSF
@@ -1159,17 +1165,17 @@ struct hdd_adapter_s
     /* Time stamp for start RoC request */
     v_TIME_t startRocTs;
 
-	/* State for synchronous OCB requests to WMI */
-	struct sir_ocb_set_config_response ocb_set_config_resp;
-	struct sir_ocb_get_tsf_timer_response ocb_get_tsf_timer_resp;
-	struct sir_dcc_get_stats_response *dcc_get_stats_resp;
-	struct sir_dcc_update_ndl_response dcc_update_ndl_resp;
-
-	/* MAC addresses used for OCB interfaces */
-	tSirMacAddr ocb_mac_address[VOS_MAX_CONCURRENCY_PERSONA];
-	int ocb_mac_addr_count;
-	struct hdd_adapter_pm_context runtime_context;
-	struct mib_stats_metrics mib_stats;
+    /* State for synchronous OCB requests to WMI */
+    struct sir_ocb_set_config_response ocb_set_config_resp;
+    struct sir_ocb_get_tsf_timer_response ocb_get_tsf_timer_resp;
+    struct sir_dcc_get_stats_response *dcc_get_stats_resp;
+    struct sir_dcc_update_ndl_response dcc_update_ndl_resp;
+
+    /* MAC addresses used for OCB interfaces */
+    tSirMacAddr ocb_mac_address[VOS_MAX_CONCURRENCY_PERSONA];
+    int ocb_mac_addr_count;
+    struct hdd_adapter_pm_context runtime_context;
+    struct mib_stats_metrics mib_stats;
 };
 
 #define WLAN_HDD_GET_STATION_CTX_PTR(pAdapter) (&(pAdapter)->sessionCtx.station)
@@ -1190,6 +1196,14 @@ struct hdd_adapter_s
         ((WLAN_HDD_IS_TDLS_SUPPORTED_ADAPTER(pAdapter)) ? \
         (tdlsCtx_t*)(pAdapter)->sessionCtx.station.pHddTdlsCtx : NULL)
 #endif
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+#define WLAN_HDD_GET_NDP_CTX_PTR(adapter) (&(adapter)->sessionCtx.ndp_ctx)
+#define WLAN_HDD_GET_NDP_WEXT_STATE_PTR(adapter) \
+                       (&(adapter)->sessionCtx.ndp_ctx.wext_state)
+#else
+#define WLAN_HDD_GET_NDP_CTX_PTR(adapter) (NULL)
+#define WLAN_HDD_GET_NDP_WEXT_STATE_PTR(adapter) (NULL)
+#endif
 
 /* Set mac address locally administered bit */
 #define WLAN_HDD_RESET_LOCALLY_ADMINISTERED_BIT(macaddr) (macaddr[0] &= 0xFD)
@@ -2049,4 +2063,6 @@ void
 hdd_get_ibss_peer_info_cb(v_VOID_t *pUserData,
                                     tSirPeerInfoRspParams *pPeerInfo);
 
+eHalStatus hdd_smeCloseSessionCallback(void *pContext);
+
 #endif    // end #if !defined( WLAN_HDD_MAIN_H )
diff --git a/CORE/HDD/inc/wlan_hdd_p2p.h b/CORE/HDD/inc/wlan_hdd_p2p.h
index 25d9b20835c6..7fad19cf0ab2 100644
--- a/CORE/HDD/inc/wlan_hdd_p2p.h
+++ b/CORE/HDD/inc/wlan_hdd_p2p.h
@@ -183,8 +183,12 @@ struct net_device* wlan_hdd_add_virtual_intf(
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) || defined(WITH_BACKPORTS)
 int wlan_hdd_del_virtual_intf( struct wiphy *wiphy, struct wireless_dev *wdev );
+int __wlan_hdd_del_virtual_intf(struct wiphy *wiphy,
+                                        struct wireless_dev *wdev);
 #else
 int wlan_hdd_del_virtual_intf( struct wiphy *wiphy, struct net_device *dev );
+int __wlan_hdd_del_virtual_intf(struct wiphy *wiphy,
+                                        struct net_device *dev);
 #endif
 
 void wlan_hdd_cleanup_remain_on_channel_ctx(hdd_adapter_t *pAdapter);
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index 0ec5f7ec65c3..70d9d2fee800 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -70,6 +70,7 @@
 #endif
 #include <vos_sched.h>
 #include <wlan_logging_sock_svc.h>
+#include "wlan_hdd_nan_datapath.h"
 
 struct ether_addr
 {
@@ -4105,6 +4106,10 @@ hdd_smeRoamCallback(void *pContext, tCsrRoamInfo *pRoamInfo, tANI_U32 roamId,
             break;
          }
 #endif /* FEATURE_WLAN_ESE && FEATURE_WLAN_ESE_UPLOAD */
+        case eCSR_ROAM_NDP_STATUS_UPDATE:
+            hdd_ndp_event_handler(pAdapter, pRoamInfo, roamId, roamStatus,
+                roamResult );
+            break;
         default:
             break;
     }
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 67f018fd7b20..946807eef702 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -109,6 +109,7 @@
 #include "wlan_hdd_memdump.h"
 
 #include "wlan_logging_sock_svc.h"
+#include "wlan_hdd_nan_datapath.h"
 
 #define g_mode_rates_size (12)
 #define a_mode_rates_size (8)
@@ -1320,6 +1321,12 @@ static const struct nl80211_vendor_cmd_info wlan_hdd_cfg80211_vendor_events[] =
         .vendor_id = QCA_NL80211_VENDOR_ID,
         .subcmd = QCA_NL80211_VENDOR_SUBCMD_MONITOR_RSSI
     },
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+    [QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX] = {
+        .vendor_id = QCA_NL80211_VENDOR_ID,
+        .subcmd = QCA_NL80211_VENDOR_SUBCMD_NDP
+    },
+#endif /* WLAN_FEATURE_NAN_DATAPATH */
 };
 
 /**
@@ -10910,6 +10917,16 @@ const struct wiphy_vendor_command hdd_wiphy_vendor_commands[] =
 			 WIPHY_VENDOR_CMD_NEED_RUNNING,
 		.doit = wlan_hdd_cfg80211_get_wakelock_stats
 	},
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+	{
+		.info.vendor_id = QCA_NL80211_VENDOR_ID,
+		.info.subcmd = QCA_NL80211_VENDOR_SUBCMD_NDP,
+		.flags = WIPHY_VENDOR_CMD_NEED_WDEV |
+			WIPHY_VENDOR_CMD_NEED_NETDEV |
+			WIPHY_VENDOR_CMD_NEED_RUNNING,
+		.doit = wlan_hdd_cfg80211_process_ndp_cmd
+	},
+#endif
 };
 
 
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index de8ffc391f27..66790887c0cc 100644
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -115,6 +115,7 @@ void hdd_ch_avoid_cb(void *hdd_context,void *indi_param);
 
 #ifdef WLAN_FEATURE_NAN
 #include "wlan_hdd_nan.h"
+#include "wlan_hdd_nan_datapath.h"
 #endif /* WLAN_FEATURE_NAN */
 
 #include "wlan_hdd_debugfs.h"
@@ -340,6 +341,7 @@ const char* hdd_device_mode_to_string(uint8_t device_mode)
 	CASE_RETURN_STRING(WLAN_HDD_IBSS);
 	CASE_RETURN_STRING(WLAN_HDD_P2P_DEVICE);
 	CASE_RETURN_STRING(WLAN_HDD_OCB);
+	CASE_RETURN_STRING(WLAN_HDD_NDI);
 	default:
 		return "Unknown";
 	}
@@ -10056,7 +10058,15 @@ VOS_STATUS hdd_register_interface( hdd_adapter_t *pAdapter, tANI_U8 rtnl_lock_he
    return VOS_STATUS_SUCCESS;
 }
 
-static eHalStatus hdd_smeCloseSessionCallback(void *pContext)
+/**
+ * hdd_smeCloseSessionCallback() - HDD callback function
+ * @pContext: adapter context
+ *
+ * This is a callback function HDD registers with SME.
+ *
+ * Returns: eHalstatus
+ */
+eHalStatus hdd_smeCloseSessionCallback(void *pContext)
 {
    hdd_adapter_t *pAdapter = pContext;
 
@@ -10682,6 +10692,7 @@ hdd_adapter_t* hdd_open_adapter( hdd_context_t *pHddCtx, tANI_U8 session_type,
       case WLAN_HDD_P2P_CLIENT:
       case WLAN_HDD_P2P_DEVICE:
       case WLAN_HDD_OCB:
+      case WLAN_HDD_NDI:
       {
          pAdapter = hdd_alloc_station_adapter( pHddCtx, macAddr, iface_name );
 
@@ -10703,7 +10714,11 @@ hdd_adapter_t* hdd_open_adapter( hdd_context_t *pHddCtx, tANI_U8 session_type,
 
          pAdapter->device_mode = session_type;
 
-         status = hdd_init_station_mode( pAdapter );
+         if (WLAN_HDD_NDI == session_type)
+                status = hdd_init_nan_data_mode(pAdapter);
+         else
+                status = hdd_init_station_mode( pAdapter );
+
          if( VOS_STATUS_SUCCESS != status )
             goto err_free_netdev;
 
@@ -10725,7 +10740,6 @@ hdd_adapter_t* hdd_open_adapter( hdd_context_t *pHddCtx, tANI_U8 session_type,
          //Stop the Interface TX queue.
          hddLog(LOG1, FL("Disabling queues"));
          netif_tx_disable(pAdapter->dev);
-         //netif_tx_disable(pWlanDev);
          netif_carrier_off(pAdapter->dev);
 
 #ifdef QCA_LL_TX_FLOW_CT
diff --git a/CORE/HDD/src/wlan_hdd_nan_datapath.c b/CORE/HDD/src/wlan_hdd_nan_datapath.c
index d41eb47f254c..f7becb286a25 100644
--- a/CORE/HDD/src/wlan_hdd_nan_datapath.c
+++ b/CORE/HDD/src/wlan_hdd_nan_datapath.c
@@ -23,9 +23,40 @@
  *
  * WLAN Host Device Driver nan datapath API implementation
  */
-#include <wlan_hdd_includes.h>
+#include <linux/if.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <linux/etherdevice.h>
 #include "vos_trace.h"
+#include "vos_sched.h"
+#include "wlan_hdd_includes.h"
 #include "wlan_hdd_nan_datapath.h"
+#include "wlan_hdd_p2p.h"
+#include "wma_api.h"
+
+/* NLA policy */
+static const struct nla_policy
+qca_wlan_vendor_ndp_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = {
+	[QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD] = { .type = NLA_U32 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID] = { .type = NLA_U16 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { .type = NLA_STRING,
+					.len = IFNAMSIZ },
+	[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID] = { .type = NLA_U32 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_SPEC_CHANNEL] = { .type = NLA_U32 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR] = { .type = NLA_BINARY,
+						.len = VOS_MAC_ADDR_SIZE },
+	[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY] = { .type = NLA_U16 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS] = { .type = NLA_BINARY,
+					.len = NDP_QOS_INFO_LEN },
+	[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO_LEN] = { .type = NLA_U16 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO] = { .type = NLA_BINARY,
+					.len = NDP_APP_INFO_LEN },
+	[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID] = { .type = NLA_U32 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_RESPONSE_CODE] = { .type = NLA_U16 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_STATUS_CODE] = { .type = NLA_U16 },
+	[QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR] = { .type = NLA_BINARY,
+					.len = VOS_MAC_ADDR_SIZE },
+};
 
 /**
  * hdd_ndp_print_ini_config()- Print nan datapath specific INI configuration
@@ -48,12 +79,11 @@ void hdd_ndp_print_ini_config(hdd_context_t *hdd_ctx)
  * @hdd_ctx: Pointer to HDD context
  * @cfg: Pointer to target device capability information
  *
- * NaN datapath functionality is enabled if it is enabled in
- * .ini file and also supported in target device.
+ * NAN datapath functinality is enabled if it is enabled in
+ * .ini file and also supported in firmware.
  *
  * Return: None
  */
-
 void hdd_nan_datapath_target_config(hdd_context_t *hdd_ctx,
 					struct hdd_tgt_cfg *cfg)
 {
@@ -61,3 +91,769 @@ void hdd_nan_datapath_target_config(hdd_context_t *hdd_ctx,
 	hddLog(LOG1, FL("enable_nan_datapath: %d"),
 		hdd_ctx->cfg_ini->enable_nan_datapath);
 }
+
+/**
+ * hdd_ndi_start_bss() - Start BSS on NAN data interface
+ * @adapter: adapter context
+ * @operating_channel: channel on which the BSS to be started
+ *
+ * Return: 0 on success, error value on failure
+ */
+static int hdd_ndi_start_bss(hdd_adapter_t *adapter,
+				uint8_t operating_channel)
+{
+	int ret;
+	uint16_t ch_width;
+	uint32_t roam_id;
+	hdd_wext_state_t *wext_state =
+		WLAN_HDD_GET_NDP_WEXT_STATE_PTR(adapter);
+	tCsrRoamProfile *roam_profile = &wext_state->roamProfile;
+
+	ENTER();
+
+	if (!roam_profile) {
+		hddLog(LOGE, FL("No valid roam profile"));
+		return -EINVAL;
+	}
+
+	if (HDD_WMM_USER_MODE_NO_QOS ==
+		(WLAN_HDD_GET_CTX(adapter))->cfg_ini->WmmMode) {
+		/* QoS not enabled in cfg file*/
+		roam_profile->uapsd_mask = 0;
+	} else {
+		/* QoS enabled, update uapsd mask from cfg file*/
+		roam_profile->uapsd_mask =
+			(WLAN_HDD_GET_CTX(adapter))->cfg_ini->UapsdMask;
+	}
+
+	roam_profile->csrPersona = adapter->device_mode;
+
+	roam_profile->ChannelInfo.numOfChannels = 1;
+	if (operating_channel) {
+		roam_profile->ChannelInfo.ChannelList = &operating_channel;
+	} else {
+		roam_profile->ChannelInfo.ChannelList[0] =
+			NAN_SOCIAL_CHANNEL_2_4GHZ;
+	}
+	hdd_select_cbmode(adapter, operating_channel, &ch_width);
+	roam_profile->vht_channel_width = ch_width;
+
+	roam_profile->SSIDs.numOfSSIDs = 1;
+	roam_profile->SSIDs.SSIDList->SSID.length = 0;
+
+	roam_profile->phyMode = eCSR_DOT11_MODE_11ac;
+	roam_profile->BSSType = eCSR_BSS_TYPE_NDI;
+	roam_profile->BSSIDs.numOfBSSIDs = 1;
+	vos_mem_copy((void *)(roam_profile->BSSIDs.bssid),
+		&adapter->macAddressCurrent.bytes[0],
+		VOS_MAC_ADDR_SIZE);
+
+	roam_profile->AuthType.numEntries = 1;
+	roam_profile->AuthType.authType[0] = eCSR_AUTH_TYPE_OPEN_SYSTEM;
+	roam_profile->EncryptionType.numEntries = 1;
+	roam_profile->EncryptionType.encryptionType[0] = eCSR_ENCRYPT_TYPE_NONE;
+
+	ret = sme_RoamConnect(WLAN_HDD_GET_HAL_CTX(adapter),
+		adapter->sessionId, roam_profile, &roam_id);
+	if (eHAL_STATUS_SUCCESS != ret) {
+		hddLog(LOGE,
+			FL("NDI sme_RoamConnect session %d failed with status %d -> NotConnected"),
+			  adapter->sessionId, ret);
+		/* change back to NotConnected */
+		hdd_connSetConnectionState(adapter,
+			eConnectionState_NotConnected);
+	} else {
+		hddLog(LOG2, FL("sme_RoamConnect issued successfully for NDI"));
+	}
+
+	roam_profile->ChannelInfo.ChannelList = NULL;
+	roam_profile->ChannelInfo.numOfChannels = 0;
+
+	EXIT();
+
+	return ret;
+}
+
+
+/**
+ * hdd_ndi_create_req_handler() - NDI create request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return: 0 on success or error code on failure
+ */
+static int hdd_ndi_create_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	hdd_adapter_t *adapter;
+	char *iface_name;
+	uint16_t transaction_id;
+	int ret;
+	struct nan_datapath_ctx *ndp_ctx;
+	uint8_t op_channel =
+		hdd_ctx->cfg_ini->nan_datapath_ndi_channel;
+
+	ENTER();
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) {
+		hddLog(LOGE, FL("Interface name string is unavailable"));
+		return -EINVAL;
+	}
+	iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]);
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) {
+		hddLog(LOGE, FL("transaction id is unavailable"));
+		return -EINVAL;
+	}
+	transaction_id =
+		nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]);
+
+	/* Reject if there is an existing interface with same name */
+	adapter = hdd_get_adapter_by_name(hdd_ctx, iface_name);
+	if (adapter) {
+		hddLog(LOGE, FL("Interface %s already exists"),
+			iface_name);
+		return -EEXIST;
+	}
+
+	/* Check for an existing interface of NDI type */
+	adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_NDI);
+	if (adapter) {
+		hddLog(LOGE, FL("Cannot support more than one NDI"));
+		return -EINVAL;
+	}
+
+	adapter = hdd_open_adapter(hdd_ctx, WLAN_HDD_NDI, iface_name,
+			wlan_hdd_get_intf_addr(hdd_ctx), VOS_TRUE);
+	if (!adapter) {
+		hddLog(LOGE, FL("hdd_open_adapter failed"));
+		return -ENOMEM;
+	}
+
+	/*
+	 * Create transaction id is required to be saved since the firmware
+	 * does not honor the transaction id for create request
+	 */
+	ndp_ctx = WLAN_HDD_GET_NDP_CTX_PTR(adapter);
+	ndp_ctx->ndp_create_transaction_id = transaction_id;
+
+	/*
+	 * The NAN data interface has been created at this point.
+	 * Unlike traditional device modes, where the higher application
+	 * layer initiates connect / join / start, the NAN data interface
+	 * does not have any such formal requests. The NDI create request
+	 * is responsible for starting the BSS as well.
+	 */
+	if (op_channel != NAN_SOCIAL_CHANNEL_2_4GHZ ||
+	    op_channel != NAN_SOCIAL_CHANNEL_5GHZ_LOWER_BAND ||
+	    op_channel != NAN_SOCIAL_CHANNEL_5GHZ_UPPER_BAND) {
+		/* start NDI on the default 2.4 GHz social channel */
+		op_channel = NAN_SOCIAL_CHANNEL_2_4GHZ;
+	}
+	ret = hdd_ndi_start_bss(adapter, op_channel);
+	if (0 > ret)
+		hddLog(LOGE, FL("NDI start bss failed"));
+
+	EXIT();
+	return ret;
+}
+
+/**
+ * hdd_ndi_delete_req_handler() - NDI delete request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return: 0 on success or error code on failure
+ */
+static int hdd_ndi_delete_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	return 0;
+}
+
+
+/**
+ * hdd_ndp_initiator_req_handler() - NDP initiator request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return:  0 on success or error code on failure
+ */
+static int hdd_ndp_initiator_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	return 0;
+}
+
+/**
+ * hdd_ndp_responder_req_handler() - NDP responder request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return: 0 on success or error code on failure
+ */
+static int hdd_ndp_responder_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	return 0;
+}
+
+/**
+ * hdd_ndp_end_req_handler() - NDP end request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return: 0 on success or error code on failure
+ */
+static int hdd_ndp_end_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	return 0;
+}
+
+/**
+ * hdd_ndp_schedule_req_handler() - NDP schedule request handler
+ * @hdd_ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * Return: 0 on success or error code on failure
+ */
+static int hdd_ndp_schedule_req_handler(hdd_context_t *hdd_ctx,
+						struct nlattr **tb)
+{
+	return 0;
+}
+
+
+/**
+ * hdd_ndp_iface_create_rsp_handler() - NDP iface create response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_iface_create_rsp_handler(hdd_adapter_t *adapter,
+							void *rsp_params)
+{
+	struct sk_buff *vendor_event;
+	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+	struct ndi_create_rsp *ndi_rsp = (struct ndi_create_rsp *)rsp_params;
+	uint32_t data_len = (2 * sizeof(uint32_t)) + sizeof(uint16_t) +
+				NLMSG_HDRLEN + (3 * NLA_HDRLEN);
+	struct nan_datapath_ctx *ndp_ctx = WLAN_HDD_GET_NDP_CTX_PTR(adapter);
+
+	ENTER();
+
+	if (wlan_hdd_validate_context(hdd_ctx))
+		return;
+
+	if (!ndi_rsp) {
+		hddLog(LOGE, FL("Invalid ndi create response"));
+		return;
+	}
+
+	/* notify response to the upper layer */
+	vendor_event = cfg80211_vendor_event_alloc(hdd_ctx->wiphy,
+				NULL,
+				data_len,
+				QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+				vos_get_gfp_flags());
+
+	if (!vendor_event) {
+		hddLog(LOGE, FL("cfg80211_vendor_event_alloc failed"));
+		return;
+	}
+
+	/* Sub vendor command */
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
+		QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE)) {
+		hddLog(LOGE, FL("QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD put fail"));
+		goto nla_put_failure;
+	}
+
+	/* Transaction id */
+	if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
+		ndp_ctx->ndp_create_transaction_id)) {
+		hddLog(LOGE, FL("VENDOR_ATTR_NDP_TRANSACTION_ID put fail"));
+		goto nla_put_failure;
+	}
+
+	/* Status code */
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_TYPE,
+		ndi_rsp->status)) {
+		hddLog(LOGE, FL("VENDOR_ATTR_NDP_DRV_RETURN_TYPE put fail"));
+		goto nla_put_failure;
+	}
+
+	/* Status return value */
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, 0xA5)) {
+		hddLog(LOGE, FL("VENDOR_ATTR_NDP_DRV_RETURN_VALUE put fail"));
+		goto nla_put_failure;
+	}
+
+	hddLog(LOG2, FL("sub command: %d, value: %d"),
+		QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+		QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE);
+	hddLog(LOG2, FL("create transaction id: %d, value: %d"),
+		QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
+		ndp_ctx->ndp_create_transaction_id);
+	hddLog(LOG2, FL("status code: %d, value: %d"),
+		QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_TYPE, ndi_rsp->status);
+	hddLog(LOG2, FL("Return value: %d, value: %d"),
+		QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, 0xA5);
+
+	cfg80211_vendor_event(vendor_event, GFP_KERNEL);
+
+	ndp_ctx->ndp_create_transaction_id = 0;
+
+	if (ndi_rsp->status == VOS_STATUS_SUCCESS) {
+		hddLog(LOGE, FL("NDI interface successfully created"));
+	} else {
+		hddLog(LOGE,
+			FL("NDI interface creation failed with reason %d"),
+			ndi_rsp->reason);
+	}
+	EXIT();
+	return;
+
+nla_put_failure:
+	kfree_skb(vendor_event);
+	return;
+}
+
+/**
+ * hdd_ndp_iface_delete_rsp_handler() - NDP iface delete response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_iface_delete_rsp_handler(hdd_adapter_t *adapter,
+							void *rsp_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_initiator_rsp_handler() - NDP initiator response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_initiator_rsp_handler(hdd_adapter_t *adapter,
+						void *rsp_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_new_peer_ind_handler() - NDP new peer indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_new_peer_ind_handler(hdd_adapter_t *adapter,
+						void *ind_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_peer_departed_ind_handler() - NDP peer departed indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_peer_departed_ind_handler(
+				hdd_adapter_t *adapter, void *ind_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_confirm_ind_handler() - NDP confirm indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_confirm_ind_handler(hdd_adapter_t *adapter,
+						void *ind_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_indication_handler() - NDP indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_indication_handler(hdd_adapter_t *adapter,
+						void *ind_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_responder_rsp_handler() - NDP responder response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_responder_rsp_handler(hdd_adapter_t *adapter,
+							void *rsp_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_end_rsp_handler() - NDP end response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_end_rsp_handler(hdd_adapter_t *adapter,
+						void *rsp_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_end_ind_handler() - NDP end indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_end_ind_handler(hdd_adapter_t *adapter,
+						void *ind_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_schedule_update_rsp_handler() - NDP schedule update response handler
+ * @adapter: pointer to adapter context
+ * @rsp_params: response parameters
+ *
+ * Return: none
+ */
+static void hdd_ndp_schedule_update_rsp_handler(
+				hdd_adapter_t *adapter, void *rsp_params)
+{
+	return;
+}
+
+/**
+ * hdd_ndp_event_handler() - ndp response and indication handler
+ * @adapter: adapter context
+ * @roam_info: pointer to roam_info structure
+ * @roam_id: roam id as indicated by SME
+ * @roam_status: roam status
+ * @roam_result: roam result
+ *
+ * Return: none
+ */
+void hdd_ndp_event_handler(hdd_adapter_t *adapter,
+	tCsrRoamInfo *roam_info, uint32_t roam_id, eRoamCmdStatus roam_status,
+	eCsrRoamResult roam_result)
+{
+	if (roam_status == eCSR_ROAM_NDP_STATUS_UPDATE) {
+		switch (roam_result) {
+		case eCSR_ROAM_RESULT_NDP_CREATE_RSP:
+			hdd_ndp_iface_create_rsp_handler(adapter,
+				&roam_info->ndp.ndi_create_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_DELETE_RSP:
+			hdd_ndp_iface_delete_rsp_handler(adapter,
+				&roam_info->ndp.ndi_delete_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_INITIATOR_RSP:
+			hdd_ndp_initiator_rsp_handler(adapter,
+				&roam_info->ndp.ndp_init_rsp_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_NEW_PEER_IND:
+			hdd_ndp_new_peer_ind_handler(adapter,
+				&roam_info->ndp.ndp_peer_ind_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_CONFIRM_IND:
+			hdd_ndp_confirm_ind_handler(adapter,
+				&roam_info->ndp.ndp_confirm_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_INDICATION:
+			hdd_ndp_indication_handler(adapter,
+				&roam_info->ndp.ndp_indication_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_SCHED_UPDATE_RSP:
+			hdd_ndp_schedule_update_rsp_handler(adapter,
+				&roam_info->ndp.ndp_sched_upd_rsp_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_RESPONDER_RSP:
+			hdd_ndp_responder_rsp_handler(adapter,
+				&roam_info->ndp.ndp_responder_rsp_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_END_RSP:
+			hdd_ndp_end_rsp_handler(adapter,
+				&roam_info->ndp.ndp_end_rsp_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_PEER_DEPARTED_IND:
+			hdd_ndp_peer_departed_ind_handler(adapter,
+				&roam_info->ndp.ndp_peer_ind_params);
+			break;
+		case eCSR_ROAM_RESULT_NDP_END_IND:
+			hdd_ndp_end_ind_handler(adapter,
+				&roam_info->ndp.ndp_end_ind_params);
+			break;
+		default:
+			hddLog(LOGE,
+				FL("Unknown NDP response event from SME %d"),
+				roam_result);
+			break;
+		}
+	}
+}
+
+/**
+ * __wlan_hdd_cfg80211_process_ndp_cmds() - handle NDP request
+ * @wiphy: pointer to wireless wiphy structure.
+ * @wdev: pointer to wireless_dev structure.
+ * @data: Pointer to the data to be passed via vendor interface
+ * @data_len:Length of the data to be passed
+ *
+ * This function is invoked to handle vendor command
+ *
+ * Return: 0 on success, negative errno on failure
+ */
+static int __wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy,
+	struct wireless_dev *wdev, const void *data, int data_len)
+{
+	uint32_t ndp_cmd_type;
+	uint16_t transaction_id;
+	int ret_val;
+	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
+	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1];
+	char *iface_name;
+
+	ENTER();
+
+	ret_val = wlan_hdd_validate_context(hdd_ctx);
+	if (ret_val)
+		return ret_val;
+
+	if (VOS_FTM_MODE == hdd_get_conparam()) {
+		hddLog(LOGE, FL("Command not allowed in FTM mode"));
+		return -EPERM;
+	}
+	if (!hdd_ctx->cfg_ini->enable_nan_datapath) {
+		hddLog(LOGE, FL("NAN datapath is not suported"));
+		return -EPERM;
+	}
+	if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX,
+			data, data_len,
+			qca_wlan_vendor_ndp_policy)) {
+		hddLog(LOGE, FL("Invalid NDP vendor command attributes"));
+		return -EINVAL;
+	}
+
+	/* Parse and fetch NDP Command Type*/
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD]) {
+		hddLog(LOGE, FL("NAN datapath cmd type failed"));
+		return -EINVAL;
+	}
+	ndp_cmd_type = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD]);
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) {
+		hddLog(LOGE, FL("attr transaction id failed"));
+		return -EINVAL;
+	}
+	transaction_id = nla_get_u16(
+			tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]);
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) {
+		hddLog(LOGE, FL("Interface name string is unavailable"));
+		return -EINVAL;
+	}
+	iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]);
+
+	hddLog(LOG2, FL("Transaction Id: %d NDP Cmd: %d iface_name: %s"),
+		transaction_id, ndp_cmd_type, iface_name);
+
+	switch (ndp_cmd_type) {
+	case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE:
+		ret_val  = hdd_ndi_create_req_handler(hdd_ctx, tb);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE:
+		ret_val = hdd_ndi_delete_req_handler(hdd_ctx, tb);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST:
+		ret_val = hdd_ndp_initiator_req_handler(hdd_ctx, tb);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST:
+		ret_val = hdd_ndp_responder_req_handler(hdd_ctx, tb);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST:
+		ret_val = hdd_ndp_end_req_handler(hdd_ctx, tb);
+		break;
+	case QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REQUEST:
+		ret_val = hdd_ndp_schedule_req_handler(hdd_ctx, tb);
+		break;
+	default:
+		hddLog(LOGE, FL("Unrecognized NDP vendor cmd %d"),
+			ndp_cmd_type);
+		ret_val = -EINVAL;
+		break;
+	}
+
+	return ret_val;
+}
+
+/**
+ * wlan_hdd_cfg80211_process_ndp_cmd() - handle NDP request
+ * @wiphy: pointer to wireless wiphy structure.
+ * @wdev: pointer to wireless_dev structure.
+ * @data: Pointer to the data to be passed via vendor interface
+ * @data_len:Length of the data to be passed
+ *
+ * This function is called to send a NAN request to
+ * firmware. This is an SSR-protected wrapper function.
+ *
+ * Return: 0 on success, negative errno on failure
+ */
+int wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy,
+	struct wireless_dev *wdev, const void *data, int data_len)
+{
+	int ret;
+
+	vos_ssr_protect(__func__);
+	ret = __wlan_hdd_cfg80211_process_ndp_cmd(wiphy, wdev, data, data_len);
+	vos_ssr_unprotect(__func__);
+
+	return ret;
+}
+
+/**
+ * hdd_init_nan_data_mode() - initialize nan data mode
+ * @adapter: adapter context
+ *
+ * Returns: 0 on success negative error code on error
+ */
+int hdd_init_nan_data_mode(struct hdd_adapter_s *adapter)
+{
+	struct net_device *wlan_dev = adapter->dev;
+	struct nan_datapath_ctx *ndp_ctx = WLAN_HDD_GET_NDP_CTX_PTR(adapter);
+	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+	eHalStatus hal_status;
+	VOS_STATUS status;
+	uint32_t type, sub_type;
+	int32_t ret_val = 0;
+	unsigned long rc;
+	uint32_t timeout = WLAN_WAIT_TIME_SESSIONOPENCLOSE;
+
+	INIT_COMPLETION(adapter->session_open_comp_var);
+	sme_SetCurrDeviceMode(hdd_ctx->hHal, adapter->device_mode);
+	sme_set_pdev_ht_vht_ies(hdd_ctx->hHal, hdd_ctx->cfg_ini->enable2x2);
+	status = vos_get_vdev_types(adapter->device_mode, &type, &sub_type);
+	if (VOS_STATUS_SUCCESS != status) {
+		hddLog(LOGE, "failed to get vdev type");
+		goto error_sme_open;
+	}
+
+	/* open sme session for future use */
+	hal_status = sme_OpenSession(hdd_ctx->hHal, hdd_smeRoamCallback,
+			adapter, (uint8_t *)&adapter->macAddressCurrent,
+			&adapter->sessionId, type, sub_type);
+	if (!HAL_STATUS_SUCCESS(hal_status)) {
+		hddLog(LOGE, "sme_OpenSession() failed with status code %d",
+				hal_status);
+		ret_val = -EAGAIN;
+		goto error_sme_open;
+	}
+
+	/* Block on a completion variable. Can't wait forever though */
+	rc = wait_for_completion_timeout(
+			&adapter->session_open_comp_var,
+			msecs_to_jiffies(timeout));
+	if (!rc) {
+		hddLog(LOGE,
+			FL("Failed to open session, timeout code: %ld"), rc);
+		ret_val = -ETIMEDOUT;
+		goto error_sme_open;
+	}
+
+	/* Register wireless extensions */
+	if (eHAL_STATUS_SUCCESS != (hal_status = hdd_register_wext(wlan_dev))) {
+		hddLog(LOGE, FL("Wext registration failed with status code %d"),
+				hal_status);
+		ret_val = -EAGAIN;
+		goto error_register_wext;
+	}
+
+	status = hdd_init_tx_rx(adapter);
+	if (VOS_STATUS_SUCCESS != status) {
+		hddLog(LOGE, FL("hdd_init_tx_rx() init failed, status %d"),
+				status);
+		ret_val = -EAGAIN;
+		goto error_init_txrx;
+	}
+
+	set_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
+
+	status = hdd_wmm_adapter_init(adapter);
+	if (VOS_STATUS_SUCCESS != status) {
+		hddLog(LOGE, FL("hdd_wmm_adapter_init() failed, status %d"),
+				status);
+		ret_val = -EAGAIN;
+		goto error_wmm_init;
+	}
+
+	set_bit(WMM_INIT_DONE, &adapter->event_flags);
+
+	ret_val = process_wma_set_command((int)adapter->sessionId,
+			(int)WMI_PDEV_PARAM_BURST_ENABLE,
+			(int)hdd_ctx->cfg_ini->enableSifsBurst,
+			PDEV_CMD);
+	if (0 != ret_val) {
+		hddLog(LOGE, FL("WMI_PDEV_PARAM_BURST_ENABLE set failed %d"),
+				ret_val);
+	}
+
+	ndp_ctx->state = NAN_DATA_NDI_CREATING_STATE;
+	return ret_val;
+
+error_wmm_init:
+	clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
+	hdd_deinit_tx_rx(adapter);
+
+error_init_txrx:
+	hdd_UnregisterWext(wlan_dev);
+
+error_register_wext:
+	if (test_bit(SME_SESSION_OPENED, &adapter->event_flags)) {
+		INIT_COMPLETION(adapter->session_close_comp_var);
+		if (eHAL_STATUS_SUCCESS ==
+				sme_CloseSession(hdd_ctx->hHal,
+					adapter->sessionId,
+					hdd_smeCloseSessionCallback, adapter)) {
+			rc = wait_for_completion_timeout(
+					&adapter->session_close_comp_var,
+					msecs_to_jiffies(timeout));
+			if (rc <= 0) {
+				hddLog(LOGE,
+					FL("Session close failed status %ld"),
+					rc);
+				ret_val = -ETIMEDOUT;
+			}
+		}
+	}
+
+error_sme_open:
+	return ret_val;
+}
diff --git a/CORE/HDD/src/wlan_hdd_nan_datapath.h b/CORE/HDD/src/wlan_hdd_nan_datapath.h
index 104a8b63763c..23fb9ab7375b 100644
--- a/CORE/HDD/src/wlan_hdd_nan_datapath.h
+++ b/CORE/HDD/src/wlan_hdd_nan_datapath.h
@@ -23,32 +23,220 @@
  *
  * WLAN Host Device Driver nan datapath API specification
  */
-
 #ifndef __WLAN_HDD_NAN_DATAPATH_H
 #define __WLAN_HDD_NAN_DATAPATH_H
 
 struct hdd_context_s;
 struct hdd_tgt_cfg;
 struct hdd_config;
+struct hdd_adapter_s;
+struct wireless_dev;
+
+/* NAN Social channels */
+#define NAN_SOCIAL_CHANNEL_2_4GHZ 6
+#define NAN_SOCIAL_CHANNEL_5GHZ_LOWER_BAND 44
+#define NAN_SOCIAL_CHANNEL_5GHZ_UPPER_BAND 149
+
+#define NDP_APP_INFO_LEN 255
+#define NDP_QOS_INFO_LEN 255
+
+#ifdef WLAN_FEATURE_NAN_DATAPATH
+#define WLAN_HDD_NDP_GET_SSID(adapter) ( \
+	&(adapter)->sessionCtx.ndp_ctx.conn_info.SSID)
+
+#define WLAN_HDD_NDP_GET_BSSID(adapter) ( \
+	&(adapter)->sessionCtx.ndp_ctx.conn_info.bssId)
+#else
+#define WLAN_HDD_NDP_GET_SSID(adapter)  (NULL)
+#define WLAN_HDD_NDP_GET_BSSID(adapter) (NULL)
+#endif /* WLAN_FEATURE_NAN_DATAPATH */
+
+/**
+ * enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD: NDP Sub command
+ * @QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID: Transaction id reference
+ * @QCA_WLAN_VENDOR_ATTR_NDP_STATUS_ID: NDP status id
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID: Service instance id
+ * @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_SPEC_CHANNEL: Requested channel
+ * @QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR: Peer discovery mac addr
+ * @QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR: Iface name
+ * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY: Security configuration
+ * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS: Qos configuration
+ * @QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO_LEN: Application info length
+ * @QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO: Application info
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID: NDP instance id
+ * @QCA_WLAN_VENDOR_ATTR_NDP_NUM_INSTANCE_ID: Number of NDP instance ids
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY: NDP instance id array
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_RESPONSE_CODE: Schedule response
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_STATUS_CODE: schedule status
+ * @QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR: NDI mac address
+ * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_TYPE: Driver return status
+ * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE: Driver return value
+ */
+enum qca_wlan_vendor_attr_ndp_params {
+	QCA_WLAN_VENDOR_ATTR_NDP_PARAM_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
+	QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
+	QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID,
+	QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_SPEC_CHANNEL,
+	QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR,
+	QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
+	QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY,
+	QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS,
+	QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO_LEN,
+	QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
+	QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
+	QCA_WLAN_VENDOR_ATTR_NDP_NUM_INSTANCE_ID,
+	QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY,
+	QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_RESPONSE_CODE,
+	QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_STATUS_CODE,
+	QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
+	QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_TYPE,
+	QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
+
+	QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX =
+		QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST - 1,
+};
+
+/**
+ * enum qca_wlan_vendor_attr_ndp_cfg_security - vendor security attribute
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SECURITY_ENABLE: Security enabled
+ */
+enum qca_wlan_vendor_attr_ndp_cfg_security {
+	QCA_WLAN_VENDOR_ATTR_NDP_SECURITY_ENABLE = 1,
+};
+
+/**
+ * enum qca_wlan_vendor_attr_ndp_qos - vendor qos attribute
+ * @QCA_WLAN_VENDOR_ATTR_NDP_QOS_CONFIG: NDP QoS configuration
+ */
+enum qca_wlan_vendor_attr_ndp_qos {
+	QCA_WLAN_VENDOR_ATTR_NDP_QOS_CONFIG = 1,
+};
+
+/**
+ * enum qca_wlan_vendor_attr_ndp_sub_cmd_value - NDP subcmd value
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INVALID: Unused subcmd value
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE: iface create
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: iface delete
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: NDP initiator request
+ * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE: NDP initiator response
+ * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: NDP responder request
+ * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE: NDP responder response
+ * @QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: NDP end request
+ * @QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE: NDP end response
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REQUEST: NDP update request
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_RESPONSE: NDP update response
+ * @QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND: NDP request indication
+ * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND: NDP confirm indication
+ * @QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_IND: NDP sched update indication
+ * @QCA_WLAN_VENDOR_ATTR_NDP_END_IND: NDP End indication
+ */
+enum qca_wlan_vendor_attr_ndp_sub_cmd_value {
+	QCA_WLAN_VENDOR_ATTR_NDP_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE = 1,
+	QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE = 2,
+	QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST = 3,
+	QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE = 4,
+	QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST = 5,
+	QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE = 6,
+	QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST = 7,
+	QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE = 8,
+	QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REQUEST = 9,
+	QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_RESPONSE = 10,
+	QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND = 11,
+	QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND = 12,
+	QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_IND = 13,
+	QCA_WLAN_VENDOR_ATTR_NDP_END_IND = 14
+};
+
+/** enum nan_datapath_state - NAN datapath states
+ * @NAN_DATA_NDI_CREATING_STATE: NDI create is in progress
+ * @NAN_DATA_NDI_CREATED_STATE: NDI successfully crated
+ * @NAN_DATA_NDI_DELETING_STATE: NDI delete is in progress
+ * @NAN_DATA_NDI_DELETED_STATE: NDI delete is in progress
+ * @NAN_DATA_PEER_CREATE_STATE: Peer create is in progress
+ * @NAN_DATA_PEER_DELETE_STATE: Peer delete is in progrss
+ * @NAN_DATA_CONNECTING_STATE: Data connection in progress
+ * @NAN_DATA_CONNECTED_STATE: Data connection successful
+ * @NAN_DATA_END_STATE: NDP end is in progress
+ * @NAN_DATA_DISCONNECTED_STATE: NDP is in disconnected state
+ */
+enum nan_datapath_state {
+	NAN_DATA_NDI_CREATING_STATE = 0,
+	NAN_DATA_NDI_CREATED_STATE = 1,
+	NAN_DATA_NDI_DELETING_STATE = 2,
+	NAN_DATA_NDI_DELETED_STATE = 3,
+	NAN_DATA_PEER_CREATE_STATE = 4,
+	NAN_DATA_PEER_DELETE_STATE = 5,
+	NAN_DATA_CONNECTING_STATE = 6,
+	NAN_DATA_CONNECTED_STATE = 7,
+	NAN_DATA_END_STATE = 8,
+	NAN_DATA_DISCONNECTED_STATE = 9,
+};
+
+/**
+ * struct nan_datapath_ctx - context for nan data path
+ * @state: Current state of NDP
+ * @active_ndp_sessions: active ndp sessions per adapter
+ * @ndp_create_transaction_id: transaction id for create req
+ * @ndp_delete_transaction_id: transaction id for delete req
+ * @wext_state: Wext state variable
+ * @conn_info: NDP connection info
+ * @roam_info: NDP roam info
+ * @gtk_offload_req_params: GTK offload request params
+ * @ndp_key_installed: NDP security key installed
+ * @ndp_enc_key: NDP encryption key info
+ * @ndp_debug_state: debug state info
+ */
+struct nan_datapath_ctx {
+	enum nan_datapath_state state;
+	uint32_t active_ndp_sessions;
+	uint16_t ndp_create_transaction_id;
+	uint16_t ndp_delete_transaction_id;
+	hdd_wext_state_t wext_state;
+	connection_info_t conn_info;
+#ifdef WLAN_FEATURE_GTK_OFFLOAD
+	tSirGtkOffloadParams gtk_offload_req_params;
+#endif
+	bool ndp_key_installed;
+	tCsrRoamSetKey ndp_enc_key;
+	uint32_t ndp_debug_state;
+};
 
 #ifdef WLAN_FEATURE_NAN_DATAPATH
 void hdd_ndp_print_ini_config(struct hdd_context_s *hdd_ctx);
-void hdd_nan_datapath_enable(struct hdd_config *cfg_ini, bool enable);
-void hdd_nan_datapath_target_config(struct hdd_context_s *hdd_ctx,
+void hdd_nan_datapath_target_config(hdd_context_t *hdd_ctx,
 				struct hdd_tgt_cfg *cfg);
-
+void hdd_ndp_event_handler(struct hdd_adapter_s *adapter,
+	tCsrRoamInfo *roam_info, uint32_t roam_id, eRoamCmdStatus roam_status,
+	eCsrRoamResult roam_result);
+int wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy,
+	struct wireless_dev *wdev, const void *data, int data_len);
+int hdd_init_nan_data_mode(struct hdd_adapter_s *adapter);
 #else
 static inline void hdd_ndp_print_ini_config(struct hdd_context_s *hdd_ctx)
 {
 }
-static inline void hdd_nan_datapath_enable(struct hdd_config *cfg_ini, bool enable)
-{
-}
 static inline void hdd_nan_datapath_target_config(struct hdd_context_s *hdd_ctx,
 						struct hdd_tgt_cfg *cfg)
 {
 }
-
+static inline void hdd_ndp_event_handler(struct hdd_adapter_s *adapter,
+	tCsrRoamInfo *roam_info, uint32_t roam_id, eRoamCmdStatus roam_status,
+	eCsrRoamResult roam_result)
+{
+}
+static inline int wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy,
+		struct wireless_dev *wdev, const void *data, int data_len)
+{
+	return 0;
+}
+static inline int hdd_init_nan_data_mode(struct hdd_adapter_s *adapter)
+{
+	return 0;
+}
 #endif /* WLAN_FEATURE_NAN_DATAPATH */
 
 #endif /* __WLAN_HDD_NAN_DATAPATH_H */
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 5bfacefc0b95..f6f4e4913b12 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -110,6 +110,7 @@
 #include "wlan_hdd_ocb.h"
 #include "wlan_hdd_tsf.h"
 #include "vos_nvitem.h"
+#include "wlan_hdd_nan_datapath.h"
 
 #define HDD_FINISH_ULA_TIME_OUT         800
 #define HDD_SET_MCBC_FILTERS_TO_FW      1
@@ -1501,7 +1502,12 @@ void ccmCfgSetCallback(tHalHandle halHandle, tANI_S32 result)
 void hdd_clearRoamProfileIe( hdd_adapter_t *pAdapter)
 {
    int i = 0;
-   hdd_wext_state_t *pWextState= WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
+   hdd_wext_state_t *pWextState;
+
+   if (WLAN_HDD_NDI == pAdapter->device_mode)
+       pWextState = WLAN_HDD_GET_NDP_WEXT_STATE_PTR(pAdapter);
+   else
+       pWextState= WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
 
    /* clear WPA/RSN/WSC IE information in the profile */
    pWextState->roamProfile.nWPAReqIELength = 0;
@@ -12716,16 +12722,29 @@ int hdd_validate_mcc_config(hdd_adapter_t *pAdapter, v_UINT_t staId, v_UINT_t ar
 int hdd_set_wext(hdd_adapter_t *pAdapter)
 {
     hdd_wext_state_t *pwextBuf;
-    hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
-
-    pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
+    hdd_station_ctx_t *pHddStaCtx;
+    //struct nan_datapath_ctx *nan_ctx;
+    tCsrSSIDInfo *ssid_list;
+    tCsrBssid *bssid;
+
+    if (WLAN_HDD_NDI == pAdapter->device_mode) {
+       pwextBuf = WLAN_HDD_GET_NDP_WEXT_STATE_PTR(pAdapter);
+       //nan_ctx = WLAN_HDD_GET_NDP_CTX_PTR(pAdapter);
+       ssid_list = WLAN_HDD_NDP_GET_SSID(pAdapter);
+       bssid = WLAN_HDD_NDP_GET_BSSID(pAdapter);
+    } else {
+       pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
+       pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
+       ssid_list = &pHddStaCtx->conn_info.SSID;
+       bssid = &pHddStaCtx->conn_info.bssId;
+    }
 
-    // Now configure the roaming profile links. To SSID and bssid.
+    /* Now configure the roaming profile links. To SSID and bssid */
     pwextBuf->roamProfile.SSIDs.numOfSSIDs = 0;
-    pwextBuf->roamProfile.SSIDs.SSIDList = &pHddStaCtx->conn_info.SSID;
+    pwextBuf->roamProfile.SSIDs.SSIDList = ssid_list;
 
     pwextBuf->roamProfile.BSSIDs.numOfBSSIDs = 0;
-    pwextBuf->roamProfile.BSSIDs.bssid = &pHddStaCtx->conn_info.bssId;
+    pwextBuf->roamProfile.BSSIDs.bssid = bssid;
 
     /*Set the numOfChannels to zero to scan all the channels*/
     pwextBuf->roamProfile.ChannelInfo.numOfChannels = 0;
@@ -12756,41 +12775,49 @@ int hdd_set_wext(hdd_adapter_t *pAdapter)
 
     }
 
+/**
+ * hdd_register_wext() - register wext context
+ * @dev: net device handle
+ *
+ * Registers wext interface context for a given net device
+ *
+ * Returns: 0 on success, errno on failure
+ */
 int hdd_register_wext(struct net_device *dev)
-    {
+{
     hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
-    hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
+    hdd_wext_state_t *pwextBuf;
     VOS_STATUS status;
 
-   ENTER();
+    ENTER();
 
-    // Zero the memory.  This zeros the profile structure.
-   memset(pwextBuf, 0,sizeof(hdd_wext_state_t));
+    if (WLAN_HDD_NDI == pAdapter->device_mode)
+        pwextBuf = WLAN_HDD_GET_NDP_WEXT_STATE_PTR(pAdapter);
+    else
+        pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
 
-    init_completion(&(WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter))->completion_var);
+    /* Zero the memory. This zeros the profile structure */
+    memset(pwextBuf, 0, sizeof(hdd_wext_state_t));
 
+    init_completion(&pwextBuf->completion_var);
 
     status = hdd_set_wext(pAdapter);
-
-    if(!VOS_IS_STATUS_SUCCESS(status)) {
-
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, ("ERROR: hdd_set_wext failed!!"));
+    if (!VOS_IS_STATUS_SUCCESS(status)) {
+        hddLog(LOGE, FL("ERROR: hdd_set_wext failed!!"));
         return eHAL_STATUS_FAILURE;
     }
 
-    if (!VOS_IS_STATUS_SUCCESS(vos_event_init(&pwextBuf->vosevent)))
-    {
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, ("ERROR: HDD vos event init failed!!"));
+    if (!VOS_IS_STATUS_SUCCESS(vos_event_init(&pwextBuf->vosevent))) {
+        hddLog(LOGE, FL("ERROR: HDD vos event init failed!!"));
         return eHAL_STATUS_FAILURE;
     }
 
-    if (!VOS_IS_STATUS_SUCCESS(vos_event_init(&pwextBuf->scanevent)))
-    {
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, ("ERROR: HDD scan event init failed!!"));
+    if (!VOS_IS_STATUS_SUCCESS(vos_event_init(&pwextBuf->scanevent))) {
+        hddLog(LOGE, ("ERROR: HDD scan event init failed!!"));
         return eHAL_STATUS_FAILURE;
     }
 
-    // Register as a wireless device
+    /* Register as a wireless device */
     dev->wireless_handlers = (struct iw_handler_def *)&we_handler_def;
 
     EXIT();
diff --git a/CORE/SME/inc/csrApi.h b/CORE/SME/inc/csrApi.h
index 27c68735fc97..a5d2177e21e5 100644
--- a/CORE/SME/inc/csrApi.h
+++ b/CORE/SME/inc/csrApi.h
@@ -650,7 +650,7 @@ typedef enum
     eCSR_ROAM_RESULT_NDP_NEW_PEER_IND,
     eCSR_ROAM_RESULT_NDP_CONFIRM_IND,
     eCSR_ROAM_RESULT_NDP_INDICATION,
-    eCSR_ROAM_RESULT_NDP_RESPONDER_REQ,
+    eCSR_ROAM_RESULT_NDP_SCHED_UPDATE_RSP,
     eCSR_ROAM_RESULT_NDP_RESPONDER_RSP,
     eCSR_ROAM_RESULT_NDP_END_RSP,
     eCSR_ROAM_RESULT_NDP_PEER_DEPARTED_IND,