qcacmn: NDP_INITIATOR_REQ implementation

Add implementation for NDP_INITIATOR_REQ.

Change-Id: Ieb4cb79d500fd75b23b4a3f8bfa414d14eb6fe18
CRs-Fixed: 2014795

os_if/linux/nan/inc/os_if_nan.h

@@ -153,6 +153,16 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
 int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 				     struct nan_callbacks *cb_obj);
 
+/**
+ * os_if_nan_register_lim_callbacks: os_if api to register lim callbacks
+ * @psoc: pointer to psoc object
+ * @cb_obj: struct pointer containing callbacks
+ *
+ * Return: status of operation
+ */
+int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
+				     struct nan_callbacks *cb_obj);
+
 /**
  * os_if_nan_post_ndi_create_rsp: os_if api to pos ndi create rsp to umac nan
  * component

os_if/linux/nan/src/os_if_nan.c

@@ -24,6 +24,7 @@
 #include "qdf_trace.h"
 #include "os_if_nan.h"
 #include "wlan_nan_api.h"
+#include "nan_ucfg_api.h"
 #include "nan_public_structs.h"
 #include "wlan_osif_priv.h"
 #include <net/cfg80211.h>
@@ -168,6 +169,147 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc,
 	return cb_obj.ndi_delete(vdev_id, iface_name, transaction_id);
 }
 
+/**
+ * os_if_nan_process_ndp_initiator_req() - NDP initiator request handler
+ * @ctx: hdd context
+ * @tb: parsed NL attribute list
+ *
+ * tb will contain following vendor attributes:
+ * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR
+ * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID
+ * QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL - optional
+ * QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG
+ * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID
+ * QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR
+ * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional
+ * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional
+ * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional
+ * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional
+ *
+ * Return:  0 on success or error code on failure
+ */
+static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc,
+					       struct nlattr **tb)
+{
+	int ret = 0;
+	char *iface_name;
+	QDF_STATUS status;
+	uint32_t ndp_qos_cfg;
+	enum nan_datapath_state state;
+	struct wlan_objmgr_vdev *nan_vdev;
+	struct nan_datapath_initiator_req req = {0};
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) {
+		cfg80211_err("Interface name string is unavailable");
+		return -EINVAL;
+	}
+
+	iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]);
+	nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID);
+	if (!nan_vdev) {
+		cfg80211_err("NAN data interface %s not available", iface_name);
+		return -EINVAL;
+	}
+
+	state = ucfg_nan_get_ndi_state(nan_vdev);
+	if (state == NAN_DATA_NDI_DELETED_STATE ||
+	    state == NAN_DATA_NDI_DELETING_STATE ||
+	    state == NAN_DATA_NDI_CREATING_STATE) {
+		cfg80211_err("Data request not allowed in NDI current state: %d",
+			  state);
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) {
+		cfg80211_err("Transaction ID is unavailable");
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+	req.transaction_id =
+		nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]);
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL])
+		req.channel = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]);
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]) {
+		req.channel_cfg =
+		    nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]);
+	} else {
+		cfg80211_err("Channel config is unavailable");
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]) {
+		cfg80211_err("NDP service instance ID is unavailable");
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+	req.service_instance_id =
+		nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]);
+
+	qdf_mem_copy(req.self_ndi_mac_addr.bytes,
+		     wlan_vdev_mlme_get_macaddr(nan_vdev), QDF_MAC_ADDR_SIZE);
+
+	if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]) {
+		cfg80211_err("NDI peer discovery mac addr is unavailable");
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+	qdf_mem_copy(req.peer_discovery_mac_addr.bytes,
+		nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]),
+		QDF_MAC_ADDR_SIZE);
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) {
+		req.ndp_info.ndp_app_info_len =
+			nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]);
+		req.ndp_info.ndp_app_info =
+			nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]);
+	}
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) {
+		/* at present ndp config stores 4 bytes QOS info only */
+		req.ndp_config.ndp_cfg_len = 4;
+		req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg;
+		ndp_qos_cfg =
+			nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]);
+	}
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] &&
+		!tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) {
+		cfg80211_err("PMK cannot be absent when CSID is present.");
+		ret = -EINVAL;
+		goto initiator_req_failed;
+	}
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) {
+		req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]);
+		req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]);
+		QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD,
+				QDF_TRACE_LEVEL_DEBUG,
+				req.pmk.pmk, req.pmk.pmk_len);
+	}
+
+	if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) {
+		req.ncs_sk_type =
+			nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]);
+
+	}
+
+	cfg80211_debug("vdev_id: %d, transaction_id: %d, channel: %d, service_instance_id: %d, ndp_app_info_len: %d, csid: %d, peer_discovery_mac_addr: %pM",
+		wlan_vdev_get_id(nan_vdev), req.transaction_id, req.channel,
+		req.service_instance_id, req.ndp_info.ndp_app_info_len,
+		req.ncs_sk_type, req.peer_discovery_mac_addr.bytes);
+
+	status = ucfg_nan_req_processor(nan_vdev, &req, NDP_INITIATOR_REQ);
+	ret = qdf_status_to_os_return(status);
+initiator_req_failed:
+	wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID);
+
+	return ret;
+}
+
 int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
 			      const void *data, int data_len)
 {
@@ -211,6 +353,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
 		return os_if_nan_process_ndi_create(psoc, tb);
 	case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE:
 		return os_if_nan_process_ndi_delete(psoc, tb);
+	case QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST:
+		return os_if_nan_process_ndp_initiator_req(psoc, tb);
 	default:
 		cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type);
 		return -EINVAL;
@@ -219,6 +363,368 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc,
 	return -EINVAL;
 }
 
