From 52e9bb6d6ff53c833d7439c00a8f9c070d5fe5f4 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:56 -0700 Subject: [PATCH] qcacmn: NDP_END_REQ implementation Add implementation of NDP_END_REQ. Change-Id: Ifa0bdcdee09c15c68bb12c63ba1157c71650c5bc CRs-Fixed: 2014795 --- os_if/linux/nan/src/os_if_nan.c | 265 ++++++++++++++++++++++ target_if/nan/src/target_if_nan.c | 300 +++++++++++++++++++++++++ umac/nan/core/inc/nan_public_structs.h | 3 + umac/nan/core/src/nan_main.c | 60 ++++- umac/nan/dispatcher/src/nan_ucfg_api.c | 39 ++++ 5 files changed, 666 insertions(+), 1 deletion(-) diff --git a/os_if/linux/nan/src/os_if_nan.c b/os_if/linux/nan/src/os_if_nan.c index 0459f630c69c..681c01ce9c03 100644 --- a/os_if/linux/nan/src/os_if_nan.c +++ b/os_if/linux/nan/src/os_if_nan.c @@ -442,6 +442,61 @@ responder_req_failed: } +/** + * os_if_nan_process_ndp_end_req() - NDP end request handler + * @psoc: pointer to psoc object + * + * @tb: parsed NL attribute list + * tb includes following vendor attributes: + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID + * + * Return: 0 on success or error code on failure + */ +static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + int ret = 0; + QDF_STATUS status; + struct wlan_objmgr_vdev *nan_vdev; + struct nan_datapath_end_req req = {0}; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("Transaction ID is unavailable"); + return -EINVAL; + } + req.transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]) { + cfg80211_err("NDP instance ID array is unavailable"); + return -EINVAL; + } + + req.num_ndp_instances = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]) / + sizeof(uint32_t); + if (0 >= req.num_ndp_instances) { + cfg80211_err("Num NDP instances is 0"); + return -EINVAL; + } + req.ndp_ids = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]); + + cfg80211_debug("sending ndp_end_req to SME, transaction_id: %d", + req.transaction_id); + + nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface is not available"); + return -EINVAL; + } + + status = ucfg_nan_req_processor(nan_vdev, &req, NDP_END_REQ); + ret = qdf_status_to_os_return(status); + 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) { @@ -489,6 +544,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return os_if_nan_process_ndp_initiator_req(psoc, tb); case QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: return os_if_nan_process_ndp_responder_req(psoc, tb); + case QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: + return os_if_nan_process_ndp_end_req(psoc, tb); default: cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); return -EINVAL; @@ -881,6 +938,169 @@ ndp_confirm_nla_failed: kfree_skb(vendor_event); } +/** + * os_if_ndp_end_rsp_handler() - NDP end 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_END_RESPONSE(4 bytest) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes) + * + * Return: none + */ +static void os_if_ndp_end_rsp_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_rsp_event *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 end response"); + return; + } + + data_len = NLMSG_HDRLEN + (4 * NLA_HDRLEN) + (3 * sizeof(uint32_t)) + + sizeof(uint16_t); + + 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_END_RESPONSE)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + rsp->status)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + rsp->reason)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + rsp->transaction_id)) + goto ndp_end_rsp_nla_failed; + + cfg80211_debug("NDP End rsp sent, transaction id: %d, status: %d, reason: %d", + rsp->transaction_id, rsp->status, rsp->reason); + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; + +ndp_end_rsp_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + +/** + * os_if_ndp_end_ind_handler() - NDP end 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_END_IND (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY (4 * num of NDP Instances) + * + * Return: none + */ +static void os_if_ndp_end_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_indication_event *end_ind) +{ + QDF_STATUS status; + uint32_t data_len, i; + struct nan_callbacks cb_obj; + uint32_t *ndp_instance_array; + struct sk_buff *vendor_event; + struct wlan_objmgr_vdev *vdev_itr; + struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("failed to get callbacks"); + return; + } + + if (!end_ind) { + cfg80211_err("Invalid ndp end indication"); + return; + } + + ndp_instance_array = qdf_mem_malloc(end_ind->num_ndp_ids * + sizeof(*ndp_instance_array)); + if (!ndp_instance_array) { + cfg80211_err("Failed to allocate ndp_instance_array"); + return; + } + for (i = 0; i < end_ind->num_ndp_ids; i++) { + int idx = 0; + + ndp_instance_array[i] = end_ind->ndp_map[i].ndp_instance_id; + vdev_itr = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, + end_ind->ndp_map[i].vdev_id, WLAN_NAN_ID); + + if (vdev_itr == NULL) { + cfg80211_err("vdev not found for vdev_id: %d", + end_ind->ndp_map[i].vdev_id); + continue; + } + + idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev), + &end_ind->ndp_map[i].peer_ndi_mac_addr); + if (idx < 0) { + cfg80211_err("can't find addr: %pM in sta_ctx.", + &end_ind->ndp_map[i].peer_ndi_mac_addr); + continue; + } + /* save the value of active sessions on each peer */ + ucfg_nan_set_active_ndp_sessions(vdev, + end_ind->ndp_map[i].num_active_ndp_sessions, + idx); + } + + data_len = (sizeof(uint32_t)) + NLMSG_HDRLEN + (2 * NLA_HDRLEN) + + end_ind->num_ndp_ids * sizeof(*ndp_instance_array); + + 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_END_IND)) + goto ndp_end_ind_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY, + end_ind->num_ndp_ids * sizeof(*ndp_instance_array), + ndp_instance_array)) + goto ndp_end_ind_nla_failed; + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + qdf_mem_free(ndp_instance_array); + return; + +ndp_end_ind_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); + qdf_mem_free(ndp_instance_array); +} + /** * os_if_new_peer_ind_handler() - NDP new peer indication handler * @adapter: pointer to adapter context @@ -925,6 +1145,42 @@ static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev, cfg80211_debug("vdev_id: %d, num_peers: %d", vdev_id, active_peers); } +/** + * os_if_peer_departed_ind_handler() - Handle NDP peer departed indication + * @adapter: pointer to adapter context + * @ind_params: indication parameters + * + * Return: none + */ +static void os_if_peer_departed_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_peer_ind *peer_ind) +{ + QDF_STATUS status; + struct nan_callbacks cb_obj; + 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); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("failed to get callbacks"); + return; + } + + if (NULL == peer_ind) { + cfg80211_err("Invalid new NDP peer params"); + 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); + active_peers--; + ucfg_nan_set_active_peers(vdev, active_peers); + cb_obj.peer_departed_ind(vdev_id, peer_ind->sta_id, + &peer_ind->peer_mac_addr, + (active_peers == 0 ? true : false)); +} + /** * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler * @adapter: pointer to adapter context @@ -1114,6 +1370,15 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, case NDP_RESPONDER_RSP: os_if_ndp_responder_rsp_handler(vdev, msg); break; + case NDP_END_RSP: + os_if_ndp_end_rsp_handler(vdev, msg); + break; + case NDP_END_IND: + os_if_ndp_end_ind_handler(vdev, msg); + break; + case NDP_PEER_DEPARTED: + os_if_peer_departed_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 5d286a9bebc4..2a95ab96b836 100644 --- a/target_if/nan/src/target_if_nan.c +++ b/target_if/nan/src/target_if_nan.c @@ -22,6 +22,7 @@ #include "../../../umac/nan/core/src/nan_main_i.h" #include "nan_public_structs.h" +#include "nan_ucfg_api.h" #include "target_if_nan.h" #include "wmi_unified_api.h" #include "scheduler_api.h" @@ -54,6 +55,16 @@ static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg) vdev = rsp->vdev; break; } + case NDP_END_RSP: { + struct nan_datapath_end_rsp_event *rsp = msg->bodyptr; + vdev = rsp->vdev; + break; + } + case NDP_END_IND: { + struct nan_datapath_end_indication_event *rsp = msg->bodyptr; + vdev = rsp->vdev; + break; + } default: target_if_err("invalid msg type %d", msg->type); qdf_mem_free(msg->bodyptr); @@ -730,6 +741,258 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, return 0; } +static QDF_STATUS target_if_nan_ndp_end_req(struct nan_datapath_end_req *req) +{ + int ret; + uint16_t len; + wmi_buf_t buf; + QDF_STATUS status; + wmi_unified_t wmi_handle; + uint32_t ndp_end_req_len, i; + struct wlan_objmgr_psoc *psoc; + struct scheduler_msg msg = {0}; + wmi_ndp_end_req *ndp_end_req_lst; + wmi_ndp_end_req_fixed_param *cmd; + struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; + struct nan_datapath_end_rsp_event end_rsp = {0}; + + if (!req) { + target_if_err("req is null"); + return QDF_STATUS_E_INVAL; + } + + psoc = wlan_vdev_get_psoc(req->vdev); + if (!psoc) { + target_if_err("psoc is null."); + return QDF_STATUS_E_NULL_VALUE; + } + + wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + if (!wmi_handle) { + target_if_err("wmi_handle is null."); + 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."); + return QDF_STATUS_E_NULL_VALUE; + } + + /* len of tlv following fixed param */ + ndp_end_req_len = sizeof(wmi_ndp_end_req) * req->num_ndp_instances; + /* above comes out to 4 byte alligned already, no need of padding */ + len = sizeof(*cmd) + ndp_end_req_len + WMI_TLV_HDR_SIZE; + buf = wmi_buf_alloc(wmi_handle, len); + if (!buf) { + target_if_err("Malloc failed"); + status = QDF_STATUS_E_NOMEM; + goto send_ndp_end_fail; + } + cmd = (wmi_ndp_end_req_fixed_param *) wmi_buf_data(buf); + + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_ndp_end_req_fixed_param, + WMITLV_GET_STRUCT_TLVLEN(wmi_ndp_end_req_fixed_param)); + + cmd->transaction_id = req->transaction_id; + + /* set tlv pointer to end of fixed param */ + WMITLV_SET_HDR((uint8_t *)&cmd[1], WMITLV_TAG_ARRAY_STRUC, + ndp_end_req_len); + + ndp_end_req_lst = (wmi_ndp_end_req *)((uint8_t *)&cmd[1] + + WMI_TLV_HDR_SIZE); + for (i = 0; i < req->num_ndp_instances; i++) { + WMITLV_SET_HDR(&ndp_end_req_lst[i], + WMITLV_TAG_ARRAY_FIXED_STRUC, + (sizeof(*ndp_end_req_lst) - WMI_TLV_HDR_SIZE)); + + ndp_end_req_lst[i].ndp_instance_id = req->ndp_ids[i]; + } + + target_if_debug("Sending WMI_NDP_END_REQ_CMDID to FW"); + ret = wmi_unified_cmd_send(wmi_handle, buf, len, + WMI_NDP_END_REQ_CMDID); + if (ret < 0) { + target_if_err("WMI_NDP_END_REQ_CMDID failed, ret: %d", ret); + wmi_buf_free(buf); + status = QDF_STATUS_E_FAILURE; + goto send_ndp_end_fail; + } + return QDF_STATUS_SUCCESS; + +send_ndp_end_fail: + end_rsp.vdev = req->vdev; + msg.type = NDP_END_RSP; + end_rsp.status = NAN_DATAPATH_RSP_STATUS_ERROR; + end_rsp.reason = NAN_DATAPATH_END_FAILED; + end_rsp.transaction_id = req->transaction_id; + msg.bodyptr = &end_rsp; + + if (nan_rx_ops && nan_rx_ops->nan_event_rx) + nan_rx_ops->nan_event_rx(&msg); + + return status; +} + +static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, + uint32_t data_len) +{ + int ret = 0; + QDF_STATUS status; + struct wlan_objmgr_psoc *psoc; + struct wlan_objmgr_vdev *vdev; + struct scheduler_msg msg = {0}; + WMI_NDP_END_RSP_EVENTID_param_tlvs *event; + struct nan_datapath_end_rsp_event *end_rsp; + struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; + wmi_ndp_end_rsp_event_fixed_param *fixed_params = NULL; + + psoc = target_if_get_psoc_from_scn_hdl(scn); + if (!psoc) { + target_if_err("psoc is null"); + return -EINVAL; + } + + nan_rx_ops = target_if_nan_get_rx_ops(psoc); + /* process even here and call callback */ + if (!nan_rx_ops || !nan_rx_ops->nan_event_rx) { + target_if_err("lmac callbacks not registered"); + return -EINVAL; + } + + event = (WMI_NDP_END_RSP_EVENTID_param_tlvs *) data; + fixed_params = (wmi_ndp_end_rsp_event_fixed_param *)event->fixed_param; + target_if_debug("WMI_NDP_END_RSP_EVENTID(0x%X) recieved. transaction_id: %d, rsp_status: %d, reason_code: %d", + WMI_NDP_END_RSP_EVENTID, fixed_params->transaction_id, + fixed_params->rsp_status, fixed_params->reason_code); + + vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!vdev) { + target_if_err("vdev is null"); + return -EINVAL; + } + + end_rsp = qdf_mem_malloc(sizeof(*end_rsp)); + if (!end_rsp) { + target_if_err("malloc failed"); + ret = -ENOMEM; + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); + goto send_ndp_end_rsp; + } + + end_rsp->vdev = vdev; + end_rsp->transaction_id = fixed_params->transaction_id; + end_rsp->reason = fixed_params->reason_code; + end_rsp->status = fixed_params->rsp_status; + +send_ndp_end_rsp: + msg.bodyptr = end_rsp; + msg.type = NDP_END_RSP; + msg.callback = target_if_nan_event_dispatcher; + target_if_err("NDP_END_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(end_rsp); + return -EINVAL; + } + return ret; +} + +static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, + uint32_t data_len) +{ + int i, buf_size; + QDF_STATUS status; + struct scheduler_msg msg; + wmi_ndp_end_indication *ind; + struct qdf_mac_addr peer_addr; + struct wlan_objmgr_psoc *psoc; + struct wlan_objmgr_vdev *vdev; + struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; + WMI_NDP_END_INDICATION_EVENTID_param_tlvs *event; + struct nan_datapath_end_indication_event *rsp; + + psoc = target_if_get_psoc_from_scn_hdl(scn); + if (!psoc) { + target_if_err("psoc is null"); + return -EINVAL; + } + + nan_rx_ops = target_if_nan_get_rx_ops(psoc); + if (!nan_rx_ops || !nan_rx_ops->nan_event_rx) { + target_if_err("lmac callbacks not registered"); + return -EINVAL; + } + + event = (WMI_NDP_END_INDICATION_EVENTID_param_tlvs *) data; + if (event->num_ndp_end_indication_list == 0) { + target_if_err("Error: Event ignored, 0 ndp instances"); + return -EINVAL; + } + + vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!vdev) { + target_if_err("vdev is null"); + return -EINVAL; + } + + target_if_debug("number of ndp instances = %d", + event->num_ndp_end_indication_list); + buf_size = sizeof(*rsp) + event->num_ndp_end_indication_list * + sizeof(rsp->ndp_map[0]); + rsp = qdf_mem_malloc(buf_size); + if (!rsp) { + target_if_err("Failed to allocate memory"); + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); + return -ENOMEM; + } + + rsp->vdev = vdev; + rsp->num_ndp_ids = event->num_ndp_end_indication_list; + + ind = event->ndp_end_indication_list; + for (i = 0; i < rsp->num_ndp_ids; i++) { + WMI_MAC_ADDR_TO_CHAR_ARRAY( + &ind[i].peer_ndi_mac_addr, + peer_addr.bytes); + /* add mac address print - TBD */ + target_if_debug( + "ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ", + i, ind[i].type, ind[i].reason_code, + ind[i].ndp_instance_id, ind[i].num_active_ndps_on_peer); + + /* Add each instance entry to the list */ + rsp->ndp_map[i].ndp_instance_id = + ind[i].ndp_instance_id; + rsp->ndp_map[i].vdev_id = ind[i].vdev_id; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr, + rsp->ndp_map[i].peer_ndi_mac_addr.bytes); + rsp->ndp_map[i].num_active_ndp_sessions = + ind[i].num_active_ndps_on_peer; + rsp->ndp_map[i].type = ind[i].type; + rsp->ndp_map[i].reason_code = + ind[i].reason_code; + } + + msg.type = NDP_END_IND; + msg.bodyptr = rsp; + msg.callback = target_if_nan_event_dispatcher; + + target_if_err("NDP_END_IND 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 QDF_STATUS target_if_nan_req(void *req, uint32_t req_type) { /* send cmd to fw */ @@ -740,6 +1003,9 @@ static QDF_STATUS target_if_nan_req(void *req, uint32_t req_type) case NDP_RESPONDER_REQ: target_if_nan_ndp_responder_req(req); break; + case NDP_END_REQ: + target_if_nan_ndp_end_req(req); + break; default: target_if_err("invalid req type"); break; @@ -823,6 +1089,26 @@ 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_NDP_END_INDICATION_EVENTID, + target_if_ndp_end_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_END_RSP_EVENTID, + target_if_ndp_end_rsp_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; } @@ -859,6 +1145,20 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) status = ret; } + ret = wmi_unified_unregister_event_handler(handle, + WMI_NDP_END_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_END_RSP_EVENTID); + if (ret) { + target_if_err("wmi event deregistration failed, ret: %d", ret); + status = ret; + } + if (status) return QDF_STATUS_E_FAILURE; else diff --git a/umac/nan/core/inc/nan_public_structs.h b/umac/nan/core/inc/nan_public_structs.h index 6c6f94f020cf..4cd2785fdc3a 100644 --- a/umac/nan/core/inc/nan_public_structs.h +++ b/umac/nan/core/inc/nan_public_structs.h @@ -497,6 +497,9 @@ struct nan_callbacks { int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *); QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr); + void (*peer_departed_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, + bool); + void (*ndp_delete_peers)(struct peer_nan_datapath_map*, uint8_t); void (*delete_peers_by_addr)(uint8_t, struct qdf_mac_addr); }; diff --git a/umac/nan/core/src/nan_main.c b/umac/nan/core/src/nan_main.c index c8ff0dbf79bc..2aefbe335751 100644 --- a/umac/nan/core/src/nan_main.c +++ b/umac/nan/core/src/nan_main.c @@ -115,7 +115,6 @@ static void nan_req_incomplete(void *req, uint32_t cmdtype) static void nan_req_activated(void *in_req, uint32_t cmdtype) { uint32_t req_type; - QDF_STATUS status; struct wlan_objmgr_psoc *psoc; struct wlan_objmgr_vdev *vdev; struct wlan_lmac_if_nan_tx_ops *tx_ops; @@ -413,6 +412,57 @@ static QDF_STATUS nan_handle_responder_rsp( return QDF_STATUS_SUCCESS; } +static QDF_STATUS nan_handle_ndp_end_rsp( + struct nan_datapath_end_rsp_event *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_END_RSP, rsp); + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS nan_handle_end_ind( + struct nan_datapath_end_indication_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.ndp_delete_peers(ind->ndp_map, ind->num_ndp_ids); + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ind->vdev, + NDP_END_IND, ind); + + return QDF_STATUS_SUCCESS; +} + QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) { QDF_STATUS status = QDF_STATUS_SUCCESS; @@ -448,6 +498,14 @@ QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) cmd.cmd_type = WLAN_SER_CMD_NDP_RESP_REQ; wlan_serialization_remove_cmd(&cmd); break; + case NDP_END_RSP: + nan_handle_ndp_end_rsp(pe_msg->bodyptr, &cmd.vdev); + cmd.cmd_type = WLAN_SER_CMD_NDP_DATA_END_INIT_REQ; + wlan_serialization_remove_cmd(&cmd); + break; + case NDP_END_IND: + nan_handle_end_ind(pe_msg->bodyptr); + break; default: nan_alert("Unhandled NDP event: %d", pe_msg->type); status = QDF_STATUS_E_NOSUPPORT; diff --git a/umac/nan/dispatcher/src/nan_ucfg_api.c b/umac/nan/dispatcher/src/nan_ucfg_api.c index cf0510564343..2f2d28c3a24b 100644 --- a/umac/nan/dispatcher/src/nan_ucfg_api.c +++ b/umac/nan/dispatcher/src/nan_ucfg_api.c @@ -440,6 +440,40 @@ free_resources: return NULL; } +static struct nan_datapath_end_req *ucfg_nan_copy_end_req( + struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_req *in_req) +{ + struct nan_datapath_end_req *req; + + req = qdf_mem_malloc(sizeof(*req)); + if (!req) { + nan_alert("malloc failed"); + return NULL; + } + + qdf_mem_copy(req, in_req, sizeof(*req)); + if (in_req->num_ndp_instances) { + req->ndp_ids = qdf_mem_malloc(sizeof(uint32_t) * + in_req->num_ndp_instances); + if (!req->ndp_ids) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->ndp_ids, in_req->ndp_ids, + sizeof(uint32_t) * in_req->num_ndp_instances); + } + + /* do not get ref here, rather take ref when request is activated */ + req->vdev = vdev; + return req; + +free_resources: + qdf_mem_free(req->ndp_ids); + qdf_mem_free(req); + return NULL; +} + QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { @@ -459,6 +493,9 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, case NDP_RESPONDER_REQ: req = ucfg_nan_copy_responder_req(vdev, in_req); break; + case NDP_END_REQ: + req = ucfg_nan_copy_end_req(vdev, in_req); + break; default: nan_err("in correct message req type: %d", req_type); return QDF_STATUS_E_INVAL; @@ -522,6 +559,7 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, psoc_obj->cb_obj.get_peer_idx = cb_obj->get_peer_idx; psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind; + psoc_obj->cb_obj.peer_departed_ind = cb_obj->peer_departed_ind; return 0; } @@ -537,6 +575,7 @@ int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, } psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer; + psoc_obj->cb_obj.ndp_delete_peers = cb_obj->ndp_delete_peers; psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr; return 0;