qcacmn: Implement ndp schedule update and channel info in ndp confirm

Add support for ndp schedule update event and provide channel information in ndp confirm event. Change-Id: Ic2c073dd4f220627cc2bd1a2d52d858136b6b450 CRs-Fixed: 2180310
2018-01-09 17:54:41 -08:00
parent 6f5ff952ab
commit 8c72007596
9 changed files with 518 additions and 32 deletions
--- a/os_if/linux/nan/src/os_if_nan.c
+++ b/os_if/linux/nan/src/os_if_nan.c
@@ -122,6 +122,14 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = {
 						.type = NLA_BINARY,
 						.len = NAN_MAX_SERVICE_NAME_LEN
 	},
+	[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO] = {
+						.type = NLA_BINARY,
+						.len = NAN_CH_INFO_MAX_LEN
+	},
+	[QCA_WLAN_VENDOR_ATTR_NDP_NSS] = {
+						.type = NLA_U32,
+						.len = sizeof(uint32_t)
+	},
 };

 static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc,
@@ -1023,6 +1031,7 @@ ndp_indication_nla_failed:
 static inline uint32_t osif_ndp_get_ndp_confirm_ind_len(
 				struct nan_datapath_confirm_event *ndp_confirm)
 {
+	uint32_t ch_info_len = 0;
 	uint32_t data_len = NLMSG_HDRLEN;

 	data_len += nla_total_size(vendor_attr_policy[
@@ -1042,9 +1051,62 @@ static inline uint32_t osif_ndp_get_ndp_confirm_ind_len(
 		data_len +=
 			nla_total_size(ndp_confirm->ndp_info.ndp_app_info_len);

+	/* ch_info is a nested array of following attributes */
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL].len);
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH].len);
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_NSS].len);
+
+	if (ndp_confirm->num_channels)
+		data_len += ndp_confirm->num_channels *
+				nla_total_size(ch_info_len);
+
 	return data_len;
 }

+static QDF_STATUS os_if_ndp_confirm_pack_ch_info(struct sk_buff *event,
+				struct nan_datapath_confirm_event *ndp_confirm)
+{
+	int idx = 0;
+	struct nlattr *ch_array, *ch_element;
+
+	cfg80211_debug("num_ch: %d", ndp_confirm->num_channels);
+	if (!ndp_confirm->num_channels)
+		return QDF_STATUS_SUCCESS;
+
+	ch_array = nla_nest_start(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO);
+	if (!ch_array)
+		return QDF_STATUS_E_FAULT;
+
+	for (idx = 0; idx < ndp_confirm->num_channels; idx++) {
+		cfg80211_debug("ch[%d]: freq: %d, width: %d, nss: %d",
+			       idx, ndp_confirm->ch[idx].channel,
+			       ndp_confirm->ch[idx].ch_width,
+			       ndp_confirm->ch[idx].nss);
+		ch_element = nla_nest_start(event, idx);
+		if (!ch_element)
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL,
+				ndp_confirm->ch[idx].channel))
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH,
+				ndp_confirm->ch[idx].ch_width))
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_NSS,
+				ndp_confirm->ch[idx].nss))
+			return QDF_STATUS_E_FAULT;
+		nla_nest_end(event, ch_element);
+	}
+	nla_nest_end(event, ch_array);
+
+	return QDF_STATUS_SUCCESS;
+}
+
 /**
 * os_if_ndp_confirm_ind_handler() - NDP confirm indication handler
 * @vdev: pointer to vdev object
@@ -1062,7 +1124,8 @@ static inline uint32_t osif_ndp_get_ndp_confirm_ind_len(
 *
 * Return: none
 */
-static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
+static void
+os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
 			      struct nan_datapath_confirm_event *ndp_confirm)
 {
 	int idx = 0;
@@ -1070,12 +1133,11 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
 	uint32_t data_len;
 	QDF_STATUS status;
 	qdf_size_t ifname_len;
-	uint32_t ndp_qos_config = 0;
+	struct nan_callbacks cb_obj;
 	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");
@@ -1156,12 +1218,19 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev,
 			ndp_confirm->reason_code))
 		goto ndp_confirm_nla_failed;