+/**
+ * os_if_ndp_initiator_rsp_handler() - NDP initiator response handler
+ * @vdev: pointer to vdev object
+ * @rsp_params: response parameters
+ *
+ * Following vendor event is sent to cfg80211:
+ * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
+ *         QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes)
+ *
+ * Return: none
+ */
+static void os_if_ndp_initiator_rsp_handler(struct wlan_objmgr_vdev *vdev,
+					struct nan_datapath_initiator_rsp *rsp)
+{
+	uint32_t data_len;
+	struct sk_buff *vendor_event;
+	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
+	struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
+
+	if (!rsp) {
+		cfg80211_err("Invalid NDP Initator response");
+		return;
+	}
+
+	data_len = (4 * sizeof(uint32_t)) + (1 * sizeof(uint16_t)) +
+				NLMSG_HDRLEN + (5 * NLA_HDRLEN);
+	vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL,
+				data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+				GFP_ATOMIC);
+	if (!vendor_event) {
+		cfg80211_err("cfg80211_vendor_event_alloc failed");
+		return;
+	}
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
+			QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE))
+		goto ndp_initiator_rsp_nla_failed;
+
+	if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID,
+			rsp->transaction_id))
+		goto ndp_initiator_rsp_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
+			rsp->ndp_instance_id))
+		goto ndp_initiator_rsp_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE,
+			rsp->status))
+		goto ndp_initiator_rsp_nla_failed;
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
+			rsp->reason))
+		goto ndp_initiator_rsp_nla_failed;
+
+	cfg80211_debug("NDP Initiator rsp sent, tid:%d, instance id:%d, status:%d, reason: %d",
+	       rsp->transaction_id, rsp->ndp_instance_id, rsp->status,
+	       rsp->reason);
+	cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
+	return;
+ndp_initiator_rsp_nla_failed:
+	cfg80211_err("nla_put api failed");
+	kfree_skb(vendor_event);
+}
+
+/**
+ * os_if_ndp_indication_handler() - NDP indication handler
+ * @vdev: pointer to vdev object
+ * @ind_params: indication parameters
+ *
+ * Following vendor event is sent to cfg80211:
+ * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
+ *         QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ)
+ * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR (6 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size)
+ * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE(4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_SCID(scid_len in size)
+ *
+ * Return: none
+ */
+static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev,
+				struct nan_datapath_indication_event *event)
+{
+	uint16_t data_len;
+	uint32_t ndp_qos_config;
+	struct sk_buff *vendor_event;
+	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
+	struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
+	enum nan_datapath_state state;
+
+	if (!event) {
+		cfg80211_err("Invalid NDP Indication");
+		return;
+	}
+
+	cfg80211_debug("NDP Indication, policy: %d", event->policy);
+	state = ucfg_nan_get_ndi_state(vdev);
+	/* check if we are in middle of deleting/creating the interface */
+
+	if (state == NAN_DATA_NDI_DELETED_STATE ||
+	    state == NAN_DATA_NDI_DELETING_STATE ||
+	    state == NAN_DATA_NDI_CREATING_STATE) {
+		cfg80211_err("Data request not allowed in current NDI state: %d",
+			state);
+		return;
+	}
+
+	data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + IFNAMSIZ +
+		event->ndp_info.ndp_app_info_len + event->scid.scid_len +
+		(10 * NLA_HDRLEN) + NLMSG_HDRLEN;
+
+	/* notify response to the upper layer */
+	vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy,
+					NULL, data_len,
+					QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+					GFP_ATOMIC);
+	if (!vendor_event) {
+		cfg80211_err("cfg80211_vendor_event_alloc failed");
+		return;
+	}
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
+	   QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND))
+		goto ndp_indication_nla_failed;
+
+	if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
+	   IFNAMSIZ, "nan0"/* adapter->dev->name - fetch dev name */))
+		goto ndp_indication_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+	   QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID,
+	   event->service_instance_id))
+		goto ndp_indication_nla_failed;
+
+	if (nla_put(vendor_event,
+	   QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
+	   QDF_MAC_ADDR_SIZE, event->peer_mac_addr.bytes))
+		goto ndp_indication_nla_failed;
+
+	if (nla_put(vendor_event,
+	   QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR,
+	   QDF_MAC_ADDR_SIZE, event->peer_discovery_mac_addr.bytes))
+		goto ndp_indication_nla_failed;
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
+	   event->ndp_instance_id))
+		goto ndp_indication_nla_failed;
+
+	if (event->ndp_info.ndp_app_info_len)
+		if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
+		   event->ndp_info.ndp_app_info_len,
+		   event->ndp_info.ndp_app_info))
+			goto ndp_indication_nla_failed;
+
+	if (event->ndp_config.ndp_cfg_len) {
+		ndp_qos_config = *((uint32_t *)event->ndp_config.ndp_cfg);
+		/* at present ndp config stores 4 bytes QOS info only */
+		if (nla_put_u32(vendor_event,
+		   QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS,
+		   ndp_qos_config))
+			goto ndp_indication_nla_failed;
+	}
+
+	if (event->scid.scid_len) {
+		if (nla_put_u32(vendor_event,
+				QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE,
+				event->ncs_sk_type))
+			goto ndp_indication_nla_failed;
+
+		if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SCID,
+				event->scid.scid_len,
+				event->scid.scid))
+			goto ndp_indication_nla_failed;
+
+		cfg80211_debug("csid: %d, scid_len: %d",
+			event->ncs_sk_type, event->scid.scid_len);
+
+		QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
+				event->scid.scid, event->scid.scid_len);
+	}
+
+	cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
+	return;
+ndp_indication_nla_failed:
+	cfg80211_err("nla_put api failed");
+	kfree_skb(vendor_event);
+}
+
+/**
+ * os_if_ndp_confirm_ind_handler() - NDP confirm indication handler
+ * @vdev: pointer to vdev object
+ * @ind_params: indication parameters
+ *
+ * Following vendor event is sent to cfg80211:
+ * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD =
+ *         QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ)
+ * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size)
+ * QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE (4 bytes)
+ * QCA_WLAN_VENDOR_ATTR_NDP_RETURN_VALUE (4 bytes)
+ *
+ * Return: none
+ */
+static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
+				struct nan_datapath_confirm_event *ndp_confirm)
+{
+	int idx = 0;
+	uint32_t data_len;
+	QDF_STATUS status;
+	uint32_t ndp_qos_config = 0;
+	struct sk_buff *vendor_event;
+	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
+	struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev);
+	struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
+	struct nan_callbacks cb_obj;
+
+	if (!ndp_confirm) {
+		cfg80211_err("Invalid NDP Initator response");
+		return;
+	}
+
+	status = ucfg_nan_get_callbacks(psoc, &cb_obj);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		cfg80211_err("couldn't get callbacks");
+		return;
+	}
+
+	/* ndp_confirm is called each time user generated ndp req succeeds */
+	idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev),
+				&ndp_confirm->peer_ndi_mac_addr);
+
+	if (idx < 0)
+		cfg80211_err("can't find addr: %pM in vdev_id: %d, peer table.",
+			&ndp_confirm->peer_ndi_mac_addr,
+			wlan_vdev_get_id(vdev));
+	else if (ndp_confirm->rsp_code == NAN_DATAPATH_RESPONSE_ACCEPT) {
+		uint32_t active_sessions =
+			ucfg_nan_get_active_ndp_sessions(vdev, idx);
+		ucfg_nan_set_active_ndp_sessions(vdev, active_sessions + 1,
+						 idx);
+	}
+
+	data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + IFNAMSIZ +
+			+ NLMSG_HDRLEN + (7 * NLA_HDRLEN) +
+			ndp_confirm->ndp_info.ndp_app_info_len;
+
+	if (ndp_confirm->ndp_info.ndp_app_info_len)
+		data_len += NLA_HDRLEN + ndp_confirm->ndp_info.ndp_app_info_len;
+
+	vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL,
+				data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX,
+				GFP_ATOMIC);
+	if (!vendor_event) {
+		cfg80211_err("cfg80211_vendor_event_alloc failed");
+		return;
+	}
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD,
+			QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND))
+		goto ndp_confirm_nla_failed;
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID,
+			ndp_confirm->ndp_instance_id))
+		goto ndp_confirm_nla_failed;
+
+	if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR,
+		QDF_MAC_ADDR_SIZE, ndp_confirm->peer_ndi_mac_addr.bytes))
+		goto ndp_confirm_nla_failed;
+
+	if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR,
+		    IFNAMSIZ, "nan0" /* TBD adapter->dev->name - fetch name */))
+		goto ndp_confirm_nla_failed;
+
+	if (ndp_confirm->ndp_info.ndp_app_info_len && nla_put(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO,
+			ndp_confirm->ndp_info.ndp_app_info_len,
+			ndp_confirm->ndp_info.ndp_app_info))
+		goto ndp_confirm_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE,
+			ndp_confirm->rsp_code))
+		goto ndp_confirm_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE,
+			ndp_confirm->reason_code))
+		goto ndp_confirm_nla_failed;
+
+	cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
+	cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM, ndp_cfg: %d, rsp_code: %d, reason_code: %d",
+		ndp_confirm->ndp_instance_id,
+		ndp_confirm->peer_ndi_mac_addr.bytes,
+		ndp_qos_config, ndp_confirm->rsp_code,
+		ndp_confirm->reason_code);
+
+	cfg80211_debug("NDP confim, ndp app info dump");
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
+			   ndp_confirm->ndp_info.ndp_app_info,
+			   ndp_confirm->ndp_info.ndp_app_info_len);
+	return;
+ndp_confirm_nla_failed:
+	cfg80211_err("nla_put api failed");
+	kfree_skb(vendor_event);
+}
+
+/**
+ * os_if_new_peer_ind_handler() - NDP new peer indication handler
+ * @adapter: pointer to adapter context
+ * @ind_params: indication parameters
+ *
+ * Return: none
+ */
+static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev,
+			struct nan_datapath_peer_ind *peer_ind)
+{
+	int ret;
+	QDF_STATUS status;
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+	struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev);
+	uint32_t active_peers = ucfg_nan_get_active_peers(vdev);
+	struct nan_callbacks cb_obj;
+
+	if (NULL == peer_ind) {
+		cfg80211_err("Invalid new NDP peer params");
+		return;
+	}
+
+	status = ucfg_nan_get_callbacks(psoc, &cb_obj);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		cfg80211_err("failed to get callbacks");
+		return;
+	}
+
+	cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d",
+		peer_ind->session_id, peer_ind->peer_mac_addr.bytes,
+		peer_ind->sta_id);
+	ret = cb_obj.new_peer_ind(vdev_id, peer_ind->sta_id,
+				&peer_ind->peer_mac_addr,
+				(active_peers == 0 ? true : false));
+	if (ret) {
+		cfg80211_err("new peer handling at HDD failed %d", ret);
+		return;
+	}
+
+	active_peers++;
+	ucfg_nan_set_active_peers(vdev, active_peers);
+	cfg80211_debug("vdev_id: %d, num_peers: %d", vdev_id, active_peers);
+}
+
 /**
  * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler
  * @adapter: pointer to adapter context
@@ -393,6 +899,18 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
 	case NAN_DATAPATH_INF_DELETE_RSP:
 		os_if_ndp_iface_delete_rsp_handler(psoc, vdev, msg);
 		break;
+	case NDP_CONFIRM:
+		os_if_ndp_confirm_ind_handler(vdev, msg);
+		break;
+	case NDP_INITIATOR_RSP:
+		os_if_ndp_initiator_rsp_handler(vdev, msg);
+		break;
+	case NDP_INDICATION:
+		os_if_ndp_indication_handler(vdev, msg);
+		break;
+	case NDP_NEW_PEER:
+		os_if_new_peer_ind_handler(vdev, msg);
+		break;
 	default:
 		break;
 	}
@@ -405,6 +923,12 @@ int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 						os_if_nan_event_handler);
 }
 
+int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
+				     struct nan_callbacks *cb_obj)
+{
+	return ucfg_nan_register_lim_callbacks(psoc, cb_obj);
+}
+
 void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc,
 				   uint8_t vdev_id, bool success)
 {

target_if/nan/src/target_if_nan.c

@@ -20,12 +20,513 @@
  * DOC: contains nan target if functions
  */
 
