From 8c720075969dfa6be2a31be1f8f9b23e87973734 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 9 Jan 2018 17:54:41 -0800 Subject: [PATCH] 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 --- os_if/linux/nan/src/os_if_nan.c | 248 ++++++++++++++++++++++++- target_if/nan/src/target_if_nan.c | 72 +++++++ umac/nan/core/inc/nan_public_structs.h | 95 ++++++++-- umac/nan/core/src/nan_main.c | 27 +++ wmi/inc/wmi_unified_api.h | 29 ++- wmi/inc/wmi_unified_param.h | 1 + wmi/inc/wmi_unified_priv.h | 2 + wmi/src/wmi_unified_api.c | 10 + wmi/src/wmi_unified_tlv.c | 66 +++++++ 9 files changed, 518 insertions(+), 32 deletions(-) diff --git a/os_if/linux/nan/src/os_if_nan.c b/os_if/linux/nan/src/os_if_nan.c index fc06c42f0a..92f00d2bd8 100644 --- 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,20 +1124,20 @@ 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, - struct nan_datapath_confirm_event *ndp_confirm) +static void +os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_confirm_event *ndp_confirm) { int idx = 0; uint8_t *ifname; 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; } diff --git a/target_if/nan/src/target_if_nan.c b/target_if/nan/src/target_if_nan.c index 570c5dffdf..da883b3422 100644 --- 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) { diff --git a/umac/nan/core/inc/nan_public_structs.h b/umac/nan/core/inc/nan_public_structs.h index 2a473c20b7..a4da6e8225 100644 --- 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 * diff --git a/umac/nan/core/src/nan_main.c b/umac/nan/core/src/nan_main.c index cc84277e9c..bdedd2fd92 100644 --- 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; diff --git a/wmi/inc/wmi_unified_api.h b/wmi/inc/wmi_unified_api.h index a3b63971bb..d8784e011b 100644 --- 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 /** diff --git a/wmi/inc/wmi_unified_param.h b/wmi/inc/wmi_unified_param.h index 2a3e1a67d7..5bd23e6d65 100644 --- 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, diff --git a/wmi/inc/wmi_unified_priv.h b/wmi/inc/wmi_unified_priv.h index d2c01942b9..80c7f164aa 100644 --- 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, diff --git a/wmi/src/wmi_unified_api.c b/wmi/src/wmi_unified_api.c index f4c10e344d..8f9df7f683 100644 --- 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) diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index 902e93cc25..dfa86b226a 100644 --- 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;