+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS,
+			ndp_confirm->num_channels))
+		goto ndp_confirm_nla_failed;
+
+	status = os_if_ndp_confirm_pack_ch_info(vendor_event, ndp_confirm);
+	if (QDF_IS_STATUS_ERROR(status))
+		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",
+	cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM 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);
+		       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,
@@ -1620,6 +1689,168 @@ static void os_if_ndp_iface_delete_rsp_handler(struct wlan_objmgr_psoc *psoc,
 	cb_obj.drv_ndi_delete_rsp_handler(vdev_id);
 }

+static inline uint32_t osif_ndp_get_ndp_sch_update_ind_len(
+			struct nan_datapath_sch_update_event *sch_update)
+{
+	uint32_t ch_info_len = 0;
+	uint32_t data_len = NLMSG_HDRLEN;
+
+	data_len += nla_total_size(vendor_attr_policy[
+			QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len);
+	data_len += nla_total_size(vendor_attr_policy[
+			QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR].len);
+	if (sch_update->num_ndp_instances)
+		data_len += nla_total_size(sch_update->num_ndp_instances *
+					   sizeof(uint32_t));
+	data_len += nla_total_size(vendor_attr_policy[
+			QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REASON].len);
+	data_len += nla_total_size(vendor_attr_policy[
+			QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS].len);
+	/* ch_info is a nested array of following attributes */
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL].len);
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH].len);
+	ch_info_len += nla_total_size(
+		vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_NSS].len);
+
+	if (sch_update->num_ndp_instances)
+		data_len += sch_update->num_ndp_instances *
+						nla_total_size(ch_info_len);
+
+	return data_len;
+}
+
+static QDF_STATUS os_if_ndp_sch_update_pack_ch_info(struct sk_buff *event,
+			struct nan_datapath_sch_update_event *sch_update)
+{
+	int idx = 0;
+	struct nlattr *ch_array, *ch_element;
+
+	cfg80211_debug("num_ch: %d", sch_update->num_channels);
+	if (!sch_update->num_channels)
+		return QDF_STATUS_SUCCESS;
+
+	ch_array = nla_nest_start(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO);
+	if (!ch_array)
+		return QDF_STATUS_E_FAULT;
+
+	for (idx = 0; idx < sch_update->num_channels; idx++) {
+		cfg80211_debug("ch[%d]: freq: %d, width: %d, nss: %d",
+				idx, sch_update->ch[idx].channel,
+				sch_update->ch[idx].ch_width,
+				sch_update->ch[idx].nss);
+		ch_element = nla_nest_start(event, idx);
+		if (!ch_element)
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL,
+				sch_update->ch[idx].channel))
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH,
+				sch_update->ch[idx].ch_width))
+			return QDF_STATUS_E_FAULT;
+
+		if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_NSS,
+				sch_update->ch[idx].nss))
+			return QDF_STATUS_E_FAULT;
+		nla_nest_end(event, ch_element);
+	}
+	nla_nest_end(event, ch_array);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * os_if_ndp_sch_update_ind_handler() - NDP schedule update handler
+ * @vdev: vdev object pointer
+ * @ind: sch update pointer
+ *
+ * Following vendor event is sent to cfg80211:
+ *
+ * Return: none
+ */
+static void os_if_ndp_sch_update_ind_handler(struct wlan_objmgr_vdev *vdev,
+					     void *ind)
+{
+	int idx = 0;
+	uint8_t *ifname;
+	QDF_STATUS status;
+	uint32_t data_len;
+	uint8_t ifname_len;
+	struct sk_buff *vendor_event;
+	struct nan_datapath_sch_update_event *sch_update = ind;
+	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
+	struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev);
+
+	if (!sch_update) {
+		cfg80211_err("Invalid sch update params");
+		return;
+	}
+
+	ifname = wlan_util_vdev_get_if_name(vdev);
+	if (!ifname) {
+		cfg80211_err("ifname is null");
+		return;
+	}
+	ifname_len = qdf_str_len(ifname);
+	if (ifname_len > IFNAMSIZ) {
+		cfg80211_err("ifname(%d) too long", ifname_len);
+		return;
+	}
+
+	data_len = osif_ndp_get_ndp_sch_update_ind_len(sch_update);
+	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_SCHEDULE_UPDATE_IND))
+		goto ndp_sch_ind_nla_failed;
+
+	if (nla_put(vendor_event,
+		    QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR,
+		    QDF_MAC_ADDR_SIZE, sch_update->peer_addr.bytes))
+		goto ndp_sch_ind_nla_failed;
+
+	if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY,
+		    sch_update->num_ndp_instances * sizeof(uint32_t),
+		    sch_update->ndp_instances))
+		goto ndp_sch_ind_nla_failed;
+
+	if (nla_put_u32(vendor_event,
+			QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REASON,
+			sch_update->flags))
+		goto ndp_sch_ind_nla_failed;
+
+	if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS,
+			sch_update->num_channels))
+		goto ndp_sch_ind_nla_failed;
+
+	status = os_if_ndp_sch_update_pack_ch_info(vendor_event, sch_update);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto ndp_sch_ind_nla_failed;
+
+	cfg80211_debug("Flags: %d, num_instance_id: %d", sch_update->flags,
+		       sch_update->num_ndp_instances);
+
+	for (idx = 0; idx < sch_update->num_ndp_instances; idx++)
+		cfg80211_debug("ndp_instance[%d]: %d", idx,
+			       sch_update->ndp_instances[idx]);
+
+	cfg80211_vendor_event(vendor_event, GFP_ATOMIC);
+	return;
+
+ndp_sch_ind_nla_failed:
+	cfg80211_err("nla_put api failed");
+	kfree_skb(vendor_event);
+}
+
 void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
 			     struct wlan_objmgr_vdev *vdev,
 			     uint32_t type, void *msg)
