From 2b4f9310f8021584a1993ebc3dfa2b82df8fd3e6 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 15 Dec 2016 12:44:14 -0800 Subject: [PATCH 01/18] qcacmn: Add new files for new NAN component Add new files for new NAN component. Change-Id: I817723e518d53e9348d817746fc8318171d6ddf3 CRs-Fixed: 2014795 --- inc/target_if_nan.h | 26 ++++++++++++++++++++++++++ src/target_if_nan.c | 21 +++++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 inc/target_if_nan.h create mode 100644 src/target_if_nan.c diff --git a/inc/target_if_nan.h b/inc/target_if_nan.h new file mode 100644 index 0000000000..fa96ba83d3 --- /dev/null +++ b/inc/target_if_nan.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2017 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all + * copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * DOC: contains nan target if declarations + */ + +#ifndef _WLAN_NAN_TGT_IF_H_ +#define _WLAN_NAN_TGT_IF_H_ + +#endif /* _WIFI_POS_TGT_IF_H_ */ diff --git a/src/target_if_nan.c b/src/target_if_nan.c new file mode 100644 index 0000000000..3e46ca711d --- /dev/null +++ b/src/target_if_nan.c @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2016-2017 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all + * copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * DOC: contains nan target if functions + */ From cdb624f81dd722f1a88e98548dcc2f98d1a7efce Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 22 Mar 2017 16:19:57 -0700 Subject: [PATCH 02/18] qcacmn: Add interface with LMAC for NAN Component Add interface with LMAC for NAN Component. Change-Id: Idbcdaa19a7a2b83d5a2d125419a7bc6cbe72033d CRs-Fixed: 2014795 --- inc/target_if_nan.h | 71 +++++++++++++++++++++++++++++++++++++++++++++ src/target_if_nan.c | 54 ++++++++++++++++++++++++++++++++++ 2 files changed, 125 insertions(+) diff --git a/inc/target_if_nan.h b/inc/target_if_nan.h index fa96ba83d3..2563efae7d 100644 --- a/inc/target_if_nan.h +++ b/inc/target_if_nan.h @@ -23,4 +23,75 @@ #ifndef _WLAN_NAN_TGT_IF_H_ #define _WLAN_NAN_TGT_IF_H_ +#include "qdf_types.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct wlan_objmgr_psoc; +struct wlan_lmac_if_rx_ops; +struct wlan_lmac_if_tx_ops; +struct wlan_lmac_if_nan_rx_ops; + +/** + * target_if_nan_get_tx_ops() - retrieve the nan tx_ops + * @psoc: psoc context + * + * API to retrieve the nan tx_ops from the psoc context + * + * Return: nan tx_ops pointer + */ +struct wlan_lmac_if_nan_tx_ops *target_if_nan_get_tx_ops( + struct wlan_objmgr_psoc *psoc); + +/** + * target_if_nan_get_rx_ops() - retrieve the nan rx_ops + * @psoc: psoc context + * + * API to retrieve the nan rx_ops from the psoc context + * + * Return: nan rx_ops pointer + */ +struct wlan_lmac_if_nan_rx_ops *target_if_nan_get_rx_ops( + struct wlan_objmgr_psoc *psoc); + +/** + * target_if_nan_register_tx_ops() - registers nan tx ops + * @tx_ops: tx ops + * + * Return: none + */ +void target_if_nan_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops); + +/** + * target_if_nan_register_rx_ops() - registers nan rx ops + * @tx_ops: rx ops + * + * Return: none + */ +void target_if_nan_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops); + +/** + * target_if_nan_register_events() - registers with NDP events + * @psoc: pointer to psoc object + * + * Return: status of operation + */ +QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc); + +/** + * target_if_nan_deregister_events() - registers nan rx ops + * @psoc: pointer to psoc object + * + * Return: status of operation + */ +QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc); + #endif /* _WIFI_POS_TGT_IF_H_ */ diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 3e46ca711d..cdf51d0169 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -19,3 +19,57 @@ /** * DOC: contains nan target if functions */ + +#include "wlan_nan_api.h" +#include "nan_public_structs.h" +#include "target_if_nan.h" + +static QDF_STATUS target_if_nan_req(void *in_req, uint32_t req_type) +{ + return QDF_STATUS_SUCCESS; +} + +void target_if_nan_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops) +{ + tx_ops->nan_tx_ops.nan_req_tx = target_if_nan_req; +} + +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; +} + +inline struct wlan_lmac_if_nan_tx_ops *target_if_nan_get_tx_ops( + struct wlan_objmgr_psoc *psoc) +{ + if (!psoc) { + target_if_err("psoc is null"); + return NULL; + } + + return &psoc->soc_cb.tx_ops.nan_tx_ops; +} + +inline struct wlan_lmac_if_nan_rx_ops *target_if_nan_get_rx_ops( + struct wlan_objmgr_psoc *psoc) +{ + if (!psoc) { + target_if_err("psoc is null"); + return NULL; + } + + return &psoc->soc_cb.rx_ops.nan_rx_ops; +} + +QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) +{ + /* TBD */ + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) +{ + /* TBD */ + return QDF_STATUS_SUCCESS; +} From 8ea4a2cc81bde21f3ef6cf4f63ec58c53887b454 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 5 Apr 2017 17:26:18 -0700 Subject: [PATCH 03/18] qcacmn: NDP_INITIATOR_REQ implementation Add implementation for NDP_INITIATOR_REQ. Change-Id: Ieb4cb79d500fd75b23b4a3f8bfa414d14eb6fe18 CRs-Fixed: 2014795 --- src/target_if_nan.c | 571 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 564 insertions(+), 7 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index cdf51d0169..8203babf00 100644 --- a/src/target_if_nan.c +++ b/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; } From f36006eacc8161e8f9cfca802b0e46ae3ec5b870 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:28 -0700 Subject: [PATCH 04/18] qcacmn: NDP_RESPONDER_REQ implementation Add implementation for NDP_RESPONDER_REQ. Change-Id: I27029eae88e0bc545c8444adf1342b2ec95f4d60 CRs-Fixed: 2014795 --- src/target_if_nan.c | 234 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 8203babf00..5d286a9beb 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -49,6 +49,11 @@ static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg) vdev = confirm->vdev; break; } + case NDP_RESPONDER_RSP: { + struct nan_datapath_responder_rsp *rsp = msg->bodyptr; + vdev = rsp->vdev; + break; + } default: target_if_err("invalid msg type %d", msg->type); qdf_mem_free(msg->bodyptr); @@ -516,6 +521,215 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, return 0; } +static QDF_STATUS target_if_nan_ndp_responder_req( + struct nan_datapath_responder_req *req) +{ + int ret; + uint16_t len; + wmi_buf_t buf; + uint8_t *tlv_ptr; + QDF_STATUS status; + wmi_unified_t wmi_handle; + struct wlan_objmgr_psoc *psoc; + struct scheduler_msg pe_msg = {0}; + wmi_ndp_responder_req_fixed_param *cmd; + struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; + struct nan_datapath_responder_rsp rsp = {0}; + uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len; + + if (!req) { + target_if_err("Invalid req."); + 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; + } + + vdev_id = wlan_vdev_get_id(req->vdev); + target_if_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d", + vdev_id, req->transaction_id, + req->ndp_rsp, + req->ndp_instance_id, + req->ndp_info.ndp_app_info_len); + + /* + * 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(req->ndp_config.ndp_cfg_len, 4); + ndp_app_info_len = qdf_roundup(req->ndp_info.ndp_app_info_len, 4); + pmk_len = qdf_roundup(req->pmk.pmk_len, 4); + /* allocated memory for fixed params as well as variable size data */ + len = sizeof(*cmd) + 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_responder_fail; + } + cmd = (wmi_ndp_responder_req_fixed_param *) wmi_buf_data(buf); + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_ndp_responder_req_fixed_param, + WMITLV_GET_STRUCT_TLVLEN( + wmi_ndp_responder_req_fixed_param)); + cmd->vdev_id = vdev_id; + cmd->transaction_id = req->transaction_id; + cmd->ndp_instance_id = req->ndp_instance_id; + cmd->rsp_code = req->ndp_rsp; + cmd->ndp_cfg_len = req->ndp_config.ndp_cfg_len; + cmd->ndp_app_info_len = req->ndp_info.ndp_app_info_len; + cmd->nan_pmk_len = req->pmk.pmk_len; + cmd->nan_csid = req->ncs_sk_type; + + tlv_ptr = (uint8_t *)&cmd[1]; + WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len); + qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], + 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], + req->ndp_info.ndp_app_info, + req->ndp_info.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], 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, csid: %d", + cmd->vdev_id, cmd->transaction_id, cmd->nan_csid); + + target_if_debug("ndp_config len: %d", + req->ndp_config.ndp_cfg_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + req->ndp_config.ndp_cfg, + req->ndp_config.ndp_cfg_len); + + target_if_debug("ndp_app_info len: %d", + req->ndp_info.ndp_app_info_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + req->ndp_info.ndp_app_info, + 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, + req->pmk.pmk, cmd->nan_pmk_len); + + target_if_debug("sending WMI_NDP_RESPONDER_REQ_CMDID(0x%X)", + WMI_NDP_RESPONDER_REQ_CMDID); + ret = wmi_unified_cmd_send(wmi_handle, buf, len, + WMI_NDP_RESPONDER_REQ_CMDID); + if (ret < 0) { + target_if_err("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d", + ret); + wmi_buf_free(buf); + status = QDF_STATUS_E_FAILURE; + goto send_ndp_responder_fail; + } + return QDF_STATUS_SUCCESS; + +send_ndp_responder_fail: + rsp.vdev = req->vdev; + rsp.transaction_id = req->transaction_id; + rsp.status = NAN_DATAPATH_RSP_STATUS_ERROR; + rsp.reason = NAN_DATAPATH_DATA_RESPONDER_REQ_FAILED; + pe_msg.bodyptr = &rsp; + pe_msg.type = NDP_RESPONDER_RSP; + 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_responder_rsp_handler(ol_scn_t scn, uint8_t *data, + uint32_t len) +{ + QDF_STATUS status; + struct wlan_objmgr_psoc *psoc; + struct wlan_objmgr_vdev *vdev; + struct scheduler_msg msg = {0}; + struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; + struct nan_datapath_responder_rsp *rsp; + WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *event; + wmi_ndp_responder_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; + } + + 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_RESPONDER_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->reason = fixed_params->reason_code; + rsp->status = fixed_params->rsp_status; + rsp->create_peer = fixed_params->create_peer; + WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr, + rsp->peer_mac_addr.bytes); + + target_if_debug("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: %pM,transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d", + WMI_NDP_RESPONDER_RSP_EVENTID, fixed_params->vdev_id, + rsp->peer_mac_addr.bytes, rsp->transaction_id, + rsp->status, rsp->reason, rsp->create_peer); + msg.bodyptr = rsp; + msg.type = NDP_RESPONDER_RSP; + msg.callback = target_if_nan_event_dispatcher; + + target_if_debug("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 QDF_STATUS target_if_nan_req(void *req, uint32_t req_type) { /* send cmd to fw */ @@ -523,6 +737,9 @@ static QDF_STATUS target_if_nan_req(void *req, uint32_t req_type) case NDP_INITIATOR_REQ: target_if_nan_ndp_intiaitor_req(req); break; + case NDP_RESPONDER_REQ: + target_if_nan_ndp_responder_req(req); + break; default: target_if_err("invalid req type"); break; @@ -596,6 +813,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_NDP_RESPONDER_RSP_EVENTID, + target_if_ndp_responder_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; } @@ -625,6 +852,13 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) status = ret; } + ret = wmi_unified_unregister_event_handler(handle, + WMI_NDP_RESPONDER_RSP_EVENTID); + if (ret) { + target_if_err("wmi event deregistration failed, ret: %d", ret); + status = ret; + } + if (status) return QDF_STATUS_E_FAILURE; else From 720b86499a90f0ce3358cb3e9b2e60c7a1e76e3a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:56 -0700 Subject: [PATCH 05/18] qcacmn: NDP_END_REQ implementation Add implementation of NDP_END_REQ. Change-Id: Ifa0bdcdee09c15c68bb12c63ba1157c71650c5bc CRs-Fixed: 2014795 --- src/target_if_nan.c | 300 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 300 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 5d286a9beb..2a95ab96b8 100644 --- a/src/target_if_nan.c +++ b/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 From f110ea5155768585d79703274d7e897bcbdaed11 Mon Sep 17 00:00:00 2001 From: Rajeev Kumar Date: Mon, 17 Apr 2017 17:00:41 -0700 Subject: [PATCH 06/18] qcacmn: Initialize scheduler_msg on stack before posting message Initialize scheduler_msg on stack before posting using scheduler API such that un-used fields in message structure are initialized to 0. Change-Id: Ib3183b2c65eb9affd6610f4572c751c39a25fff7 CRs-Fixed: 2034772 --- src/target_if_nan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 2a95ab96b8..07f278c71f 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -907,7 +907,7 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, { int i, buf_size; QDF_STATUS status; - struct scheduler_msg msg; + struct scheduler_msg msg = {0}; wmi_ndp_end_indication *ind; struct qdf_mac_addr peer_addr; struct wlan_objmgr_psoc *psoc; From c58bb3e18e54e0380b97cdcf5e9fbfae2722e06b Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 07/18] qcacmn: Add Passphrase and Service Name parameter to NDP cmds Add Passphrase and Service Name to NDP initiator request and NDP responder request. Change-Id: I6a189747760a15393fcbac9dc382847fef789ab1 CRs-Fixed: 2072498 --- src/target_if_nan.c | 67 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 63 insertions(+), 4 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 07f278c71f..2797a3f5b9 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -120,6 +120,7 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) struct wlan_objmgr_psoc *psoc; struct scheduler_msg pe_msg = {0}; wmi_ndp_initiator_req_fixed_param *cmd; + uint32_t passphrase_len, service_name_len; 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}; @@ -155,9 +156,13 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) 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); + passphrase_len = qdf_roundup(ndp_req->passphrase.passphrase_len, 4); + service_name_len = + qdf_roundup(ndp_req->service_name.service_name_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; + len = sizeof(*cmd) + sizeof(*ch_tlv) + (5 * WMI_TLV_HDR_SIZE) + + ndp_cfg_len + ndp_app_info_len + pmk_len + + passphrase_len + service_name_len; buf = wmi_buf_alloc(wmi_handle, len); if (!buf) { @@ -181,6 +186,8 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) 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; + cmd->nan_passphrase_len = ndp_req->passphrase.passphrase_len; + cmd->nan_servicename_len = ndp_req->service_name.service_name_len; ch_tlv = (wmi_channel *)&cmd[1]; WMITLV_SET_HDR(ch_tlv, WMITLV_TAG_STRUC_wmi_channel, @@ -207,6 +214,17 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) cmd->nan_pmk_len); tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len; + WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); + qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->passphrase.passphrase, + cmd->nan_passphrase_len); + tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; + + WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); + qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], + ndp_req->service_name.service_name, + cmd->nan_servicename_len); + tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_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); @@ -227,6 +245,17 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) 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("pass phrase len: %d", cmd->nan_passphrase_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + ndp_req->passphrase.passphrase, + cmd->nan_passphrase_len); + + target_if_debug("service name len: %d", cmd->nan_servicename_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + ndp_req->service_name.service_name, + cmd->nan_servicename_len); + target_if_debug("sending WMI_NDP_INITIATOR_REQ_CMDID(0x%X)", WMI_NDP_INITIATOR_REQ_CMDID); @@ -544,6 +573,7 @@ static QDF_STATUS target_if_nan_ndp_responder_req( struct wlan_objmgr_psoc *psoc; struct scheduler_msg pe_msg = {0}; wmi_ndp_responder_req_fixed_param *cmd; + uint32_t passphrase_len, service_name_len; struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; struct nan_datapath_responder_rsp rsp = {0}; uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len; @@ -585,9 +615,13 @@ static QDF_STATUS target_if_nan_ndp_responder_req( ndp_cfg_len = qdf_roundup(req->ndp_config.ndp_cfg_len, 4); ndp_app_info_len = qdf_roundup(req->ndp_info.ndp_app_info_len, 4); pmk_len = qdf_roundup(req->pmk.pmk_len, 4); + passphrase_len = qdf_roundup(req->passphrase.passphrase_len, 4); + service_name_len = + qdf_roundup(req->service_name.service_name_len, 4); + /* allocated memory for fixed params as well as variable size data */ - len = sizeof(*cmd) + 3*WMI_TLV_HDR_SIZE + ndp_cfg_len + ndp_app_info_len - + pmk_len; + len = sizeof(*cmd) + 5*WMI_TLV_HDR_SIZE + ndp_cfg_len + ndp_app_info_len + + pmk_len + passphrase_len + service_name_len; buf = wmi_buf_alloc(wmi_handle, len); if (!buf) { @@ -608,6 +642,8 @@ static QDF_STATUS target_if_nan_ndp_responder_req( cmd->ndp_app_info_len = req->ndp_info.ndp_app_info_len; cmd->nan_pmk_len = req->pmk.pmk_len; cmd->nan_csid = req->ncs_sk_type; + cmd->nan_passphrase_len = req->passphrase.passphrase_len; + cmd->nan_servicename_len = req->service_name.service_name_len; tlv_ptr = (uint8_t *)&cmd[1]; WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len); @@ -626,6 +662,19 @@ static QDF_STATUS target_if_nan_ndp_responder_req( cmd->nan_pmk_len); tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len; + WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); + qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], + req->passphrase.passphrase, + cmd->nan_passphrase_len); + tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; + + WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); + qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], + req->service_name.service_name, + cmd->nan_servicename_len); + + tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_len; + target_if_debug("vdev_id = %d, transaction_id: %d, csid: %d", cmd->vdev_id, cmd->transaction_id, cmd->nan_csid); @@ -645,6 +694,16 @@ static QDF_STATUS target_if_nan_ndp_responder_req( QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, req->pmk.pmk, cmd->nan_pmk_len); + target_if_debug("pass phrase len: %d", cmd->nan_passphrase_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + req->passphrase.passphrase, + cmd->nan_passphrase_len); + + target_if_debug("service name len: %d", cmd->nan_servicename_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, + req->service_name.service_name, + cmd->nan_servicename_len); + target_if_debug("sending WMI_NDP_RESPONDER_REQ_CMDID(0x%X)", WMI_NDP_RESPONDER_REQ_CMDID); ret = wmi_unified_cmd_send(wmi_handle, buf, len, From 8e7fc37d2333b67cd485ca97f185316e2e70e7b9 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 08/18] qcacmn: Enable support for multiple NAN Data Interfaces Enable support for multiple nan data interfaces. The usespace may need to create multiple NDIs depending on whether it requires IP isolation or not. Change-Id: I4391f2efdc6bdede52a73915531d39dd7798c39d CRs-Fixed: 2072501 --- src/target_if_nan.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 2797a3f5b9..4872e3cd49 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -927,7 +927,8 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, 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); + vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, QDF_NDI_MODE, + WLAN_NAN_ID); if (!vdev) { target_if_err("vdev is null"); return -EINVAL; @@ -993,7 +994,8 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, QDF_NDI_MODE, + WLAN_NAN_ID); if (!vdev) { target_if_err("vdev is null"); return -EINVAL; From 779725f445b72164573b1a64724b6bdb32f94710 Mon Sep 17 00:00:00 2001 From: Mukul Sharma Date: Fri, 3 Nov 2017 19:26:54 +0530 Subject: [PATCH 09/18] qcacmn: Converge on wmi event registration / unregistration Converge on wmi event registration / unregistration method. Change-Id: If03a38d74a47cc1d900bc5734a7c8f950513efaa CRs-Fixed: 2148479 --- src/target_if_nan.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 4872e3cd49..3b5c6642a1 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -1112,7 +1112,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc); ret = wmi_unified_register_event_handler(handle, - WMI_NDP_INITIATOR_RSP_EVENTID, + wmi_ndp_initiator_rsp_event_id, target_if_ndp_initiator_rsp_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1121,7 +1121,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_register_event_handler(handle, - WMI_NDP_INDICATION_EVENTID, + wmi_ndp_indication_event_id, target_if_ndp_ind_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1131,7 +1131,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_register_event_handler(handle, - WMI_NDP_CONFIRM_EVENTID, + wmi_ndp_confirm_event_id, target_if_ndp_confirm_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1141,7 +1141,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_register_event_handler(handle, - WMI_NDP_RESPONDER_RSP_EVENTID, + wmi_ndp_responder_rsp_event_id, target_if_ndp_responder_rsp_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1151,7 +1151,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_register_event_handler(handle, - WMI_NDP_END_INDICATION_EVENTID, + wmi_ndp_end_indication_event_id, target_if_ndp_end_ind_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1161,7 +1161,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_register_event_handler(handle, - WMI_NDP_END_RSP_EVENTID, + wmi_ndp_end_rsp_event_id, target_if_ndp_end_rsp_handler, WMI_RX_UMAC_CTX); if (ret) { @@ -1179,42 +1179,42 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc); ret = wmi_unified_unregister_event_handler(handle, - WMI_NDP_INITIATOR_RSP_EVENTID); + wmi_ndp_initiator_rsp_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_INDICATION_EVENTID); + wmi_ndp_indication_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_CONFIRM_EVENTID); + wmi_ndp_confirm_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_RESPONDER_RSP_EVENTID); + wmi_ndp_responder_rsp_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_INDICATION_EVENTID); + wmi_ndp_end_indication_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_EVENTID); + wmi_ndp_end_rsp_event_id); if (ret) { target_if_err("wmi event deregistration failed, ret: %d", ret); status = ret; From fee11bd5705e7fe3613c12faacf0b6c06d9f9c0c Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 14 Dec 2017 13:24:31 -0800 Subject: [PATCH 10/18] qcacmn: Avoid WMI TLV structures in NAN target_if Refactor NAN target_if to make it wmi-type agnostic. Specifically do not access wmi structures in NAN target_if. All the access to wmi structures should happen in tlv and non-tlv specific wmi files. Change-Id: I944b678fc501723d7cd26c9b21c4cc6ddb7fda4e CRs-Fixed: 2159876 --- src/target_if_nan.c | 840 ++++++++------------------------------------ 1 file changed, 155 insertions(+), 685 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 3b5c6642a1..2f0c8305f5 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the @@ -27,104 +27,113 @@ #include "wmi_unified_api.h" #include "scheduler_api.h" +static QDF_STATUS target_if_nan_event_flush_cb(struct scheduler_msg *msg) +{ + void *ptr = msg->bodyptr; + struct wlan_objmgr_vdev *vdev = NULL; + + switch (msg->type) { + case NDP_INITIATOR_RSP: + vdev = ((struct nan_datapath_initiator_rsp *)ptr)->vdev; + break; + case NDP_INDICATION: + vdev = ((struct nan_datapath_indication_event *)ptr)->vdev; + break; + case NDP_CONFIRM: + vdev = ((struct nan_datapath_confirm_event *)ptr)->vdev; + break; + case NDP_RESPONDER_RSP: + vdev = ((struct nan_datapath_responder_rsp *)ptr)->vdev; + break; + case NDP_END_RSP: + vdev = ((struct nan_datapath_end_rsp_event *)ptr)->vdev; + break; + case NDP_END_IND: + vdev = ((struct nan_datapath_end_indication_event *)ptr)->vdev; + break; + default: + break; + } + + if (vdev) + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); + qdf_mem_free(msg->bodyptr); + msg->bodyptr = NULL; + + return QDF_STATUS_SUCCESS; +} + static QDF_STATUS target_if_nan_event_dispatcher(struct scheduler_msg *msg) { QDF_STATUS status; - struct wlan_objmgr_vdev *vdev = NULL; + void *ptr = msg->bodyptr; struct wlan_objmgr_psoc *psoc; + struct wlan_objmgr_vdev *vdev = NULL; 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; + case NDP_INITIATOR_RSP: + vdev = ((struct nan_datapath_initiator_rsp *)ptr)->vdev; break; - } - case NDP_INDICATION: { - struct nan_datapath_indication_event *ind = msg->bodyptr; - vdev = ind->vdev; + case NDP_INDICATION: + vdev = ((struct nan_datapath_indication_event *)ptr)->vdev; break; - } - case NDP_CONFIRM: { - struct nan_datapath_confirm_event *confirm = msg->bodyptr; - vdev = confirm->vdev; + case NDP_CONFIRM: + vdev = ((struct nan_datapath_confirm_event *)ptr)->vdev; break; - } - case NDP_RESPONDER_RSP: { - struct nan_datapath_responder_rsp *rsp = msg->bodyptr; - vdev = rsp->vdev; + case NDP_RESPONDER_RSP: + vdev = ((struct nan_datapath_responder_rsp *)ptr)->vdev; break; - } - case NDP_END_RSP: { - struct nan_datapath_end_rsp_event *rsp = msg->bodyptr; - vdev = rsp->vdev; + case NDP_END_RSP: + vdev = ((struct nan_datapath_end_rsp_event *)ptr)->vdev; break; - } - case NDP_END_IND: { - struct nan_datapath_end_indication_event *rsp = msg->bodyptr; - vdev = rsp->vdev; + case NDP_END_IND: + vdev = ((struct nan_datapath_end_indication_event *)ptr)->vdev; break; - } default: target_if_err("invalid msg type %d", msg->type); - qdf_mem_free(msg->bodyptr); - return QDF_STATUS_E_INVAL; + status = QDF_STATUS_E_INVAL; + goto free_res; } 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; + status = QDF_STATUS_E_NULL_VALUE; + goto free_res; } 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; + status = QDF_STATUS_E_NULL_VALUE; + goto free_res; } 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 = QDF_STATUS_E_NULL_VALUE; + goto free_res; } status = nan_rx_ops->nan_event_rx(msg); - wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); +free_res: + if (vdev) + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); qdf_mem_free(msg->bodyptr); - + msg->bodyptr = NULL; return status; } -static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) +static QDF_STATUS target_if_nan_ndp_initiator_req( + struct nan_datapath_initiator_req *ndp_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 wmi_unified *wmi_handle; struct wlan_objmgr_psoc *psoc; struct scheduler_msg pe_msg = {0}; - wmi_ndp_initiator_req_fixed_param *cmd; - uint32_t passphrase_len, service_name_len; 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."); @@ -149,135 +158,17 @@ static QDF_STATUS target_if_nan_ndp_intiaitor_req(void *req) 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); - passphrase_len = qdf_roundup(ndp_req->passphrase.passphrase_len, 4); - service_name_len = - qdf_roundup(ndp_req->service_name.service_name_len, 4); - /* allocated memory for fixed params as well as variable size data */ - len = sizeof(*cmd) + sizeof(*ch_tlv) + (5 * WMI_TLV_HDR_SIZE) - + ndp_cfg_len + ndp_app_info_len + pmk_len - + passphrase_len + service_name_len; + status = wmi_unified_ndp_initiator_req_cmd_send(wmi_handle, ndp_req); + if (QDF_IS_STATUS_SUCCESS(status)) + return status; - 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; - cmd->nan_passphrase_len = ndp_req->passphrase.passphrase_len; - cmd->nan_servicename_len = ndp_req->service_name.service_name_len; - - 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; - - WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); - qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->passphrase.passphrase, - cmd->nan_passphrase_len); - tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; - - WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); - qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], - ndp_req->service_name.service_name, - cmd->nan_servicename_len); - tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_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("pass phrase len: %d", cmd->nan_passphrase_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - ndp_req->passphrase.passphrase, - cmd->nan_passphrase_len); - - target_if_debug("service name len: %d", cmd->nan_servicename_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - ndp_req->service_name.service_name, - cmd->nan_servicename_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) + if (nan_rx_ops->nan_event_rx) nan_rx_ops->nan_event_rx(&pe_msg); return status; @@ -287,12 +178,10 @@ 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 wmi_unified *wmi_handle; 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; + struct nan_datapath_initiator_rsp *rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -300,36 +189,24 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_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"); - wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); - return -ENOMEM; + status = wmi_extract_ndp_initiator_rsp(wmi_handle, data, &rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); + return -EINVAL; } - 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.type = NDP_INITIATOR_RSP; msg.callback = target_if_nan_event_dispatcher; - - target_if_err("NDP_INITIATOR_RSP sent: %d", msg.type); + msg.flush_callback = target_if_nan_event_flush_cb; + target_if_debug("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); @@ -340,16 +217,13 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, } static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, - uint32_t data_len) + uint32_t data_len) { - int ret; QDF_STATUS status; struct wlan_objmgr_psoc *psoc; - struct wlan_objmgr_vdev *vdev; + struct wmi_unified *wmi_handle; 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; + struct nan_datapath_indication_event *rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -357,121 +231,31 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_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"); - wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); - return -ENOMEM; + status = wmi_extract_ndp_ind(wmi_handle, data, &rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); + return -EINVAL; } - 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.type = NDP_INDICATION; msg.callback = target_if_nan_event_dispatcher; + msg.flush_callback = target_if_nan_event_flush_cb; 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; + qdf_mem_free(rsp); + return -EINVAL; } - 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, @@ -479,11 +263,9 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, { QDF_STATUS status; struct wlan_objmgr_psoc *psoc; - struct wlan_objmgr_vdev *vdev; + struct wmi_unified *wmi_handle; 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; + struct nan_datapath_confirm_event *rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -491,69 +273,26 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + if (!wmi_handle) { + target_if_err("wmi_handle 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); + status = wmi_extract_ndp_confirm(wmi_handle, data, &rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); + return -EINVAL; } - msg.type = NDP_CONFIRM; + msg.bodyptr = rsp; + msg.type = NDP_CONFIRM; msg.callback = target_if_nan_event_dispatcher; - target_if_err("NDP_CONFIRM sent: %d", msg.type); + msg.flush_callback = target_if_nan_event_flush_cb; + target_if_debug("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; } @@ -564,19 +303,12 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, static QDF_STATUS target_if_nan_ndp_responder_req( struct nan_datapath_responder_req *req) { - int ret; - uint16_t len; - wmi_buf_t buf; - uint8_t *tlv_ptr; QDF_STATUS status; - wmi_unified_t wmi_handle; + struct wmi_unified *wmi_handle; struct wlan_objmgr_psoc *psoc; struct scheduler_msg pe_msg = {0}; - wmi_ndp_responder_req_fixed_param *cmd; - uint32_t passphrase_len, service_name_len; struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; struct nan_datapath_responder_rsp rsp = {0}; - uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len; if (!req) { target_if_err("Invalid req."); @@ -601,130 +333,17 @@ static QDF_STATUS target_if_nan_ndp_responder_req( return QDF_STATUS_E_NULL_VALUE; } - vdev_id = wlan_vdev_get_id(req->vdev); - target_if_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d", - vdev_id, req->transaction_id, - req->ndp_rsp, - req->ndp_instance_id, - req->ndp_info.ndp_app_info_len); + status = wmi_unified_ndp_responder_req_cmd_send(wmi_handle, req); + if (QDF_IS_STATUS_SUCCESS(status)) + return status; - /* - * 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(req->ndp_config.ndp_cfg_len, 4); - ndp_app_info_len = qdf_roundup(req->ndp_info.ndp_app_info_len, 4); - pmk_len = qdf_roundup(req->pmk.pmk_len, 4); - passphrase_len = qdf_roundup(req->passphrase.passphrase_len, 4); - service_name_len = - qdf_roundup(req->service_name.service_name_len, 4); - - /* allocated memory for fixed params as well as variable size data */ - len = sizeof(*cmd) + 5*WMI_TLV_HDR_SIZE + ndp_cfg_len + ndp_app_info_len - + pmk_len + passphrase_len + service_name_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_responder_fail; - } - cmd = (wmi_ndp_responder_req_fixed_param *) wmi_buf_data(buf); - WMITLV_SET_HDR(&cmd->tlv_header, - WMITLV_TAG_STRUC_wmi_ndp_responder_req_fixed_param, - WMITLV_GET_STRUCT_TLVLEN( - wmi_ndp_responder_req_fixed_param)); - cmd->vdev_id = vdev_id; - cmd->transaction_id = req->transaction_id; - cmd->ndp_instance_id = req->ndp_instance_id; - cmd->rsp_code = req->ndp_rsp; - cmd->ndp_cfg_len = req->ndp_config.ndp_cfg_len; - cmd->ndp_app_info_len = req->ndp_info.ndp_app_info_len; - cmd->nan_pmk_len = req->pmk.pmk_len; - cmd->nan_csid = req->ncs_sk_type; - cmd->nan_passphrase_len = req->passphrase.passphrase_len; - cmd->nan_servicename_len = req->service_name.service_name_len; - - tlv_ptr = (uint8_t *)&cmd[1]; - WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len); - qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], - 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], - req->ndp_info.ndp_app_info, - req->ndp_info.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], req->pmk.pmk, - cmd->nan_pmk_len); - - tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len; - WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); - qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], - req->passphrase.passphrase, - cmd->nan_passphrase_len); - tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; - - WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); - qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], - req->service_name.service_name, - cmd->nan_servicename_len); - - tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_len; - - target_if_debug("vdev_id = %d, transaction_id: %d, csid: %d", - cmd->vdev_id, cmd->transaction_id, cmd->nan_csid); - - target_if_debug("ndp_config len: %d", - req->ndp_config.ndp_cfg_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - req->ndp_config.ndp_cfg, - req->ndp_config.ndp_cfg_len); - - target_if_debug("ndp_app_info len: %d", - req->ndp_info.ndp_app_info_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - req->ndp_info.ndp_app_info, - 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, - req->pmk.pmk, cmd->nan_pmk_len); - - target_if_debug("pass phrase len: %d", cmd->nan_passphrase_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - req->passphrase.passphrase, - cmd->nan_passphrase_len); - - target_if_debug("service name len: %d", cmd->nan_servicename_len); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG, - req->service_name.service_name, - cmd->nan_servicename_len); - - target_if_debug("sending WMI_NDP_RESPONDER_REQ_CMDID(0x%X)", - WMI_NDP_RESPONDER_REQ_CMDID); - ret = wmi_unified_cmd_send(wmi_handle, buf, len, - WMI_NDP_RESPONDER_REQ_CMDID); - if (ret < 0) { - target_if_err("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d", - ret); - wmi_buf_free(buf); - status = QDF_STATUS_E_FAILURE; - goto send_ndp_responder_fail; - } - return QDF_STATUS_SUCCESS; - -send_ndp_responder_fail: rsp.vdev = req->vdev; rsp.transaction_id = req->transaction_id; rsp.status = NAN_DATAPATH_RSP_STATUS_ERROR; rsp.reason = NAN_DATAPATH_DATA_RESPONDER_REQ_FAILED; pe_msg.bodyptr = &rsp; pe_msg.type = NDP_RESPONDER_RSP; - if (nan_rx_ops && nan_rx_ops->nan_event_rx) + if (nan_rx_ops->nan_event_rx) nan_rx_ops->nan_event_rx(&pe_msg); return status; @@ -735,12 +354,9 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, { QDF_STATUS status; struct wlan_objmgr_psoc *psoc; - struct wlan_objmgr_vdev *vdev; + struct wmi_unified *wmi_handle; struct scheduler_msg msg = {0}; - struct wlan_lmac_if_nan_rx_ops *nan_rx_ops; - struct nan_datapath_responder_rsp *rsp; - WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *event; - wmi_ndp_responder_rsp_event_fixed_param *fixed_params; + struct nan_datapath_responder_rsp *rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -748,49 +364,24 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + if (!wmi_handle) { + target_if_err("wmi_handle is null."); return -EINVAL; } - event = (WMI_NDP_RESPONDER_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"); + status = wmi_extract_ndp_responder_rsp(wmi_handle, data, &rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); 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->reason = fixed_params->reason_code; - rsp->status = fixed_params->rsp_status; - rsp->create_peer = fixed_params->create_peer; - WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr, - rsp->peer_mac_addr.bytes); - - target_if_debug("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: %pM,transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d", - WMI_NDP_RESPONDER_RSP_EVENTID, fixed_params->vdev_id, - rsp->peer_mac_addr.bytes, rsp->transaction_id, - rsp->status, rsp->reason, rsp->create_peer); msg.bodyptr = rsp; msg.type = NDP_RESPONDER_RSP; msg.callback = target_if_nan_event_dispatcher; - + msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("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); @@ -802,16 +393,10 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, 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 wmi_unified *wmi_handle; 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}; @@ -838,50 +423,10 @@ static QDF_STATUS target_if_nan_ndp_end_req(struct nan_datapath_end_req *req) 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); + status = wmi_unified_ndp_end_req_cmd_send(wmi_handle, req); + if (QDF_IS_STATUS_SUCCESS(status)) + return status; - 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; @@ -889,7 +434,7 @@ send_ndp_end_fail: end_rsp.transaction_id = req->transaction_id; msg.bodyptr = &end_rsp; - if (nan_rx_ops && nan_rx_ops->nan_event_rx) + if (nan_rx_ops->nan_event_rx) nan_rx_ops->nan_event_rx(&msg); return status; @@ -898,15 +443,11 @@ send_ndp_end_fail: 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 wmi_unified *wmi_handle; 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; + struct nan_datapath_end_rsp_event *end_rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -914,67 +455,41 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + if (!wmi_handle) { + target_if_err("wmi_handle is null."); 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 = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, QDF_NDI_MODE, - WLAN_NAN_ID); - if (!vdev) { - target_if_err("vdev is null"); + status = wmi_extract_ndp_end_rsp(wmi_handle, data, &end_rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); 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); + msg.flush_callback = target_if_nan_event_flush_cb; + target_if_debug("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; + + return 0; } 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 = {0}; - 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; + struct wmi_unified *wmi_handle; + struct scheduler_msg msg = {0}; + struct nan_datapath_end_indication_event *rsp = NULL; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -982,75 +497,30 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, 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"); + wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + if (!wmi_handle) { + target_if_err("wmi_handle is null."); 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"); + status = wmi_extract_ndp_end_ind(wmi_handle, data, &rsp); + if (QDF_IS_STATUS_ERROR(status)) { + target_if_err("parsing of event failed, %d", status); return -EINVAL; } - vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, QDF_NDI_MODE, - 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.type = NDP_END_IND; msg.callback = target_if_nan_event_dispatcher; - - target_if_err("NDP_END_IND sent: %d", msg.type); + msg.flush_callback = target_if_nan_event_flush_cb; + target_if_debug("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; } @@ -1059,7 +529,7 @@ 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); + target_if_nan_ndp_initiator_req(req); break; case NDP_RESPONDER_REQ: target_if_nan_ndp_responder_req(req); From faa3ce91bb0224cdc96d298373ba349389e1546a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 2 Feb 2018 15:13:05 -0800 Subject: [PATCH 11/18] qcacmn: Fix memory allocation in NDP firmware events Fix memory allocation during NDP firmware events by allocating memory before wmi_extract APIs are called. Change-Id: I3af2f49895a79a45b3add246eeb9025b1df92faa CRs-Fixed: 2183493 --- src/target_if_nan.c | 113 +++++++++++++++++++++++++++++--------------- 1 file changed, 74 insertions(+), 39 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 2f0c8305f5..1470c756b6 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -181,7 +181,7 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, struct wmi_unified *wmi_handle; struct wlan_objmgr_psoc *psoc; struct scheduler_msg msg = {0}; - struct nan_datapath_initiator_rsp *rsp = NULL; + struct nan_datapath_initiator_rsp *rsp; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -195,9 +195,16 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - status = wmi_extract_ndp_initiator_rsp(wmi_handle, data, &rsp); + rsp = qdf_mem_malloc(sizeof(*rsp)); + if (!rsp) { + target_if_err("malloc failed"); + return -ENOMEM; + } + + status = wmi_extract_ndp_initiator_rsp(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; } @@ -209,7 +216,7 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -223,7 +230,7 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, struct wlan_objmgr_psoc *psoc; struct wmi_unified *wmi_handle; struct scheduler_msg msg = {0}; - struct nan_datapath_indication_event *rsp = NULL; + struct nan_datapath_indication_event *rsp; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -237,9 +244,16 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - status = wmi_extract_ndp_ind(wmi_handle, data, &rsp); + rsp = qdf_mem_malloc(sizeof(*rsp)); + if (!rsp) { + target_if_err("malloc failed"); + return -ENOMEM; + } + + status = wmi_extract_ndp_ind(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; } @@ -251,7 +265,7 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -265,7 +279,7 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, struct wlan_objmgr_psoc *psoc; struct wmi_unified *wmi_handle; struct scheduler_msg msg = {0}; - struct nan_datapath_confirm_event *rsp = NULL; + struct nan_datapath_confirm_event *rsp; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -279,9 +293,16 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - status = wmi_extract_ndp_confirm(wmi_handle, data, &rsp); + rsp = qdf_mem_malloc(sizeof(*rsp)); + if (!rsp) { + target_if_err("malloc failed"); + return -ENOMEM; + } + + status = wmi_extract_ndp_confirm(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; } @@ -293,7 +314,7 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -356,7 +377,7 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, struct wlan_objmgr_psoc *psoc; struct wmi_unified *wmi_handle; struct scheduler_msg msg = {0}; - struct nan_datapath_responder_rsp *rsp = NULL; + struct nan_datapath_responder_rsp *rsp; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -370,9 +391,16 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - status = wmi_extract_ndp_responder_rsp(wmi_handle, data, &rsp); + rsp = qdf_mem_malloc(sizeof(*rsp)); + if (!rsp) { + target_if_err("malloc failed"); + return -ENOMEM; + } + + status = wmi_extract_ndp_responder_rsp(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; } @@ -384,7 +412,7 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -447,7 +475,7 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, struct wlan_objmgr_psoc *psoc; struct wmi_unified *wmi_handle; struct scheduler_msg msg = {0}; - struct nan_datapath_end_rsp_event *end_rsp = NULL; + struct nan_datapath_end_rsp_event *end_rsp; psoc = target_if_get_psoc_from_scn_hdl(scn); if (!psoc) { @@ -461,9 +489,16 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - status = wmi_extract_ndp_end_rsp(wmi_handle, data, &end_rsp); + end_rsp = qdf_mem_malloc(sizeof(*end_rsp)); + if (!end_rsp) { + target_if_err("malloc failed"); + return -ENOMEM; + } + + status = wmi_extract_ndp_end_rsp(wmi_handle, data, end_rsp); if (QDF_IS_STATUS_ERROR(status)) { target_if_err("parsing of event failed, %d", status); + qdf_mem_free(end_rsp); return -EINVAL; } @@ -475,7 +510,7 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(end_rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -517,7 +552,7 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, 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); - qdf_mem_free(rsp); + target_if_nan_event_flush_cb(&msg); return -EINVAL; } @@ -649,28 +684,7 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc); ret = wmi_unified_unregister_event_handler(handle, - wmi_ndp_initiator_rsp_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_indication_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_confirm_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_responder_rsp_event_id); + wmi_ndp_end_rsp_event_id); if (ret) { target_if_err("wmi event deregistration failed, ret: %d", ret); status = ret; @@ -684,7 +698,28 @@ QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) } ret = wmi_unified_unregister_event_handler(handle, - wmi_ndp_end_rsp_event_id); + wmi_ndp_responder_rsp_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_confirm_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_indication_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_initiator_rsp_event_id); if (ret) { target_if_err("wmi event deregistration failed, ret: %d", ret); status = ret; From 8e2eb4e4041516ff8b782e2afbe626dbdf1e4190 Mon Sep 17 00:00:00 2001 From: Akshay Kosigi Date: Tue, 6 Feb 2018 16:02:25 +0530 Subject: [PATCH 12/18] qcacmn: Replace void pointers with appropriate/common structure types Void pointer usage may lead to memory corruption due to wrong pointer is typecasted. Hence define structure for all, and modules internally typecasting based on their type Change-Id: I6271ed8aa3f94254fd85f41962f23ea36895154e CRs-Fixed: 2182452 --- src/target_if_nan.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 1470c756b6..570c5dffdf 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -146,7 +146,7 @@ static QDF_STATUS target_if_nan_ndp_initiator_req( return QDF_STATUS_E_INVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return QDF_STATUS_E_INVAL; @@ -189,7 +189,7 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null"); return -EINVAL; @@ -238,7 +238,7 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null"); return -EINVAL; @@ -287,7 +287,7 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null"); return -EINVAL; @@ -342,7 +342,7 @@ static QDF_STATUS target_if_nan_ndp_responder_req( return QDF_STATUS_E_NULL_VALUE; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return QDF_STATUS_E_NULL_VALUE; @@ -385,7 +385,7 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return -EINVAL; @@ -439,7 +439,7 @@ static QDF_STATUS target_if_nan_ndp_end_req(struct nan_datapath_end_req *req) return QDF_STATUS_E_NULL_VALUE; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return QDF_STATUS_E_NULL_VALUE; @@ -483,7 +483,7 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return -EINVAL; @@ -532,7 +532,7 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } - wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_handle = get_wmi_unified_hdl_from_psoc(psoc); if (!wmi_handle) { target_if_err("wmi_handle is null."); return -EINVAL; @@ -614,7 +614,7 @@ 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) { int ret; - wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_unified_t handle = get_wmi_unified_hdl_from_psoc(psoc); ret = wmi_unified_register_event_handler(handle, wmi_ndp_initiator_rsp_event_id, @@ -681,7 +681,7 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) QDF_STATUS target_if_nan_deregister_events(struct wlan_objmgr_psoc *psoc) { int ret, status = 0; - wmi_unified_t handle = GET_WMI_HDL_FROM_PSOC(psoc); + wmi_unified_t handle = get_wmi_unified_hdl_from_psoc(psoc); ret = wmi_unified_unregister_event_handler(handle, wmi_ndp_end_rsp_event_id); From ad053f2b832c900af1965718f4ea7ced9ff4f825 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 9 Jan 2018 17:54:41 -0800 Subject: [PATCH 13/18] 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 --- src/target_if_nan.c | 72 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 570c5dffdf..da883b3422 100644 --- a/src/target_if_nan.c +++ b/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) { From 52d4acd828ed514d9aee2e56d25ebcc3eb968ead Mon Sep 17 00:00:00 2001 From: gaurank kathpalia Date: Tue, 28 Aug 2018 20:03:29 +0530 Subject: [PATCH 14/18] qcacmn: Add src, and dst id support in TARGET-IF In the scheduler_post_message, src_id is now added to know the source module of the msg. the present scheduler doesn't know about the same which is scheduler_post_msg Replace the scheduler_post_msg with scheduler_post_message Change-Id: I24a94a898fc1f8c3c1e2f1faca0ef51aacdb238c CRs-Fixed: 2306016 --- src/target_if_nan.c | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index da883b3422..4d5ca41042 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -219,7 +219,9 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_INITIATOR_RSP sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -268,7 +270,9 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_INDICATION sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -317,7 +321,9 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_CONFIRM sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -415,7 +421,9 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_INITIATOR_RSP sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -513,7 +521,9 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_END_RSP sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -555,7 +565,9 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, msg.callback = target_if_nan_event_dispatcher; msg.flush_callback = target_if_nan_event_flush_cb; target_if_debug("NDP_END_IND sent: %d", msg.type); - status = scheduler_post_msg(QDF_MODULE_ID_TARGET_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); @@ -604,7 +616,9 @@ static int target_if_ndp_sch_update_handler(ol_scn_t scn, uint8_t *data, 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); + status = scheduler_post_message(QDF_MODULE_ID_TARGET_IF, + QDF_MODULE_ID_TARGET_IF, + 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); From 1d96b30a990115d3ca7acb4057e29e6548eca4b1 Mon Sep 17 00:00:00 2001 From: Jingxiang Ge Date: Fri, 21 Sep 2018 15:46:20 +0800 Subject: [PATCH 15/18] qcacmn: Fix kw issue in target_if_nan_register_events Potential NULL pointer dereference of handle in target_if_nan_register_events. Add null check in the function. Change-Id: I1fc57d712713bc47345b178c972cc5fc926a42d0 CRs-Fixed: 2317017 --- src/target_if_nan.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 4d5ca41042..0cf64e449e 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -685,6 +685,10 @@ QDF_STATUS target_if_nan_register_events(struct wlan_objmgr_psoc *psoc) int ret; wmi_unified_t handle = get_wmi_unified_hdl_from_psoc(psoc); + if (!handle) { + target_if_err("handle is NULL"); + return QDF_STATUS_E_FAILURE; + } ret = wmi_unified_register_event_handler(handle, wmi_ndp_initiator_rsp_event_id, target_if_ndp_initiator_rsp_handler, From e629ac049c0b4a8e309353f3cfcf32da391f66a4 Mon Sep 17 00:00:00 2001 From: Tushnim Bhattacharyya Date: Wed, 26 Sep 2018 13:23:17 -0700 Subject: [PATCH 16/18] qcacmn: Fix kw issue in target_if_nan_deregister_events Potential NULL pointer dereference of handle in target_if_nan_deregister_events. Add null check in the function. Change-Id: Ie30720b525c457e6c805bd0d212044be9270bd53 CRs-Fixed: 2323349 --- src/target_if_nan.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 0cf64e449e..99d707cb01 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -766,6 +766,10 @@ 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); + if (!handle) { + target_if_err("handle is NULL"); + return QDF_STATUS_E_FAILURE; + } ret = wmi_unified_unregister_event_handler(handle, wmi_ndl_schedule_update_event_id); if (ret) { From 71fb6bc49d8309a42e06b675322bef0a2ae4d007 Mon Sep 17 00:00:00 2001 From: Yeshwanth Sriram Guntuka Date: Thu, 20 Sep 2018 16:59:00 +0530 Subject: [PATCH 17/18] qcacmn: Release vdev ref in os_if_ndp_end_ind_handler NAN vdev ref count incremented as part of end_ind handler is not released which will result in the nan vdev not getting physically deleted. Fix is to release nan vdev ref in os_if_ndp_end_ind_handler. Change-Id: I31a32fa241fb9e86d3a64d490722bc42905970c4 CRs-Fixed: 2325580 --- src/target_if_nan.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/target_if_nan.c b/src/target_if_nan.c index 99d707cb01..abb5eec245 100644 --- a/src/target_if_nan.c +++ b/src/target_if_nan.c @@ -560,6 +560,14 @@ static int target_if_ndp_end_ind_handler(ol_scn_t scn, uint8_t *data, return -EINVAL; } + rsp->vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc( + wmi_handle->soc->wmi_psoc, QDF_NDI_MODE, WLAN_NAN_ID); + if (!rsp->vdev) { + target_if_err("vdev is null"); + qdf_mem_free(rsp); + return -EINVAL; + } + msg.bodyptr = rsp; msg.type = NDP_END_IND; msg.callback = target_if_nan_event_dispatcher; From 9c774fa650c9a6c805e92c2072db339b91bfd1f2 Mon Sep 17 00:00:00 2001 From: Linux Build Service Account Date: Tue, 13 Nov 2018 16:22:31 +0530 Subject: [PATCH 18/18] qcacld-3.0: Merge NAN related Target IF files into CLD NAN component is not needed in the CMN repo. To reduce the unnecessary lines of code, merge the NAN related Target IF files from CMN into CLD. Subsequently remove these files from the CMN repo. Merge NAN related Target IF files from CMN into CLD. Change-Id: I02475f1e1a3a90280bb9da0f131ba34bb189f5b3 --- {inc => components/target_if/nan/inc}/target_if_nan.h | 2 +- {src => components/target_if/nan/src}/target_if_nan.c | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename {inc => components/target_if/nan/inc}/target_if_nan.h (97%) rename {src => components/target_if/nan/src}/target_if_nan.c (100%) diff --git a/inc/target_if_nan.h b/components/target_if/nan/inc/target_if_nan.h similarity index 97% rename from inc/target_if_nan.h rename to components/target_if/nan/inc/target_if_nan.h index 2563efae7d..45109e3869 100644 --- a/inc/target_if_nan.h +++ b/components/target_if/nan/inc/target_if_nan.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the diff --git a/src/target_if_nan.c b/components/target_if/nan/src/target_if_nan.c similarity index 100% rename from src/target_if_nan.c rename to components/target_if/nan/src/target_if_nan.c