-#include "wlan_nan_api.h"
+#include "../../../umac/nan/core/src/nan_main_i.h"
 #include "nan_public_structs.h"
 #include "target_if_nan.h"
+#include "wmi_unified_api.h"
+#include "scheduler_api.h"
 
-static QDF_STATUS target_if_nan_req(void *in_req, uint32_t req_type)
+static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg)
 {
+	QDF_STATUS status;
+	struct wlan_objmgr_vdev *vdev = NULL;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_lmac_if_nan_rx_ops *nan_rx_ops;
+
+	switch (msg->type) {
+	case NDP_INITIATOR_RSP: {
+		struct nan_datapath_initiator_rsp *initiator_rsp = msg->bodyptr;
+		vdev = initiator_rsp->vdev;
+		break;
+	}
+	case NDP_INDICATION: {
+		struct nan_datapath_indication_event *ind = msg->bodyptr;
+		vdev = ind->vdev;
+		break;
+	}
+	case NDP_CONFIRM: {
+		struct nan_datapath_confirm_event *confirm = msg->bodyptr;
+		vdev = confirm->vdev;
+		break;
+	}
+	default:
+		target_if_err("invalid msg type %d", msg->type);
+		qdf_mem_free(msg->bodyptr);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (!vdev) {
+		target_if_err("vdev is null");
+		qdf_mem_free(msg->bodyptr);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	/* try get ref now, if failure, then vdev may have been deleted */
+	status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_NAN_ID);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		nan_alert("couldn't get ref. vdev maybe deleted");
+		qdf_mem_free(msg->bodyptr);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	psoc = wlan_vdev_get_psoc(vdev);
+	if (!psoc) {
+		target_if_err("psoc is null");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+		qdf_mem_free(msg->bodyptr);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	nan_rx_ops = target_if_nan_get_rx_ops(psoc);
+	if (!nan_rx_ops) {
+		target_if_err("nan_rx_ops is null");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+		qdf_mem_free(msg->bodyptr);
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	status = nan_rx_ops->nan_event_rx(msg);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+	qdf_mem_free(msg->bodyptr);
+
+	return status;
+}
+
+static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req)
+{
+	int ret;
+	uint16_t len;
+	wmi_buf_t buf;
+	uint8_t *tlv_ptr;
+	QDF_STATUS status;
+	wmi_channel *ch_tlv;
+	wmi_unified_t wmi_handle;
+	struct wlan_objmgr_psoc *psoc;
+	struct scheduler_msg pe_msg = {0};
+	wmi_ndp_initiator_req_fixed_param *cmd;
+	struct wlan_lmac_if_nan_rx_ops *nan_rx_ops;
+	uint32_t ndp_cfg_len, ndp_app_info_len, pmk_len;
+	struct nan_datapath_initiator_rsp ndp_rsp = {0};
+	struct nan_datapath_initiator_req *ndp_req = req;
+
+	if (!ndp_req) {
+		target_if_err("ndp_req is null.");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	psoc = wlan_vdev_get_psoc(ndp_req->vdev);
+	if (!psoc) {
+		target_if_err("psoc is null.");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);
+	if (!wmi_handle) {
+		target_if_err("wmi_handle is null.");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	nan_rx_ops = target_if_nan_get_rx_ops(psoc);
+	if (!nan_rx_ops) {
+		target_if_err("nan_rx_ops is null.");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	/*
+	 * WMI command expects 4 byte alligned len:
+	 * round up ndp_cfg_len and ndp_app_info_len to 4 bytes
+	 */
+	ndp_cfg_len = qdf_roundup(ndp_req->ndp_config.ndp_cfg_len, 4);
+	ndp_app_info_len = qdf_roundup(ndp_req->ndp_info.ndp_app_info_len, 4);
+	pmk_len = qdf_roundup(ndp_req->pmk.pmk_len, 4);
+	/* allocated memory for fixed params as well as variable size data */
+	len = sizeof(*cmd) + sizeof(*ch_tlv) + (3 * WMI_TLV_HDR_SIZE)
+		+ ndp_cfg_len + ndp_app_info_len + pmk_len;
+
+	buf = wmi_buf_alloc(wmi_handle, len);
+	if (!buf) {
+		target_if_err("wmi_buf_alloc failed");
+		status = QDF_STATUS_E_NOMEM;
+		goto send_ndp_initiator_fail;
+	}
+	cmd = (wmi_ndp_initiator_req_fixed_param *) wmi_buf_data(buf);
+	WMITLV_SET_HDR(&cmd->tlv_header,
+		       WMITLV_TAG_STRUC_wmi_ndp_initiator_req_fixed_param,
+		       WMITLV_GET_STRUCT_TLVLEN(
+				wmi_ndp_initiator_req_fixed_param));
+	cmd->vdev_id = wlan_vdev_get_id(ndp_req->vdev);
+	cmd->transaction_id = ndp_req->transaction_id;
+	cmd->service_instance_id = ndp_req->service_instance_id;
+	WMI_CHAR_ARRAY_TO_MAC_ADDR(ndp_req->peer_discovery_mac_addr.bytes,
+				   &cmd->peer_discovery_mac_addr);
+
+	cmd->ndp_cfg_len = ndp_req->ndp_config.ndp_cfg_len;
+	cmd->ndp_app_info_len = ndp_req->ndp_info.ndp_app_info_len;
+	cmd->ndp_channel_cfg = ndp_req->channel_cfg;
+	cmd->nan_pmk_len = ndp_req->pmk.pmk_len;
+	cmd->nan_csid = ndp_req->ncs_sk_type;
+
+	ch_tlv = (wmi_channel *)&cmd[1];
+	WMITLV_SET_HDR(ch_tlv, WMITLV_TAG_STRUC_wmi_channel,
+			WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
+	ch_tlv->mhz = ndp_req->channel;
+	/*
+	ch_tlv->band_center_freq1 =
+		cds_chan_to_freq(cds_freq_to_chan(ndp_req->channel));
+	*/
+	tlv_ptr = (uint8_t *)&ch_tlv[1];
+
+	WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len);
+	qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE],
+		     ndp_req->ndp_config.ndp_cfg, cmd->ndp_cfg_len);
+	tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_cfg_len;
+
+	WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_app_info_len);
+	qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE],
+		     ndp_req->ndp_info.ndp_app_info, cmd->ndp_app_info_len);
+	tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_app_info_len;
+
+	WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, pmk_len);
+	qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->pmk.pmk,
+		     cmd->nan_pmk_len);
+	tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len;
+
+	target_if_debug("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d",
+		cmd->vdev_id, cmd->transaction_id, cmd->service_instance_id,
+		ch_tlv->mhz, cmd->ndp_channel_cfg, cmd->nan_csid);
+	target_if_debug("peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
+		cmd->peer_discovery_mac_addr.mac_addr31to0,
+		cmd->peer_discovery_mac_addr.mac_addr47to32);
+
+	target_if_debug("ndp_config len: %d", cmd->ndp_cfg_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			   ndp_req->ndp_config.ndp_cfg,
+			   ndp_req->ndp_config.ndp_cfg_len);
+
+	target_if_debug("ndp_app_info len: %d", cmd->ndp_app_info_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			   ndp_req->ndp_info.ndp_app_info,
+			   ndp_req->ndp_info.ndp_app_info_len);
+
+	target_if_debug("pmk len: %d", cmd->nan_pmk_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			   ndp_req->pmk.pmk, cmd->nan_pmk_len);
+	target_if_debug("sending WMI_NDP_INITIATOR_REQ_CMDID(0x%X)",
+		WMI_NDP_INITIATOR_REQ_CMDID);
+
+	ret = wmi_unified_cmd_send(wmi_handle, buf, len,
+				   WMI_NDP_INITIATOR_REQ_CMDID);
+	if (ret < 0) {
+		target_if_err("WMI_NDP_INITIATOR_REQ_CMDID failed, ret: %d",
+			      ret);
+		wmi_buf_free(buf);
+		goto send_ndp_initiator_fail;
+	}
+
+	return QDF_STATUS_SUCCESS;
+send_ndp_initiator_fail:
+	ndp_rsp.vdev = ndp_req->vdev;
+	ndp_rsp.transaction_id = ndp_req->transaction_id;
+	ndp_rsp.ndp_instance_id = ndp_req->service_instance_id;
+	ndp_rsp.status = NAN_DATAPATH_DATA_INITIATOR_REQ_FAILED;
+	pe_msg.type = NDP_INITIATOR_RSP;
+	pe_msg.bodyptr = &ndp_rsp;
+	/* process even here and call callback */
+	if (nan_rx_ops && nan_rx_ops->nan_event_rx)
+		nan_rx_ops->nan_event_rx(&pe_msg);
+
+	return status;
+}
+
+static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data,
+						uint32_t len)
+{
+	QDF_STATUS status;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_psoc *psoc;
+	struct scheduler_msg msg = {0};
+	struct nan_datapath_initiator_rsp *rsp;
+	WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *event;
+	wmi_ndp_initiator_rsp_event_fixed_param  *fixed_params;
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("psoc is null");
+		return -EINVAL;
+	}
+
+	event = (WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *)data;
+	fixed_params = event->fixed_param;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+				fixed_params->vdev_id, WLAN_NAN_ID);
+	if (!vdev) {
+		target_if_err("vdev is null");
+		return -EINVAL;
+	}
+
+	rsp = qdf_mem_malloc(sizeof(*rsp));
+	if (!rsp) {
+		target_if_err("malloc failed");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+		return -ENOMEM;
+	}
+
+	rsp->vdev = vdev;
+	rsp->transaction_id = fixed_params->transaction_id;
+	rsp->ndp_instance_id = fixed_params->ndp_instance_id;
+	rsp->status = fixed_params->rsp_status;
+	rsp->reason = fixed_params->reason_code;
+
+	msg.type = NDP_INITIATOR_RSP;
+	msg.bodyptr = rsp;
+	msg.callback = target_if_nan_event_dispatcher;
+
+	target_if_err("NDP_INITIATOR_RSP sent: %d", msg.type);
+	status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		target_if_err("failed to post msg, status: %d", status);
+		qdf_mem_free(rsp);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data,
+					uint32_t data_len)
+{
+	int ret;
+	QDF_STATUS status;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct scheduler_msg msg = {0};
+	struct nan_datapath_indication_event *rsp;
+	WMI_NDP_INDICATION_EVENTID_param_tlvs *event;
+	wmi_ndp_indication_event_fixed_param *fixed_params;
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("psoc is null");
+		return -EINVAL;
+	}
+
+	event = (WMI_NDP_INDICATION_EVENTID_param_tlvs *)data;
+	fixed_params =
+		(wmi_ndp_indication_event_fixed_param *)event->fixed_param;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+					fixed_params->vdev_id, WLAN_NAN_ID);
+	if (!vdev) {
+		target_if_err("vdev is null");
+		return -EINVAL;
+	}
+
+	rsp = qdf_mem_malloc(sizeof(*rsp));
+	if (!rsp) {
+		target_if_err("malloc failed");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+		return -ENOMEM;
+	}
+
+	rsp->vdev = vdev;
+	rsp->service_instance_id = fixed_params->service_instance_id;
+	rsp->ndp_instance_id = fixed_params->ndp_instance_id;
+	rsp->role = fixed_params->self_ndp_role;
+	rsp->policy = fixed_params->accept_policy;
+
+	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
+				rsp->peer_mac_addr.bytes);
+	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr,
+				rsp->peer_discovery_mac_addr.bytes);
+
+	target_if_debug("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d,\n"
+		"service_instance %d, ndp_instance %d, role %d, policy %d,\n"
+		"csid: %d, scid_len: %d, peer_addr: %pM, peer_disc_addr: %pM",
+		 WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id,
+		 fixed_params->service_instance_id,
+		 fixed_params->ndp_instance_id, fixed_params->self_ndp_role,
+		 fixed_params->accept_policy,
+		 fixed_params->nan_csid, fixed_params->nan_scid_len,
+		 rsp->peer_mac_addr.bytes,
+		 rsp->peer_discovery_mac_addr.bytes);
+
+	target_if_debug("ndp_cfg - %d bytes", fixed_params->ndp_cfg_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			   &event->ndp_cfg, fixed_params->ndp_cfg_len);
+
+	target_if_debug("ndp_app_info - %d bytes",
+			fixed_params->ndp_app_info_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			&event->ndp_app_info, fixed_params->ndp_app_info_len);
+
+	rsp->ndp_config.ndp_cfg_len = fixed_params->ndp_cfg_len;
+	rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
+	rsp->ncs_sk_type = fixed_params->nan_csid;
+	rsp->scid.scid_len = fixed_params->nan_scid_len;
+
+	if (rsp->ndp_config.ndp_cfg_len) {
+		rsp->ndp_config.ndp_cfg =
+			qdf_mem_malloc(fixed_params->ndp_cfg_len);
+		if (!rsp->ndp_config.ndp_cfg) {
+			target_if_err("malloc failed");
+			ret = -ENOMEM;
+			goto free_ind_resources;
+		}
+		qdf_mem_copy(rsp->ndp_config.ndp_cfg, event->ndp_cfg,
+			     rsp->ndp_config.ndp_cfg_len);
+	}
+
+	if (rsp->ndp_info.ndp_app_info_len) {
+		rsp->ndp_info.ndp_app_info =
+			qdf_mem_malloc(rsp->ndp_info.ndp_app_info_len);
+		if (!rsp->ndp_info.ndp_app_info) {
+			target_if_err("malloc failed");
+			ret = -ENOMEM;
+			goto free_ind_resources;
+		}
+		qdf_mem_copy(rsp->ndp_info.ndp_app_info,
+			     event->ndp_app_info,
+			     rsp->ndp_info.ndp_app_info_len);
+	}
+
+	if (rsp->scid.scid_len) {
+		rsp->scid.scid =
+			qdf_mem_malloc(rsp->scid.scid_len);
+		if (!rsp->scid.scid) {
+			target_if_err("malloc failed");
+			ret = -ENOMEM;
+			goto free_ind_resources;
+		}
+		qdf_mem_copy(rsp->scid.scid,
+			     event->ndp_scid, rsp->scid.scid_len);
+		target_if_debug("scid hex dump:");
+		QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+			rsp->scid.scid, rsp->scid.scid_len);
+	}
+
+	msg.type = NDP_INDICATION;
+	msg.bodyptr = rsp;
+	msg.callback = target_if_nan_event_dispatcher;
+	target_if_debug("NDP_INDICATION sent: %d", msg.type);
+	status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		target_if_err("failed to post msg, status: %d", status);
+		ret = -EINVAL;
+		goto free_ind_resources;
+	}
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+	return 0;
+
+free_ind_resources:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+	qdf_mem_free(rsp->ndp_config.ndp_cfg);
+	qdf_mem_free(rsp->ndp_info.ndp_app_info);
+	qdf_mem_free(rsp->scid.scid);
+	qdf_mem_free(rsp);
+
+	return ret;
+}
+
+static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data,
+					uint32_t data_len)
+{
+	QDF_STATUS status;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+	struct scheduler_msg msg = {0};
+	WMI_NDP_CONFIRM_EVENTID_param_tlvs *event;
+	wmi_ndp_confirm_event_fixed_param *fixed_params;
+	struct nan_datapath_confirm_event *rsp;
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("psoc is null");
+		return -EINVAL;
+	}
+
+	rsp = qdf_mem_malloc(sizeof(*rsp));
+	if (!rsp) {
+		target_if_err("malloc failed");
+		return -ENOMEM;
+	}
+
+	event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) data;
+	fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param;
+	target_if_debug("WMI_NDP_CONFIRM_EVENTID(0x%X) recieved. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d",
+		 WMI_NDP_CONFIRM_EVENTID, fixed_params->vdev_id,
+		 fixed_params->ndp_instance_id, fixed_params->rsp_code,
+		 fixed_params->reason_code,
+		 fixed_params->num_active_ndps_on_peer);
+	target_if_debug("ndp_cfg - %d bytes", fixed_params->ndp_cfg_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+		&event->ndp_cfg, fixed_params->ndp_cfg_len);
+
+	target_if_debug("ndp_app_info - %d bytes",
+			fixed_params->ndp_app_info_len);
+	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
+		&event->ndp_app_info, fixed_params->ndp_app_info_len);
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
+					fixed_params->vdev_id, WLAN_NAN_ID);
+	if (!vdev) {
+		target_if_err("vdev is null");
+		return -EINVAL;
+	}
+
+	rsp->vdev = vdev;
+	rsp->ndp_instance_id = fixed_params->ndp_instance_id;
+	rsp->rsp_code = fixed_params->rsp_code;
+	rsp->reason_code = fixed_params->reason_code;
+	rsp->num_active_ndps_on_peer =
+				fixed_params->num_active_ndps_on_peer;
+
+	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr,
+				   rsp->peer_ndi_mac_addr.bytes);
+
+	rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len;
+
+	if (rsp->ndp_info.ndp_app_info_len) {
+		rsp->ndp_info.ndp_app_info =
+				qdf_mem_malloc(fixed_params->ndp_app_info_len);
+		if (!rsp->ndp_info.ndp_app_info) {
+			target_if_err("malloc failed");
+			qdf_mem_free(rsp);
+			wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+			return -ENOMEM;
+		}
+		qdf_mem_copy(&rsp->ndp_info.ndp_app_info,
+			     event->ndp_app_info,
+			     rsp->ndp_info.ndp_app_info_len);
+	}
+	msg.type = NDP_CONFIRM;
+	msg.bodyptr = rsp;
+	msg.callback = target_if_nan_event_dispatcher;
+	target_if_err("NDP_CONFIRM sent: %d", msg.type);
+	status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		target_if_err("failed to post msg, status: %d", status);
+		qdf_mem_free(rsp->ndp_info.ndp_app_info);
+		qdf_mem_free(rsp);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static QDF_STATUS target_if_nan_req(void *req, uint32_t req_type)
+{
+	/* send cmd to fw */
+	switch (req_type) {
+	case NDP_INITIATOR_REQ:
+		target_if_nan_ndp_intiaitor_req(req);
+		break;
+	default:
+		target_if_err("invalid req type");
+		break;
+	}
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -36,8 +537,7 @@ void target_if_nan_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops)
 
 void target_if_nan_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops)
 {
-	/* TBD */
-	rx_ops->nan_rx_ops.nan_event_rx = NULL;
+	rx_ops->nan_rx_ops.nan_event_rx = nan_event_handler;
 }
 
 inline struct wlan_lmac_if_nan_tx_ops *target_if_nan_get_tx_ops(
@@ -64,12 +564,69 @@ inline struct wlan_lmac_if_nan_rx_ops *target_if_nan_get_rx_ops(
 
 QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc)
 {
-	/* TBD */
+	int ret;
+	wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc);
+
+	ret = wmi_unified_register_event_handler(handle,
+		WMI_NDP_INITIATOR_RSP_EVENTID,
+		target_if_ndp_initiator_rsp_handler,
+		WMI_RX_UMAC_CTX);
+	if (ret) {
+		target_if_err("wmi event registration failed, ret: %d", ret);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_register_event_handler(handle,
+		WMI_NDP_INDICATION_EVENTID,
+		target_if_ndp_ind_handler,
+		WMI_RX_UMAC_CTX);
+	if (ret) {
+		target_if_err("wmi event registration failed, ret: %d", ret);
+		target_if_nan_deregister_events(psoc);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	ret = wmi_unified_register_event_handler(handle,
+		WMI_NDP_CONFIRM_EVENTID,
+		target_if_ndp_confirm_handler,
+		WMI_RX_UMAC_CTX);
+	if (ret) {
+		target_if_err("wmi event registration failed, ret: %d", ret);
+		target_if_nan_deregister_events(psoc);
+		return QDF_STATUS_E_FAILURE;
+	}
+
 	return QDF_STATUS_SUCCESS;
 }
 
 QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc)
 {
-	/* TBD */
-	return QDF_STATUS_SUCCESS;
+	int ret, status = 0;
+	wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc);
+
+	ret = wmi_unified_unregister_event_handler(handle,
+				WMI_NDP_INITIATOR_RSP_EVENTID);
+	if (ret) {
+		target_if_err("wmi event deregistration failed, ret: %d", ret);
+		status = ret;
+	}
+
+	ret = wmi_unified_unregister_event_handler(handle,
+				WMI_NDP_INDICATION_EVENTID);
+	if (ret) {
+		target_if_err("wmi event deregistration failed, ret: %d", ret);
+		status = ret;
+	}
+
+	ret = wmi_unified_unregister_event_handler(handle,
+				WMI_NDP_CONFIRM_EVENTID);
+	if (ret) {
+		target_if_err("wmi event deregistration failed, ret: %d", ret);
+		status = ret;
+	}
+
+	if (status)
+		return QDF_STATUS_E_FAILURE;
+	else
+		return QDF_STATUS_SUCCESS;
 }