@@ -1655,6 +1886,9 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc,
 	case NDP_PEER_DEPARTED:
 		os_if_peer_departed_ind_handler(vdev, msg);
 		break;
+	case NDP_SCHEDULE_UPDATE:
+		os_if_ndp_sch_update_ind_handler(vdev, msg);
+		break;
 	default:
 		break;
 	}
--- a/target_if/nan/src/target_if_nan.c
+++ b/target_if/nan/src/target_if_nan.c
@@ -51,6 +51,9 @@ static QDF_STATUS target_if_nan_event_flush_cb(struct scheduler_msg *msg)
 	case NDP_END_IND:
 		vdev = ((struct nan_datapath_end_indication_event *)ptr)->vdev;
 		break;
+	case NDP_SCHEDULE_UPDATE:
+		vdev = ((struct nan_datapath_sch_update_event *)ptr)->vdev;
+		break;
 	default:
 		break;
 	}
@@ -90,6 +93,9 @@ static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg)
 	case NDP_END_IND:
 		vdev = ((struct nan_datapath_end_indication_event *)ptr)->vdev;
 		break;
+	case NDP_SCHEDULE_UPDATE:
+		vdev = ((struct nan_datapath_sch_update_event *)ptr)->vdev;
+		break;
 	default:
 		target_if_err("invalid msg type %d", msg->type);
 		status = QDF_STATUS_E_INVAL;
@@ -559,6 +565,55 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data,
 	return 0;
 }

+static int target_if_ndp_sch_update_handler(ol_scn_t scn, uint8_t *data,
+					    uint32_t data_len)
+{
+	QDF_STATUS status;
+	struct wlan_objmgr_psoc *psoc;
+	struct wmi_unified *wmi_handle;
+	struct scheduler_msg msg = {0};
+	struct nan_datapath_sch_update_event *rsp;
+
+	psoc = target_if_get_psoc_from_scn_hdl(scn);
+	if (!psoc) {
+		target_if_err("psoc is null");
+		return -EINVAL;
+	}
+
+	wmi_handle = get_wmi_unified_hdl_from_psoc(psoc);
+	if (!wmi_handle) {
+		target_if_err("wmi_handle is null.");
+		return -EINVAL;
+	}
+
+	rsp = qdf_mem_malloc(sizeof(*rsp));
+	if (!rsp) {
+		target_if_err("malloc failed");
+		return -ENOMEM;
+	}
+
+	status = wmi_extract_ndp_sch_update(wmi_handle, data, rsp);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		target_if_err("parsing of event failed, %d", status);
+		qdf_mem_free(rsp);
+		return -EINVAL;
+	}
+
+	msg.bodyptr = rsp;
+	msg.type = NDP_SCHEDULE_UPDATE;
+	msg.callback = target_if_nan_event_dispatcher;
+	msg.flush_callback = target_if_nan_event_flush_cb;
+	target_if_debug("NDP_SCHEDULE_UPDATE 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);
+		target_if_nan_event_flush_cb(&msg);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 static QDF_STATUS target_if_nan_req(void *req, uint32_t req_type)
 {
 	/* send cmd to fw */
@@ -675,6 +730,16 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc)
 		return QDF_STATUS_E_FAILURE;
 	}

+	ret = wmi_unified_register_event_handler(handle,
+		wmi_ndl_schedule_update_event_id,
+		target_if_ndp_sch_update_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;
 }

@@ -683,6 +748,13 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc)
 	int ret, status = 0;
 	wmi_unified_t handle = get_wmi_unified_hdl_from_psoc(psoc);