umac/nan/core/inc/nan_public_structs.h

@@ -492,6 +492,12 @@ struct nan_callbacks {
 	void (*drv_ndi_create_rsp_handler)(uint8_t,
 					struct nan_datapath_inf_create_rsp *);
 	void (*drv_ndi_delete_rsp_handler)(uint8_t);
+
+	int (*new_peer_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, bool);
+	int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *);
+	QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr);
+
+	void (*delete_peers_by_addr)(uint8_t, struct qdf_mac_addr);
 };
 
 #endif

umac/nan/core/src/nan_main.c

@@ -256,3 +256,161 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg)
 	}
 	return QDF_STATUS_SUCCESS;
 }
+
+static QDF_STATUS nan_handle_confirm(
+				struct nan_datapath_confirm_event *confirm)
+{
+	uint8_t vdev_id;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_objmgr_psoc *psoc;
+	struct nan_psoc_priv_obj *psoc_nan_obj;
+
+	vdev_id = wlan_vdev_get_id(confirm->vdev);
+	psoc = wlan_vdev_get_psoc(confirm->vdev);
+	if (!psoc) {
+		nan_err("psoc is null");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto free_resource;
+	}
+
+	psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
+	if (!psoc_nan_obj) {
+		nan_err("psoc_nan_obj is null");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto free_resource;
+	}
+
+	if (confirm->rsp_code != NAN_DATAPATH_RESPONSE_ACCEPT &&
+		confirm->num_active_ndps_on_peer == 0) {
+		/*
+		 * This peer was created at ndp_indication but
+		 * confirm failed, so it needs to be deleted
+		 */
+		nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDRESS_STR" on vdev_id: %d",
+			QDF_MAC_ADDR_ARRAY(confirm->peer_ndi_mac_addr.bytes),
+			vdev_id);
+		psoc_nan_obj->cb_obj.delete_peers_by_addr(vdev_id,
+						confirm->peer_ndi_mac_addr);
+	}
+	psoc_nan_obj->cb_obj.os_if_event_handler(psoc, confirm->vdev,
+						 NDP_CONFIRM, confirm);
+
+free_resource:
+	qdf_mem_free(confirm->ndp_info.ndp_app_info);
+
+	return status;
+}
+
+static QDF_STATUS nan_handle_initiator_rsp(
+				struct nan_datapath_initiator_rsp *rsp,
+				struct wlan_objmgr_vdev **vdev)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct nan_psoc_priv_obj *psoc_nan_obj;
+
+	*vdev = rsp->vdev;
+	psoc = wlan_vdev_get_psoc(rsp->vdev);
+	if (!psoc) {
+		nan_err("psoc is null");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
+	if (!psoc_nan_obj) {
+		nan_err("psoc_nan_obj is null");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	psoc_nan_obj->cb_obj.os_if_event_handler(psoc, rsp->vdev,
+					NDP_INITIATOR_RSP, rsp);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS nan_handle_ndp_ind(
+				struct nan_datapath_indication_event *ndp_ind)
+{
+	uint8_t vdev_id;
+	struct wlan_objmgr_psoc *psoc;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct nan_psoc_priv_obj *psoc_nan_obj;
+
+	vdev_id = wlan_vdev_get_id(ndp_ind->vdev);
+	psoc = wlan_vdev_get_psoc(ndp_ind->vdev);
+	if (!psoc) {
+		nan_err("psoc is null");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto ndp_indication_failed;
+	}
+
+	psoc_nan_obj = nan_get_psoc_priv_obj(psoc);
+	if (!psoc_nan_obj) {
+		nan_err("psoc_nan_obj is null");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto ndp_indication_failed;
+	}
+
+	nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr "
+		QDF_MAC_ADDRESS_STR,
+		ndp_ind->role, vdev_id, ndp_ind->ncs_sk_type,
+		QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes));
+
+	if ((ndp_ind->role == NAN_DATAPATH_ROLE_INITIATOR) ||
+	   ((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) &&
+	   (NAN_DATAPATH_ACCEPT_POLICY_ALL == ndp_ind->policy))) {
+		status = psoc_nan_obj->cb_obj.add_ndi_peer(vdev_id,
+						ndp_ind->peer_mac_addr);
+		if (QDF_IS_STATUS_ERROR(status)) {
+			nan_err("Couldn't add ndi peer, ndp_role: %d",
+				ndp_ind->role);
+			goto ndp_indication_failed;
+		}
+	}
+	if (NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role)
+		psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ndp_ind->vdev,
+						NDP_INDICATION, ndp_ind);
+ndp_indication_failed:
+	qdf_mem_free(ndp_ind->ndp_config.ndp_cfg);
+	qdf_mem_free(ndp_ind->ndp_info.ndp_app_info);
+	qdf_mem_free(ndp_ind->scid.scid);
+
+	return status;
+}
+
+QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_serialization_queued_cmd_info cmd;
+
+	cmd.requestor = WLAN_UMAC_COMP_NAN;
+	cmd.cmd_id = 0;
+	cmd.req_type = WLAN_SER_CANCEL_NON_SCAN_CMD;
+	cmd.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE;
+
+	if (!pe_msg->bodyptr) {
+		nan_err("msg body is null");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	switch (pe_msg->type) {
+	case NDP_CONFIRM: {
+		nan_handle_confirm(pe_msg->bodyptr);
+		break;
+	}
+	case NDP_INITIATOR_RSP: {
+		nan_handle_initiator_rsp(pe_msg->bodyptr, &cmd.vdev);
+		cmd.cmd_type = WLAN_SER_CMD_NDP_INIT_REQ;
+		wlan_serialization_remove_cmd(&cmd);
+		break;
+	}
+	case NDP_INDICATION: {
+		nan_handle_ndp_ind(pe_msg->bodyptr);
+		break;
+	}
+	default:
+		nan_alert("Unhandled NDP event: %d", pe_msg->type);
+		status = QDF_STATUS_E_NOSUPPORT;
+		break;
+	}
+	return status;
+}

umac/nan/core/src/nan_main_i.h

@@ -124,4 +124,12 @@ void nan_release_cmd(void *in_req, uint32_t req_type);
  */
 QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg);
 
+/*
+ * nan_event_handler: function to process events from firmware
+ * @msg: message received from lmac
+ *
+ * Return: status of operation
+ */
+QDF_STATUS nan_event_handler(struct scheduler_msg *msg);
+
 #endif

umac/nan/dispatcher/inc/nan_ucfg_api.h

@@ -196,6 +196,20 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc,
 QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
 				  void *in_req, uint32_t req_type);
 
+/**
+ * ucfg_nan_event_handler: ucfg API to be called from legacy code to
+ * post events to os_if/hdd layer
+ * @psoc: pointer to psoc object
+ * @vdev: pointer to vdev object
+ * @type: message type
+ * @msg: msg buffer
+ *
+ * Return: None
+ */
+void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc,
+			    struct wlan_objmgr_vdev *vdev,
+			    uint32_t type, void *msg);
+
 /**
  * ucfg_nan_register_hdd_callbacks: ucfg API to set hdd callbacks
  * @psoc: pointer to psoc object
@@ -211,6 +225,16 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 				    struct wlan_objmgr_vdev *,
 				    uint32_t, void *));
 
+/*
+ * ucfg_nan_register_lim_callbacks: ucfg API to set lim callbacks
+ * @psoc: pointer to psoc object
+ * @cb_obj: structs containing callbacks
+ *
+ * Return: status of operation
+ */
+int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
+				    struct nan_callbacks *cb_obj);
+
 /**
  * ucfg_nan_get_callbacks: ucfg API to return callbacks
  * @psoc: pointer to psoc object

umac/nan/dispatcher/src/nan_ucfg_api.c

@@ -322,9 +322,69 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc,
 	return psoc_obj->vdev;
 }
 
+static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req(
+			struct wlan_objmgr_vdev *vdev,
+			struct nan_datapath_initiator_req *in_req)
+{
+	struct nan_datapath_initiator_req *out_req;
+
+	out_req = qdf_mem_malloc(sizeof(*out_req));
+	if (!out_req) {
+		nan_alert("malloc failed");
+		return NULL;
+	}
+
+	qdf_mem_copy(out_req, in_req, sizeof(*out_req));
+	if (in_req->ndp_config.ndp_cfg_len) {
+		out_req->ndp_config.ndp_cfg =
+			qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len);
+		if (!out_req->ndp_config.ndp_cfg) {
+			nan_alert("malloc failed");
+			goto free_resources;
+		}
+		qdf_mem_copy(out_req->ndp_config.ndp_cfg,
+			     in_req->ndp_config.ndp_cfg,
+			     in_req->ndp_config.ndp_cfg_len);
+	}
+
+	if (in_req->ndp_info.ndp_app_info_len) {
+		out_req->ndp_info.ndp_app_info =
+			qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len);
+		if (!out_req->ndp_info.ndp_app_info) {
+			nan_alert("malloc failed");
+			goto free_resources;
+		}
+		qdf_mem_copy(out_req->ndp_info.ndp_app_info,
+			     in_req->ndp_info.ndp_app_info,
+			     in_req->ndp_info.ndp_app_info_len);
+	}
+
+	if (in_req->pmk.pmk_len) {
+		out_req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len);
+		if (!out_req->pmk.pmk) {
+			nan_alert("malloc failed");
+			goto free_resources;
+		}
+		qdf_mem_copy(out_req->pmk.pmk, in_req->pmk.pmk,
+			     in_req->pmk.pmk_len);
+	}
+
+	/* do not get ref here, rather take ref when request is activated */
+	out_req->vdev = vdev;
+	return out_req;
+
+free_resources:
+	qdf_mem_free(out_req->pmk.pmk);
+	qdf_mem_free(out_req->ndp_info.ndp_app_info);
+	qdf_mem_free(out_req->ndp_config.ndp_cfg);
+	qdf_mem_free(out_req);
+	return NULL;
+}
+
 QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
 				  void *in_req, uint32_t req_type)
 {
+	void *req;
 	QDF_STATUS status;
 	struct scheduler_msg msg = {0};
 
@@ -333,8 +393,22 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
+	switch (req_type) {
+	case NDP_INITIATOR_REQ:
+		req = ucfg_nan_copy_intiator_req(vdev, in_req);
+		break;
+	default:
+		nan_err("in correct message req type: %d", req_type);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (!req) {
+		nan_err("failed to create local copy");
+		return QDF_STATUS_E_INVAL;
+	}
+
 	msg.type = req_type;
-	msg.bodyptr = in_req;
+	msg.bodyptr = req;
 	msg.callback = nan_scheduled_msg_handler;
 	status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg);
 	if (QDF_IS_STATUS_ERROR(status)) {
@@ -345,6 +419,20 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
 	return status;
 }
 
+void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc,
+			    struct wlan_objmgr_vdev *vdev,
+			    uint32_t type, void *msg)
+{
+	struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
+
+	if (!psoc_obj) {
+		nan_err("nan psoc priv object is NULL");
+		return;
+	}
+
+	psoc_obj->cb_obj.os_if_event_handler(psoc, vdev, type, msg);
+}
+
 int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 				    struct nan_callbacks *cb_obj,
 				    void (os_if_event_handler)(
@@ -370,5 +458,24 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 	psoc_obj->cb_obj.drv_ndi_delete_rsp_handler =
 				cb_obj->drv_ndi_delete_rsp_handler;
 
+	psoc_obj->cb_obj.get_peer_idx = cb_obj->get_peer_idx;
+	psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind;
+
+	return 0;
+}
+
+int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc,
+				    struct nan_callbacks *cb_obj)
+{
+	struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc);
+
+	if (!psoc_obj) {
+		nan_err("nan psoc priv object is NULL");
+		return -EINVAL;
+	}
+
+	psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer;
+	psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr;
+
 	return 0;
 }