+	ret = wmi_unified_unregister_event_handler(handle,
+				wmi_ndl_schedule_update_event_id);
+	if (ret) {
+		target_if_err("wmi event deregistration failed, ret: %d", ret);
+		status = ret;
+	}
+
 	ret = wmi_unified_unregister_event_handler(handle,
 				wmi_ndp_end_rsp_event_id);
 	if (ret) {
--- a/umac/nan/core/inc/nan_public_structs.h
+++ b/umac/nan/core/inc/nan_public_structs.h
@@ -39,23 +39,45 @@ struct wlan_objmgr_vdev;
 #define NAN_MAX_SERVICE_NAME_LEN 255
 #define NAN_PASSPHRASE_MIN_LEN 8
 #define NAN_PASSPHRASE_MAX_LEN 63
+#define NAN_CH_INFO_MAX_CHANNELS 4

-
-#define NAN_DATAPATH_INF_CREATE_REQ                     0
-#define NAN_DATAPATH_INF_CREATE_RSP                     1
-#define NAN_DATAPATH_INF_DELETE_REQ                     2
-#define NAN_DATAPATH_INF_DELETE_RSP                     3
-#define NDP_INITIATOR_REQ                               4
-#define NDP_INITIATOR_RSP                               5
-#define NDP_RESPONDER_REQ                               6
-#define NDP_RESPONDER_RSP                               7
-#define NDP_END_REQ                                     8
-#define NDP_END_RSP                                     9
-#define NDP_INDICATION                                  10
-#define NDP_CONFIRM                                     11
-#define NDP_END_IND                                     12
-#define NDP_NEW_PEER                                    13
-#define NDP_PEER_DEPARTED                               14
+/**
+ * enum nan_datapath_msg_type - NDP msg type
+ * @NAN_DATAPATH_INF_CREATE_REQ: ndi create request
+ * @NAN_DATAPATH_INF_CREATE_RSP: ndi create response
+ * @NAN_DATAPATH_INF_DELETE_REQ: ndi delete request
+ * @NAN_DATAPATH_INF_DELETE_RSP: ndi delete response
+ * @NDP_INITIATOR_REQ: ndp initiator request
+ * @NDP_INITIATOR_RSP: ndp initiator response
+ * @NDP_RESPONDER_REQ: ndp responder request
+ * @NDP_RESPONDER_RSP: ndp responder response
+ * @NDP_END_REQ: ndp end request
+ * @NDP_END_RSP: ndp end response
+ * @NDP_INDICATION: ndp indication
+ * @NDP_CONFIRM: ndp confirm
+ * @NDP_END_IND: ndp end indication
+ * @NDP_NEW_PEER: ndp new peer created
+ * @NDP_PEER_DEPARTED: ndp peer departed/deleted
+ * @NDP_SCHEDULE_UPDATE: ndp schedule update
+ */
+enum nan_datapath_msg_type {
+	NAN_DATAPATH_INF_CREATE_REQ  = 0,
+	NAN_DATAPATH_INF_CREATE_RSP  = 1,
+	NAN_DATAPATH_INF_DELETE_REQ  = 2,
+	NAN_DATAPATH_INF_DELETE_RSP  = 3,
+	NDP_INITIATOR_REQ            = 4,
+	NDP_INITIATOR_RSP            = 5,
+	NDP_RESPONDER_REQ            = 6,
+	NDP_RESPONDER_RSP            = 7,
+	NDP_END_REQ                  = 8,
+	NDP_END_RSP                  = 9,
+	NDP_INDICATION               = 10,
+	NDP_CONFIRM                  = 11,
+	NDP_END_IND                  = 12,
+	NDP_NEW_PEER                 = 13,
+	NDP_PEER_DEPARTED            = 14,
+	NDP_SCHEDULE_UPDATE          = 15,
+};

 /**
 * enum nan_datapath_status_type - NDP status type
@@ -279,6 +301,22 @@ struct peer_nan_datapath_map {
 	uint32_t ndp_instance_id;
 };

+/**
+ * struct nan_datapath_channel_info - ndp channel and channel bandwidth
+ * @channel: channel freq in mhz of the ndp connection
+ * @ch_width: channel width (wmi_channel_width) of the ndp connection
+ * @nss: nss used for ndp connection
+ *
+ */
+struct nan_datapath_channel_info {
+	uint32_t channel;
+	uint32_t ch_width;
+	uint32_t nss;
+};
+
+#define NAN_CH_INFO_MAX_LEN \
+	(NAN_CH_INFO_MAX_CHANNELS * sizeof(struct nan_datapath_channel_info))
+
 /**
 * struct nan_datapath_inf_create_req - ndi create request params
 * @transaction_id: unique identifier
@@ -460,6 +498,8 @@ struct nan_datapath_end_indication_event {
 * @num_active_ndps_on_peer: number of ndp instances on peer
 * @peer_ndi_mac_addr: peer NDI mac address
 * @rsp_code: ndp response code
+ * @num_channels: num channels
+ * @ch: channel info struct array
 * @ndp_info: ndp application info
 *
 */
@@ -470,6 +510,8 @@ struct nan_datapath_confirm_event {
 	uint32_t num_active_ndps_on_peer;
 	struct qdf_mac_addr peer_ndi_mac_addr;
 	enum nan_datapath_response_code rsp_code;
+	uint32_t num_channels;
+	struct nan_datapath_channel_info ch[NAN_CH_INFO_MAX_CHANNELS];
 	struct nan_datapath_app_info ndp_info;
 };

@@ -516,6 +558,27 @@ struct nan_datapath_peer_ind {
 	uint16_t sta_id;
 };

+/**
+ * struct nan_datapath_sch_update_event - ndp schedule update indication
+ * @vdev: vdev schedule update was received
+ * @peer_addr: peer for which schedule update was received
+ * @flags: reason for sch update (opaque to driver)
+ * @num_channels: num of channels
+ * @num_ndp_instances: num of ndp instances
+ * @ch: channel info array
+ * @ndp_instances: array of ndp instances
+ *
+ */
+struct nan_datapath_sch_update_event {
+	struct wlan_objmgr_vdev *vdev;
+	struct qdf_mac_addr peer_addr;
+	uint32_t flags;
+	uint32_t num_channels;
+	uint32_t num_ndp_instances;
+	struct nan_datapath_channel_info ch[NAN_CH_INFO_MAX_CHANNELS];
+	uint32_t ndp_instances[NDP_NUM_INSTANCE_ID];
+};
+
 /**
 * struct nan_callbacks - struct containing callback to non-converged driver
 *
--- a/umac/nan/core/src/nan_main.c
+++ b/umac/nan/core/src/nan_main.c
@@ -441,6 +441,30 @@ static QDF_STATUS nan_handle_end_ind(
 	return QDF_STATUS_SUCCESS;
 }

+static QDF_STATUS nan_handle_schedule_update(
+				struct nan_datapath_sch_update_event *ind)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct nan_psoc_priv_obj *psoc_nan_obj;
+
+	psoc = wlan_vdev_get_psoc(ind->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, ind->vdev,
+						 NDP_SCHEDULE_UPDATE, ind);
+
+	return QDF_STATUS_SUCCESS;
+}
+
 QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
@@ -484,6 +508,9 @@ QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg)
 	case NDP_END_IND:
 		nan_handle_end_ind(pe_msg->bodyptr);
 		break;
+	case NDP_SCHEDULE_UPDATE:
+		nan_handle_schedule_update(pe_msg->bodyptr);
+		break;
 	default:
 		nan_alert("Unhandled NDP event: %d", pe_msg->type);
 		status = QDF_STATUS_E_NOSUPPORT;
--- a/wmi/inc/wmi_unified_api.h
+++ b/wmi/inc/wmi_unified_api.h
@@ -1993,7 +1993,7 @@ QDF_STATUS wmi_extract_wds_entry(void *wmi_hdl, uint8_t *evt_buf,
 #ifdef WLAN_FEATURE_NAN_CONVERGENCE
 /**
 * wmi_unified_ndp_initiator_req_cmd_send - api to send initiator request to FW
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @req: pointer to request buffer
 *
 * Return: status of operation
@@ -2003,7 +2003,7 @@ QDF_STATUS wmi_unified_ndp_initiator_req_cmd_send(void *wmi_hdl,

 /**
 * wmi_unified_ndp_responder_req_cmd_send - api to send responder request to FW
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @req: pointer to request buffer
 *
 * Return: status of operation
@@ -2013,7 +2013,7 @@ QDF_STATUS wmi_unified_ndp_responder_req_cmd_send(void *wmi_hdl,

 /**
 * wmi_unified_ndp_end_req_cmd_send - api to send end request to FW
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @req: pointer to request buffer
 *
 * Return: status of operation
@@ -2023,7 +2023,7 @@ QDF_STATUS wmi_unified_ndp_end_req_cmd_send(void *wmi_hdl,

 /**
 * wmi_extract_ndp_initiator_rsp - api to extract initiator rsp from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @rsp: buffer to populate
 *
@@ -2034,7 +2034,7 @@ QDF_STATUS wmi_extract_ndp_initiator_rsp(wmi_unified_t wmi_handle,

 /**
 * wmi_extract_ndp_ind - api to extract ndp indication struct from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @ind: buffer to populate
 *
@@ -2045,7 +2045,7 @@ QDF_STATUS wmi_extract_ndp_ind(wmi_unified_t wmi_handle, uint8_t *data,

 /**
 * wmi_extract_ndp_confirm - api to extract ndp confim struct from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @ev: buffer to populate
 *
@@ -2056,7 +2056,7 @@ QDF_STATUS wmi_extract_ndp_confirm(wmi_unified_t wmi_handle, uint8_t *data,

 /**
 * wmi_extract_ndp_responder_rsp - api to extract responder rsp from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @rsp: buffer to populate
 *
@@ -2067,7 +2067,7 @@ QDF_STATUS wmi_extract_ndp_responder_rsp(wmi_unified_t wmi_handle,

 /**
 * wmi_extract_ndp_end_rsp - api to extract ndp end rsp from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @rsp: buffer to populate
 *
@@ -2078,7 +2078,7 @@ QDF_STATUS wmi_extract_ndp_end_rsp(wmi_unified_t wmi_handle, uint8_t *data,

 /**
 * wmi_extract_ndp_end_ind - api to extract ndp end indication from even buffer
- * @wmi_hdl: wma handle
+ * @wmi_hdl: wmi handle
 * @data: event buffer
 * @ind: buffer to populate
 *
@@ -2086,6 +2086,17 @@ QDF_STATUS wmi_extract_ndp_end_rsp(wmi_unified_t wmi_handle, uint8_t *data,
 */
 QDF_STATUS wmi_extract_ndp_end_ind(wmi_unified_t wmi_handle, uint8_t *data,
 			struct nan_datapath_end_indication_event **ind);
+
+/**
+ * wmi_extract_ndp_sch_update - api to extract ndp sch update from event buffer
+ * @wmi_hdl: wmi handle
+ * @data: event buffer
+ * @ind: buffer to populate
+ *
+ * Return: status of operation
+ */
+QDF_STATUS wmi_extract_ndp_sch_update(wmi_unified_t wmi_handle, uint8_t *data,
+				struct nan_datapath_sch_update_event *ind);
 #endif

 /**
--- a/wmi/inc/wmi_unified_param.h
+++ b/wmi/inc/wmi_unified_param.h
@@ -5496,6 +5496,7 @@ typedef enum {
 	wmi_ndp_responder_rsp_event_id,
 	wmi_ndp_end_indication_event_id,
 	wmi_ndp_end_rsp_event_id,
+	wmi_ndl_schedule_update_event_id,
 	wmi_oem_response_event_id,
 	wmi_peer_stats_info_event_id,
 	wmi_pdev_chip_power_stats_event_id,
--- a/wmi/inc/wmi_unified_priv.h
+++ b/wmi/inc/wmi_unified_priv.h
@@ -1526,6 +1526,8 @@ QDF_STATUS (*extract_ndp_end_rsp)(wmi_unified_t wmi_handle,
 		uint8_t *data, struct nan_datapath_end_rsp_event *rsp);
 QDF_STATUS (*extract_ndp_end_ind)(wmi_unified_t wmi_handle,
 		uint8_t *data, struct nan_datapath_end_indication_event **ind);
+QDF_STATUS (*extract_ndp_sch_update)(wmi_unified_t wmi_handle,
+		uint8_t *data, struct nan_datapath_sch_update_event *ind);
 #endif /* WLAN_FEATURE_NAN_CONVERGENCE */

 QDF_STATUS (*send_btm_config)(wmi_unified_t wmi_handle,
--- a/wmi/src/wmi_unified_api.c
+++ b/wmi/src/wmi_unified_api.c
@@ -7368,6 +7368,16 @@ QDF_STATUS wmi_extract_ndp_end_ind(wmi_unified_t wmi_handle, uint8_t *data,

 	return QDF_STATUS_E_FAILURE;
 }
+
+QDF_STATUS wmi_extract_ndp_sch_update(wmi_unified_t wmi_handle, uint8_t *data,
+				      struct nan_datapath_sch_update_event *ind)
+{
+	if (wmi_handle->ops->extract_ndp_sch_update)
+		return wmi_handle->ops->extract_ndp_sch_update(wmi_handle,
+							       data, ind);
+
+	return QDF_STATUS_E_FAILURE;
+}
 #endif
 QDF_STATUS wmi_unified_send_btm_config(void *wmi_hdl,
 				       struct wmi_btm_config *params)
--- a/wmi/src/wmi_unified_tlv.c
+++ b/wmi/src/wmi_unified_tlv.c
@@ -17809,6 +17809,69 @@ static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle,

 	return QDF_STATUS_SUCCESS;
 }
+
+static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle,
+		uint8_t *data, struct nan_datapath_sch_update_event *ind)
+{
+	uint8_t i;
+	WMI_HOST_WLAN_PHY_MODE ch_mode;
+	WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *event;
+	wmi_ndl_schedule_update_fixed_param *fixed_params;
+
+	event = (WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *)data;
+	fixed_params = event->fixed_param;
+
+	WMI_LOGD(FL("flags: %d, num_ch: %d, num_ndp_instances: %d"),
+		 fixed_params->flags, fixed_params->num_channels,
+		 fixed_params->num_ndp_instances);
+
+	ind->vdev =
+		wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc,
+						     fixed_params->vdev_id,
+						     WLAN_NAN_ID);
+	if (!ind->vdev) {
+		WMI_LOGE("vdev is null");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	ind->flags = fixed_params->flags;
+	ind->num_channels = fixed_params->num_channels;
+	ind->num_ndp_instances = fixed_params->num_ndp_instances;
+	WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_macaddr,
+				   ind->peer_addr.bytes);
+
+	if (ind->num_ndp_instances > NDP_NUM_INSTANCE_ID) {
+		WMI_LOGE(FL("uint32 overflow"));
+		wlan_objmgr_vdev_release_ref(ind->vdev, WLAN_NAN_ID);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	qdf_mem_copy(ind->ndp_instances, event->ndp_instance_list,
+		     sizeof(uint32_t) * ind->num_ndp_instances);
+
+	if (ind->num_channels > NAN_CH_INFO_MAX_CHANNELS) {
+		WMI_LOGE(FL("too many channels"));
+		ind->num_channels = NAN_CH_INFO_MAX_CHANNELS;
+	}
+	for (i = 0; i < ind->num_channels; i++) {
+		ind->ch[i].channel = event->ndl_channel_list[i].mhz;
+		ind->ch[i].nss = event->nss_list[i];
+		ch_mode = WMI_GET_CHANNEL_MODE(&event->ndl_channel_list[i]);
+		ind->ch[i].ch_width = wmi_get_ch_width_from_phy_mode(wmi_handle,
+								     ch_mode);
+		WMI_LOGD(FL("ch: %d, ch_mode: %d, nss: %d"),
+			 ind->ch[i].channel,
+			 ind->ch[i].ch_width,
+			 ind->ch[i].nss);
+	}
+
+	for (i = 0; i < fixed_params->num_ndp_instances; i++)
+		WMI_LOGD(FL("instance_id[%d]: %d"),
+			 i, event->ndp_instance_list[i]);
+
+	return QDF_STATUS_SUCCESS;
+}
+
 #endif

 #ifdef QCA_SUPPORT_CP_STATS
@@ -22963,6 +23026,7 @@ struct wmi_ops tlv_ops =  {
 	.extract_ndp_responder_rsp = extract_ndp_responder_rsp_tlv,
 	.extract_ndp_end_rsp = extract_ndp_end_rsp_tlv,
 	.extract_ndp_end_ind = extract_ndp_end_ind_tlv,
+	.extract_ndp_sch_update = extract_ndp_sch_update_tlv,
 #endif
 	.send_btm_config = send_btm_config_cmd_tlv,
 	.send_obss_detection_cfg_cmd = send_obss_detection_cfg_cmd_tlv,
@@ -23236,6 +23300,8 @@ static void populate_tlv_events_id(uint32_t *event_ids)
 	event_ids[wmi_ndp_end_indication_event_id] =
 		WMI_NDP_END_INDICATION_EVENTID;
 	event_ids[wmi_ndp_end_rsp_event_id] = WMI_NDP_END_RSP_EVENTID;
+	event_ids[wmi_ndl_schedule_update_event_id] =
+					WMI_NDL_SCHEDULE_UPDATE_EVENTID;

 	event_ids[wmi_oem_response_event_id] = WMI_OEM_RESPONSE_EVENTID;
 	event_ids[wmi_peer_stats_info_event_id] = WMI_PEER_STATS_INFO_EVENTID;