From b0b838e6d5b2310ecf1d6a1ca534b0c1244a2eb6 Mon Sep 17 00:00:00 2001 From: Prakash Dhavali Date: Thu, 25 Feb 2016 23:29:32 -0800 Subject: [PATCH 01/92] Merge remote-tracking branch 'origin/caf/caf-wlan/master' into wlan-cmn.driver.lnx.1.0-dev Sync-up wlan-cmn.driver.lnx.1.0-dev branch to caf master version of host-common driver that is exactly same as qcacld-3.0 driver version 5.0.0.149 * origin/caf/caf-wlan/master: (294 commits) qcacld-3.0: Lower the log level for unhandled Action frame logs qcacld-3.0: Add disconnect to the head of sme pending command list Release 5.0.0.149 QCACLD3 WLAN Driver qcacld-3.0: Enable emergency reaping for wmi pipe. qcacld-3.0: add retry logic if htc_issue_packets fails qcacld-3.0: Ignore HTT_T2H_MSG_TYPE_MGMT_TX_COMPL_IND from FW qcacld-3.0: Do not reserve mgmt descriptors qcacld-3.0: Use appropriate list API qcacld-3.0: Remove per vdev tx descriptor pool qcacld-3.0: Enable enahnced flow control qcacld-3.0: Add support for telescopic PNO ... Release 5.0.0.140 ... Initial readme for WLAN Host Driver for iHelium Change-Id: I36e7222946f442159390bd78a65ee5dc6876b582 CRs-Fixed: 688141 From 1226de9d0683dd55ae41c2207614fc105a436d2c Mon Sep 17 00:00:00 2001 From: Prakash Dhavali Date: Tue, 1 Mar 2016 09:05:38 -0800 Subject: [PATCH 02/92] Merge commit '0219ae6' into wlan-cmn.driver.lnx.1.0-dev Sync up wlan-cmn.driver.lnx.1.0-dev to CAF 5.0.0.160 from 5.0.0.149 release as baseline for subsequent win and mcl convergence refactoring. * commit '0219ae6': (554 commits) Release 5.0.0.160 qcacld-3.0: Add wma handler for vdev delete and peer delete responses Release 5.0.0.159 qcacld-3.0: Fix Compilation error on WLAN_FEATURE_11W disabled qcacld-3.0: Update channel width and center freq qcacld-3.0: Move sta state to not connected after try disconnect qcacld-3.0: Remove #ifdef FEATURE_WLAN_LFR from HDD qcacld-3.0: Remove RRM ie in Assoc Req based on AP capability qcacld-3.0: Fix fw statistics parsing on the host qcacld-3.0: Fix IPA-uc callback in NON-SMP system qcacld-3.0: SAP DFS-3 Feature support in DFS layer qcacld-3.0: SAP DFS-3 Feature support in WMA qcacld-3.0: correct phy_mode in hdd_chan_change_notify qcacld-3.0: move hif_bus_open to hif_open qcacld-3.0: Remove hif_claim_device qcacld-3.0: Remove epping context from cds qcacld-3.0: Enable Tx beamformee in SAP mode qcacld-3.0: Set the IMPS enable/disable based on INI qcacld-3.0: Fix memory leak in case of fw reset stats command qcacld-3.0: Use appropriate API to get total free descriptors ... qcacld-3.0: Enable athdiag debug support for SNOC devices qcacld-3.0: Remove support of power gating parameters qcacld-3.0: Add log in vos_mem_alloc if kzalloc takes more than 3 seconds Change-Id: I903d2b6edfb715570daffbcfcdb46866f04737dc CRs-Fixed: 688141 From c3226ef1d06e28143400436f477e4709f7c0bb10 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 15 Dec 2016 12:44:14 -0800 Subject: [PATCH 03/92] qcacmn: Add new files for new NAN component Add new files for new NAN component. Change-Id: I817723e518d53e9348d817746fc8318171d6ddf3 CRs-Fixed: 2014795 --- core/inc/nan_public_structs.h | 26 ++++++++++++++++++++++++++ core/inc/wlan_nan_api.h | 26 ++++++++++++++++++++++++++ core/src/nan_api.c | 21 +++++++++++++++++++++ core/src/nan_main.c | 21 +++++++++++++++++++++ core/src/nan_utils.c | 22 ++++++++++++++++++++++ core/src/nan_utils_i.h | 26 ++++++++++++++++++++++++++ dispatcher/inc/nan_ucfg_api.h | 21 +++++++++++++++++++++ dispatcher/src/nan_ucfg_api.c | 22 ++++++++++++++++++++++ 8 files changed, 185 insertions(+) create mode 100644 core/inc/nan_public_structs.h create mode 100644 core/inc/wlan_nan_api.h create mode 100644 core/src/nan_api.c create mode 100644 core/src/nan_main.c create mode 100644 core/src/nan_utils.c create mode 100644 core/src/nan_utils_i.h create mode 100644 dispatcher/inc/nan_ucfg_api.h create mode 100644 dispatcher/src/nan_ucfg_api.c diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h new file mode 100644 index 000000000000..72701bbfc8c6 --- /dev/null +++ b/core/inc/nan_public_structs.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 definitions exposed to other modules + */ + +#ifndef _NAN_PUBLIC_STRUCTS_H_ +#define _NAN_PUBLIC_STRUCTS_H_ + +#endif diff --git a/core/inc/wlan_nan_api.h b/core/inc/wlan_nan_api.h new file mode 100644 index 000000000000..da75dd69e089 --- /dev/null +++ b/core/inc/wlan_nan_api.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 definitions exposed to other modules + */ + +#ifndef _WLAN_NAN_API_H_ +#define _WLAN_NAN_API_H_ + +#endif diff --git a/core/src/nan_api.c b/core/src/nan_api.c new file mode 100644 index 000000000000..4a66917b6960 --- /dev/null +++ b/core/src/nan_api.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 public API function definitions + */ diff --git a/core/src/nan_main.c b/core/src/nan_main.c new file mode 100644 index 000000000000..f9680ddb695f --- /dev/null +++ b/core/src/nan_main.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 core nan function definitions + */ diff --git a/core/src/nan_utils.c b/core/src/nan_utils.c new file mode 100644 index 000000000000..69b8daf1875e --- /dev/null +++ b/core/src/nan_utils.c @@ -0,0 +1,22 @@ +/* + * 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 utility functions + */ + diff --git a/core/src/nan_utils_i.h b/core/src/nan_utils_i.h new file mode 100644 index 000000000000..e405374520b9 --- /dev/null +++ b/core/src/nan_utils_i.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2012-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 declaration of common utility APIs to be used in NAN modules + */ + +#ifndef _WLAN_NAN_UTILS_H_ +#define _WLAN_NAN_UTILS_H_ + +#endif diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h new file mode 100644 index 000000000000..1b346459aa8f --- /dev/null +++ b/dispatcher/inc/nan_ucfg_api.h @@ -0,0 +1,21 @@ +/* + * 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 interface prototypes for OS_IF layer + */ diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c new file mode 100644 index 000000000000..c1945666b24b --- /dev/null +++ b/dispatcher/src/nan_ucfg_api.c @@ -0,0 +1,22 @@ +/* + * 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 interface definitions for OS_IF layer + */ + From aeeb03b4b258c3e514156822b753a3d9753e790e Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 15 Dec 2016 12:44:14 -0800 Subject: [PATCH 04/92] qcacmn: Add new files for new NAN component Add new files for new NAN component. Change-Id: I817723e518d53e9348d817746fc8318171d6ddf3 CRs-Fixed: 2014795 --- inc/os_if_nan.h | 26 ++++++++++++++++++++++++++ src/os_if_nan.c | 22 ++++++++++++++++++++++ 2 files changed, 48 insertions(+) create mode 100644 inc/os_if_nan.h create mode 100644 src/os_if_nan.c diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h new file mode 100644 index 000000000000..41207a46352f --- /dev/null +++ b/inc/os_if_nan.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2012-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: declares nan component os interface APIs + */ + +#ifndef _OS_IF_NAN_H_ +#define _OS_IF_NAN_H_ + +#endif diff --git a/src/os_if_nan.c b/src/os_if_nan.c new file mode 100644 index 000000000000..3ee4c4706966 --- /dev/null +++ b/src/os_if_nan.c @@ -0,0 +1,22 @@ +/* + * 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: defines nan component os interface APIs + */ + From 2b4f9310f8021584a1993ebc3dfa2b82df8fd3e6 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 15 Dec 2016 12:44:14 -0800 Subject: [PATCH 05/92] 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 000000000000..fa96ba83d3ed --- /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 000000000000..3e46ca711d4f --- /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 398c8df7f37eb56c69d3667f381b3f09165b05cd Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 30 Mar 2017 20:20:14 -0700 Subject: [PATCH 06/92] qcacmn: Rename nan_utils_i.h to nan_main_i.h Rename nan_utils_i.h to nan_main_i.h, because it is supposed to contain few internal structures along with apis Change-Id: I77e44c362f2a36c5b17bcaa62cb2f2124abf0245 CRs-Fixed: 2014795 --- core/src/{nan_utils_i.h => nan_main_i.h} | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) rename core/src/{nan_utils_i.h => nan_main_i.h} (84%) diff --git a/core/src/nan_utils_i.h b/core/src/nan_main_i.h similarity index 84% rename from core/src/nan_utils_i.h rename to core/src/nan_main_i.h index e405374520b9..b6a78d06e5ef 100644 --- a/core/src/nan_utils_i.h +++ b/core/src/nan_main_i.h @@ -17,10 +17,11 @@ */ /** - * DOC: contains declaration of common utility APIs to be used in NAN modules + * DOC: contains declaration of common utility APIs and private structs to be + * used in NAN modules */ -#ifndef _WLAN_NAN_UTILS_H_ -#define _WLAN_NAN_UTILS_H_ +#ifndef _WLAN_NAN_MAIN_I_H_ +#define _WLAN_NAN_MAIN_I_H_ #endif From 4fa5c8fddd50fdd05a272f92e77b5f2386f969c2 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 21 Mar 2017 15:12:22 -0700 Subject: [PATCH 07/92] qcacmn: Define NDP structures and enums and private obj 1) Define NDP structures and enum. 2) Define PSOC and VDEV private object Change-Id: I3cb3c0e357f8b4598a0e4ec8abbd5b69e5de5180 CRs-Fixed: 2014795 --- core/inc/nan_public_structs.h | 464 ++++++++++++++++++++++++++++++++++ core/src/nan_main_i.h | 64 +++++ 2 files changed, 528 insertions(+) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 72701bbfc8c6..188dc82c724b 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -20,7 +20,471 @@ * DOC: contains nan definitions exposed to other modules */ +#ifdef WLAN_FEATURE_NAN_CONVERGENCE #ifndef _NAN_PUBLIC_STRUCTS_H_ #define _NAN_PUBLIC_STRUCTS_H_ +#include "qdf_types.h" +#include "qdf_status.h" + +struct wlan_objmgr_psoc; +struct wlan_objmgr_vdev; + +#define IFACE_NAME_SIZE 64 + +#define NAN_DATAPATH_INF_CREATE_REQ 0 +#define NAN_DATAPATH_INF_CREATE_RSP 1 +#define NAN_DATAPATH_INF_DELETE_REQ 2 +#define NAN_DATAPATH_INF_DELETE_RSP 3 +#define NDP_INITIATOR_REQ 4 +#define NDP_INITIATOR_RSP 5 +#define NDP_RESPONDER_REQ 6 +#define NDP_RESPONDER_RSP 7 +#define NDP_END_REQ 8 +#define NDP_END_RSP 9 +#define NDP_INDICATION 10 +#define NDP_CONFIRM 11 +#define NDP_END_IND 12 +#define NDP_NEW_PEER 13 +#define NDP_PEER_DEPARTED 14 + +/** + * enum nan_datapath_status_type - NDP status type + * @NAN_DATAPATH_RSP_STATUS_SUCCESS: request was successful + * @NAN_DATAPATH_RSP_STATUS_ERROR: request failed + */ +enum nan_datapath_status_type { + NAN_DATAPATH_RSP_STATUS_SUCCESS = 0x00, + NAN_DATAPATH_RSP_STATUS_ERROR = 0x01, +}; + +/** + * enum nan_datapath_reason_code - NDP command rsp reason code value + * @NDP_UNSUPPORTED_CONCURRENCY: Will be used in unsupported concurrency cases + * @NDP_NAN_DATA_IFACE_CREATE_FAILED: ndi create failed + * @NDP_NAN_DATA_IFACE_DELETE_FAILED: ndi delete failed + * @NDP_DATA_INITIATOR_REQ_FAILED: data initiator request failed + * @NDP_DATA_RESPONDER_REQ_FAILED: data responder request failed + * @NDP_INVALID_SERVICE_INSTANCE_ID: invalid service instance id + * @NDP_INVALID_NDP_INSTANCE_ID: invalid ndp instance id + * @NDP_INVALID_RSP_CODE: invalid response code in ndp responder request + * @NDP_INVALID_APP_INFO_LEN: invalid app info length + * @NDP_NMF_REQ_FAIL: OTA nan mgmt frame failure for data request + * @NDP_NMF_RSP_FAIL: OTA nan mgmt frame failure for data response + * @NDP_NMF_CNF_FAIL: OTA nan mgmt frame failure for confirm + * @NDP_END_FAILED: ndp end failed + * @NDP_NMF_END_REQ_FAIL: OTA nan mgmt frame failure for data end + * @NDP_VENDOR_SPECIFIC_ERROR: other vendor specific failures + */ +enum nan_datapath_reason_code { + NAN_DATAPATH_UNSUPPORTED_CONCURRENCY = 9000, + NAN_DATAPATH_NAN_DATA_IFACE_CREATE_FAILED = 9001, + NAN_DATAPATH_NAN_DATA_IFACE_DELETE_FAILED = 9002, + NAN_DATAPATH_DATA_INITIATOR_REQ_FAILED = 9003, + NAN_DATAPATH_DATA_RESPONDER_REQ_FAILED = 9004, + NAN_DATAPATH_INVALID_SERVICE_INSTANCE_ID = 9005, + NAN_DATAPATH_INVALID_NDP_INSTANCE_ID = 9006, + NAN_DATAPATH_INVALID_RSP_CODE = 9007, + NAN_DATAPATH_INVALID_APP_INFO_LEN = 9008, + NAN_DATAPATH_NMF_REQ_FAIL = 9009, + NAN_DATAPATH_NMF_RSP_FAIL = 9010, + NAN_DATAPATH_NMF_CNF_FAIL = 9011, + NAN_DATAPATH_END_FAILED = 9012, + NAN_DATAPATH_NMF_END_REQ_FAIL = 9013, + /* 9500 onwards vendor specific error codes */ + NAN_DATAPATH_VENDOR_SPECIFIC_ERROR = 9500, +}; + +/** + * enum nan_datapath_response_code - responder's response code to nan data path + * request + * @NAN_DATAPATH_RESPONSE_ACCEPT: ndp request accepted + * @NAN_DATAPATH_RESPONSE_REJECT: ndp request rejected + * @NAN_DATAPATH_RESPONSE_DEFER: ndp request deferred until later (response to + * follow any time later) + * + */ +enum nan_datapath_response_code { + NAN_DATAPATH_RESPONSE_ACCEPT = 0, + NAN_DATAPATH_RESPONSE_REJECT = 1, + NAN_DATAPATH_RESPONSE_DEFER = 2, +}; + +/** + * enum nan_datapath_accept_policy - nan data path accept policy + * @NAN_DATAPATH_ACCEPT_POLICY_NONE: the framework will decide the policy + * @NAN_DATAPATH_ACCEPT_POLICY_ALL: accept policy offloaded to fw + * + */ +enum nan_datapath_accept_policy { + NAN_DATAPATH_ACCEPT_POLICY_NONE = 0, + NAN_DATAPATH_ACCEPT_POLICY_ALL = 1, +}; + +/** + * enum nan_datapath_self_role - nan data path role + * @NAN_DATAPATH_ROLE_INITIATOR: initiator of nan data path request + * @NAN_DATAPATH_ROLE_RESPONDER: responder to nan data path request + * + */ +enum nan_datapath_self_role { + NAN_DATAPATH_ROLE_INITIATOR = 0, + NAN_DATAPATH_ROLE_RESPONDER = 1, +}; + +/** + * enum nan_datapath_end_type - NDP end type + * @NAN_DATAPATH_END_TYPE_UNSPECIFIED: type is unspecified + * @NAN_DATAPATH_END_TYPE_PEER_UNAVAILABLE: type is peer unavailable + * @NAN_DATAPATH_END_TYPE_OTA_FRAME: NDP end frame received from peer + * + */ +enum nan_datapath_end_type { + NAN_DATAPATH_END_TYPE_UNSPECIFIED = 0x00, + NAN_DATAPATH_END_TYPE_PEER_UNAVAILABLE = 0x01, + NAN_DATAPATH_END_TYPE_OTA_FRAME = 0x02, +}; + +/** + * enum nan_datapath_end_reason_code - NDP end reason code + * @NAN_DATAPATH_END_REASON_UNSPECIFIED: reason is unspecified + * @NAN_DATAPATH_END_REASON_INACTIVITY: reason is peer inactivity + * @NAN_DATAPATH_END_REASON_PEER_DATA_END: data end indication received from + * peer + * + */ +enum nan_datapath_end_reason_code { + NAN_DATAPATH_END_REASON_UNSPECIFIED = 0x00, + NAN_DATAPATH_END_REASON_INACTIVITY = 0x01, + NAN_DATAPATH_END_REASON_PEER_DATA_END = 0x02, +}; + +/** enum nan_datapath_state - NAN datapath states + * @NAN_DATA_NDI_CREATING_STATE: NDI create is in progress + * @NAN_DATA_NDI_CREATED_STATE: NDI successfully crated + * @NAN_DATA_NDI_DELETING_STATE: NDI delete is in progress + * @NAN_DATA_NDI_DELETED_STATE: NDI delete is in progress + * @NAN_DATA_PEER_CREATE_STATE: Peer create is in progress + * @NAN_DATA_PEER_DELETE_STATE: Peer delete is in progrss + * @NAN_DATA_CONNECTING_STATE: Data connection in progress + * @NAN_DATA_CONNECTED_STATE: Data connection successful + * @NAN_DATA_END_STATE: NDP end is in progress + * @NAN_DATA_DISCONNECTED_STATE: NDP is in disconnected state + */ +enum nan_datapath_state { + NAN_DATA_INVALID_STATE = -1, + NAN_DATA_NDI_CREATING_STATE = 0, + NAN_DATA_NDI_CREATED_STATE = 1, + NAN_DATA_NDI_DELETING_STATE = 2, + NAN_DATA_NDI_DELETED_STATE = 3, + NAN_DATA_PEER_CREATE_STATE = 4, + NAN_DATA_PEER_DELETE_STATE = 5, + NAN_DATA_CONNECTING_STATE = 6, + NAN_DATA_CONNECTED_STATE = 7, + NAN_DATA_END_STATE = 8, + NAN_DATA_DISCONNECTED_STATE = 9, +}; + +/** + * struct nan_datapath_app_info - application info shared during ndp setup + * @ndp_app_info_len: ndp app info length + * @ndp_app_info: variable length application information + * + */ +struct nan_datapath_app_info { + uint32_t ndp_app_info_len; + uint8_t *ndp_app_info; +}; + +/** + * struct nan_datapath_cfg - ndp configuration + * @ndp_cfg_len: ndp configuration length + * @ndp_cfg: variable length ndp configuration + * + */ +struct nan_datapath_cfg { + uint32_t ndp_cfg_len; + uint8_t *ndp_cfg; +}; + +/** + * struct nan_datapath_pmk - structure to hold pairwise master key + * @pmk_len: length of pairwise master key + * @pmk: buffer containing pairwise master key + * + */ +struct nan_datapath_pmk { + uint32_t pmk_len; + uint8_t *pmk; +}; + +/** + * struct nan_datapath_scid - structure to hold sceurity context identifier + * @scid_len: length of scid + * @scid: scid + * + */ +struct nan_datapath_scid { + uint32_t scid_len; + uint8_t *scid; +}; + +/** + * struct peer_nan_datapath_map - mapping of NDP instances to peer to VDEV + * @vdev_id: session id of the interface over which ndp is being created + * @peer_ndi_mac_addr: peer NDI mac address + * @num_active_ndp_sessions: number of active NDP sessions on the peer + * @type: NDP end indication type + * @reason_code: NDP end indication reason code + * @ndp_instance_id: NDP instance ID + * + */ +struct peer_nan_datapath_map { + uint32_t vdev_id; + struct qdf_mac_addr peer_ndi_mac_addr; + uint32_t num_active_ndp_sessions; + enum nan_datapath_end_type type; + enum nan_datapath_end_reason_code reason_code; + uint32_t ndp_instance_id; +}; + +/** + * struct nan_datapath_inf_create_req - ndi create request params + * @transaction_id: unique identifier + * @iface_name: interface name + * + */ +struct nan_datapath_inf_create_req { + uint32_t transaction_id; + char iface_name[IFACE_NAME_SIZE]; +}; + +/* + * struct nan_datapath_inf_create_rsp - ndi create response params + * @status: request status + * @reason: reason if any + * + */ +struct nan_datapath_inf_create_rsp { + uint32_t status; + uint32_t reason; + uint8_t sta_id; +}; + +/** + * struct nan_datapath_inf_delete_rsp - ndi delete response params + * @status: request status + * @reason: reason if any + * + */ +struct nan_datapath_inf_delete_rsp { + uint32_t status; + uint32_t reason; +}; + +/** + * struct nan_datapath_initiator_req - ndp initiator request params + * @transaction_id: unique identifier + * @vdev_id: session id of the interface over which ndp is being created + * @channel: suggested channel for ndp creation + * @channel_cfg: channel config, 0=no channel, 1=optional, 2=mandatory + * @service_instance_id: Service identifier + * @peer_discovery_mac_addr: Peer's discovery mac address + * @self_ndi_mac_addr: self NDI mac address + * @ndp_config: ndp configuration params + * @ndp_info: ndp application info + * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 + * @pmk: pairwise master key + * + */ +struct nan_datapath_initiator_req { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t channel; + uint32_t channel_cfg; + uint32_t service_instance_id; + uint32_t ncs_sk_type; + struct qdf_mac_addr peer_discovery_mac_addr; + struct qdf_mac_addr self_ndi_mac_addr; + struct nan_datapath_cfg ndp_config; + struct nan_datapath_app_info ndp_info; + struct nan_datapath_pmk pmk; +}; + +/** + * struct nan_datapath_initiator_rsp - response event from FW + * @transaction_id: unique identifier + * @vdev_id: session id of the interface over which ndp is being created + * @ndp_instance_id: locally created NDP instance ID + * @status: status of the ndp request + * @reason: reason for failure if any + * + */ +struct nan_datapath_initiator_rsp { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t ndp_instance_id; + uint32_t status; + uint32_t reason; +}; + +/** + * struct nan_datapath_responder_req - responder's response to ndp create + * request + * @transaction_id: unique identifier + * @vdev_id: session id of the interface over which ndp is being created + * @ndp_instance_id: locally created NDP instance ID + * @ndp_rsp: response to the ndp create request + * @ndp_config: ndp configuration params + * @ndp_info: ndp application info + * @pmk: pairwise master key + * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 + * + */ +struct nan_datapath_responder_req { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t ndp_instance_id; + enum nan_datapath_response_code ndp_rsp; + struct nan_datapath_cfg ndp_config; + struct nan_datapath_app_info ndp_info; + struct nan_datapath_pmk pmk; + uint32_t ncs_sk_type; +}; + +/** + * struct nan_datapath_responder_rsp - response to responder's request + * @transaction_id: unique identifier + * @vdev_id: session id of the interface over which ndp is being created + * @status: command status + * @reason: reason for failure if any + * @peer_mac_addr: Peer's mac address + * @create_peer: Flag to indicate to create peer + */ +struct nan_datapath_responder_rsp { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t status; + uint32_t reason; + struct qdf_mac_addr peer_mac_addr; + bool create_peer; +}; + +/** + * struct nan_datapath_end_req - ndp end request + * @transaction_id: unique transaction identifier + * @num_ndp_instances: number of ndp instances to be terminated + * @ndp_ids: pointer to array of ndp_instance_id to be terminated + * + */ +struct nan_datapath_end_req { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t num_ndp_instances; + uint32_t *ndp_ids; +}; + +/** + * struct nan_datapath_end_rsp_event - firmware response to ndp end request + * @transaction_id: unique identifier for the request + * @status: status of operation + * @reason: reason(opaque to host driver) + * + */ +struct nan_datapath_end_rsp_event { + struct wlan_objmgr_vdev *vdev; + uint32_t transaction_id; + uint32_t status; + uint32_t reason; +}; + +/** + * struct nan_datapath_end_indication_event - ndp termination notification from + * FW + * @num_ndp_ids: number of NDP ids + * @ndp_map: mapping of NDP instances to peer and vdev + * + */ +struct nan_datapath_end_indication_event { + struct wlan_objmgr_vdev *vdev; + uint32_t num_ndp_ids; + struct peer_nan_datapath_map ndp_map[]; +}; + +/** + * struct nan_datapath_confirm_event - ndp confirmation event from FW + * @vdev_id: session id of the interface over which ndp is being created + * @ndp_instance_id: ndp instance id for which confirm is being generated + * @reason_code : reason code(opaque to driver) + * @num_active_ndps_on_peer: number of ndp instances on peer + * @peer_ndi_mac_addr: peer NDI mac address + * @rsp_code: ndp response code + * @ndp_info: ndp application info + * + */ +struct nan_datapath_confirm_event { + struct wlan_objmgr_vdev *vdev; + uint32_t ndp_instance_id; + uint32_t reason_code; + uint32_t num_active_ndps_on_peer; + struct qdf_mac_addr peer_ndi_mac_addr; + enum nan_datapath_response_code rsp_code; + struct nan_datapath_app_info ndp_info; +}; + +/** + * struct nan_datapath_indication_event - create ndp indication on the responder + * @vdev_id: session id of the interface over which ndp is being created + * @service_instance_id: Service identifier + * @peer_discovery_mac_addr: Peer's discovery mac address + * @peer_mac_addr: Peer's NDI mac address + * @ndp_initiator_mac_addr: NDI mac address of the peer initiating NDP + * @ndp_instance_id: locally created NDP instance ID + * @role: self role for NDP + * @ndp_accept_policy: accept policy configured by the upper layer + * @ndp_config: ndp configuration params + * @ndp_info: ndp application info + * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 + * @scid: security context identifier + * + */ +struct nan_datapath_indication_event { + struct wlan_objmgr_vdev *vdev; + uint32_t service_instance_id; + struct qdf_mac_addr peer_discovery_mac_addr; + struct qdf_mac_addr peer_mac_addr; + uint32_t ndp_instance_id; + enum nan_datapath_self_role role; + enum nan_datapath_accept_policy policy; + struct nan_datapath_cfg ndp_config; + struct nan_datapath_app_info ndp_info; + uint32_t ncs_sk_type; + struct nan_datapath_scid scid; +}; + +/** + * struct nan_datapath_peer_ind - ndp peer indication + * @session_id: session id + * @peer_mac_addr: peer mac address + * @sta_id: station id + * + */ +struct nan_datapath_peer_ind { + uint8_t session_id; + struct qdf_mac_addr peer_mac_addr; + uint16_t sta_id; +}; + +/** + * struct nan_callbacks - struct containing callback to non-converged driver + * + */ +struct nan_callbacks { + /* callback to os_if layer from umac */ + void (*os_if_event_handler)(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg); +}; + #endif +#endif /* WLAN_FEATURE_NAN_CONVERGENCE */ diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index b6a78d06e5ef..e16770619c4f 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -24,4 +24,68 @@ #ifndef _WLAN_NAN_MAIN_I_H_ #define _WLAN_NAN_MAIN_I_H_ +#include "qdf_types.h" +#include "qdf_status.h" +#include "nan_public_structs.h" +#include "wlan_objmgr_cmn.h" + +struct wlan_objmgr_vdev; +struct wlan_objmgr_psoc; +struct scheduler_msg; + +#define nan_log(level, args...) \ + QDF_TRACE(QDF_MODULE_ID_NAN, level, ## args) +#define nan_logfl(level, format, args...) \ + nan_log(level, FL(format), ## args) + +#define nan_alert(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_FATAL, format, ## args) +#define nan_err(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_ERROR, format, ## args) +#define nan_warn(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_WARN, format, ## args) +#define nan_notice(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_INFO, format, ## args) +#define nan_info(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_INFO_HIGH, format, ## args) +#define nan_debug(format, args...) \ + nan_logfl(QDF_TRACE_LEVEL_DEBUG, format, ## args) + +#ifndef MAX_PEERS +#define MAX_PEERS 32 +#endif + +/** + * struct nan_psoc_priv_obj - nan private psoc obj + * @lock: lock to be acquired before reading or writing to object + * @cb_obj: struct contaning callback pointers + */ +struct nan_psoc_priv_obj { + qdf_spinlock_t lock; + struct nan_callbacks cb_obj; +}; + +/** + * struct nan_vdev_priv_obj - nan private vdev obj + * @lock: lock to be acquired before reading or writing to object + * @state: Current state of NDP + * @active_ndp_sessions: active ndp sessions per adapter + * @active_ndp_peers: number of active ndp peers + * @ndp_create_transaction_id: transaction id for create req + * @ndp_delete_transaction_id: transaction id for delete req + * @ndi_delete_rsp_reason: reason code for ndi_delete rsp + * @ndi_delete_rsp_status: status for ndi_delete rsp + */ +struct nan_vdev_priv_obj { + qdf_spinlock_t lock; + enum nan_datapath_state state; + /* idx in following array should follow conn_info.peerMacAddress */ + uint32_t active_ndp_sessions[MAX_PEERS]; + uint32_t active_ndp_peers; + uint16_t ndp_create_transaction_id; + uint16_t ndp_delete_transaction_id; + uint32_t ndi_delete_rsp_reason; + uint32_t ndi_delete_rsp_status; +}; + #endif From 74b2eb34fc6d30448b9c1f8c0ecc0e4c6fec4ee0 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 21 Mar 2017 15:12:22 -0700 Subject: [PATCH 08/92] qcacmn: Define NDP structures and enums and private obj 1) Define NDP structures and enum. 2) Define PSOC and VDEV private object Change-Id: I3cb3c0e357f8b4598a0e4ec8abbd5b69e5de5180 CRs-Fixed: 2014795 --- inc/os_if_nan.h | 91 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 41207a46352f..3843abacfa52 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -23,4 +23,95 @@ #ifndef _OS_IF_NAN_H_ #define _OS_IF_NAN_H_ +#ifdef WLAN_FEATURE_NAN_CONVERGENCE + +#define NDP_QOS_INFO_LEN 255 +#define NDP_APP_INFO_LEN 255 +#define NDP_PMK_LEN 32 +#define NDP_SCID_BUF_LEN 256 +#define NDP_NUM_INSTANCE_ID 255 + +/** + * enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters + * @QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD: NDP Sub command + * @QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID: Transaction id reference + * @QCA_WLAN_VENDOR_ATTR_NDP_STATUS_ID: NDP status id + * @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID: Service instance id + * @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL: Requested channel + * @QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR: Peer discovery mac addr + * @QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR: Iface name + * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY: Security configuration + * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS: Qos configuration + * @QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO: Application info + * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID: NDP instance id + * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY: NDP instance id array + * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE: Schedule response + * @QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR: NDI mac address + * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE: Driver return status + * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE: Driver return value + * @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG: Channel config request type + * @QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE: Cipher Suit ID + * @QCA_WLAN_VENDOR_ATTR_NDP_PMK: Pairwise Master Key + * @QCA_WLAN_VENDOR_ATTR_NDP_SCID: Security Context ID + */ +enum qca_wlan_vendor_attr_ndp_params { + QCA_WLAN_VENDOR_ATTR_NDP_PARAM_INVALID = 0, + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID, + QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL, + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, + QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, + /* CONFIG_SECURITY is deprecated, use NCS_SK_TYPE/PMK/SCID instead */ + QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY, + QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS, + QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY, + QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE, + QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG, + QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE, + QCA_WLAN_VENDOR_ATTR_NDP_PMK, + QCA_WLAN_VENDOR_ATTR_NDP_SCID, + + QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST, + QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX = + QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST - 1, +}; + +/** + * enum qca_wlan_vendor_attr_ndp_sub_cmd_value - NDP subcmd value + * @QCA_WLAN_VENDOR_ATTR_NDP_INVALID: Unused subcmd value + * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE: iface create + * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: iface delete + * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: NDP initiator request + * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE: NDP initiator response + * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: NDP responder request + * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE: NDP responder response + * @QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: NDP end request + * @QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE: NDP end response + * @QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND: NDP request indication + * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND: NDP confirm indication + * @QCA_WLAN_VENDOR_ATTR_NDP_END_IND: NDP End indication + */ +enum qca_wlan_vendor_attr_ndp_sub_cmd_value { + QCA_WLAN_VENDOR_ATTR_NDP_INVALID = 0, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE = 1, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE = 2, + QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST = 3, + QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE = 4, + QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST = 5, + QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE = 6, + QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST = 7, + QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE = 8, + QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND = 9, + QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND = 10, + QCA_WLAN_VENDOR_ATTR_NDP_END_IND = 11 +}; + +#endif /* WLAN_FEATURE_NAN_CONVERGENCE */ + #endif From e10049933ea24dc8737bf144da0735aa686e5dfa Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sat, 25 Mar 2017 18:54:14 -0700 Subject: [PATCH 09/92] qcacmn: Define NAN components's get/set and utility APIs Define set/get and utility APIs to be used by NAN and other UMAC components. Change-Id: Ib3c3c9711ab823dfdf538099d30078b703566fe1 CRs-Fixed: 2014795 --- core/src/nan_main.c | 37 +++++ core/src/nan_main_i.h | 16 ++ dispatcher/inc/nan_ucfg_api.h | 152 +++++++++++++++++++ dispatcher/src/nan_ucfg_api.c | 274 ++++++++++++++++++++++++++++++++++ 4 files changed, 479 insertions(+) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index f9680ddb695f..8506ce52ea9a 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -19,3 +19,40 @@ /** * DOC: contains core nan function definitions */ + +#include "nan_main_i.h" +#include "wlan_objmgr_psoc_obj.h" +#include "wlan_objmgr_pdev_obj.h" +#include "wlan_objmgr_vdev_obj.h" + +struct nan_vdev_priv_obj *nan_get_vdev_priv_obj( + struct wlan_objmgr_vdev *vdev) +{ + struct nan_vdev_priv_obj *obj; + + if (!vdev) { + nan_err("vdev is null"); + return NULL; + } + wlan_vdev_obj_lock(vdev); + obj = wlan_objmgr_vdev_get_comp_private_obj(vdev, WLAN_UMAC_COMP_NAN); + wlan_vdev_obj_unlock(vdev); + + return obj; +} + +struct nan_psoc_priv_obj *nan_get_psoc_priv_obj( + struct wlan_objmgr_psoc *psoc) +{ + struct nan_psoc_priv_obj *obj; + + if (!psoc) { + nan_err("psoc is null"); + return NULL; + } + wlan_psoc_obj_lock(psoc); + obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_NAN); + wlan_psoc_obj_unlock(psoc); + + return obj; +} \ No newline at end of file diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index e16770619c4f..cf2929252479 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -88,4 +88,20 @@ struct nan_vdev_priv_obj { uint32_t ndi_delete_rsp_status; }; +/** + * nan_get_vdev_priv_obj: get NAN priv object from vdev object + * @vdev: pointer to vdev object + * + * Return: pointer to NAN vdev private object + */ +struct nan_vdev_priv_obj *nan_get_vdev_priv_obj(struct wlan_objmgr_vdev *vdev); + +/** + * nan_get_psoc_priv_obj: get NAN priv object from psoc object + * @psoc: pointer to psoc object + * + * Return: pointer to NAN psoc private object + */ +struct nan_psoc_priv_obj *nan_get_psoc_priv_obj(struct wlan_objmgr_psoc *psoc); + #endif diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index 1b346459aa8f..35bc40ffa647 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.h @@ -19,3 +19,155 @@ /** * DOC: contains interface prototypes for OS_IF layer */ + +#ifndef _NAN_UCFG_API_H_ +#define _NAN_UCFG_API_H_ + +#include "qdf_types.h" +#include "qdf_status.h" + +struct nan_callbacks; +struct wlan_objmgr_vdev; +struct wlan_objmgr_psoc; + +/** + * ucfg_nan_set_ndi_state: set ndi state + * @vdev: pointer to vdev object + * @state: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev, + uint32_t state); + +/** + * ucfg_nan_get_ndi_state: get ndi state from vdev obj + * @vdev: pointer to vdev object + * + * Return: ndi state + */ +enum nan_datapath_state ucfg_nan_get_ndi_state(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_set_active_peers: set active ndi peer + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_active_peers(struct wlan_objmgr_vdev *vdev, + uint32_t val); + +/** + * ucfg_nan_get_active_peers: get active ndi peer from vdev obj + * @vdev: pointer to vdev object + * + * Return: active ndi peer + */ +uint32_t ucfg_nan_get_active_peers(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_set_active_ndp_sessions: set active ndp sessions + * @vdev: pointer to vdev object + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_active_ndp_sessions(struct wlan_objmgr_vdev *vdev, + uint32_t val, uint8_t idx); + +/** + * ucfg_nan_get_active_ndp_sessions: get active ndp sessions from vdev obj + * @vdev: pointer to vdev object + * + * Return: pointer to NAN psoc private object + */ +uint32_t ucfg_nan_get_active_ndp_sessions(struct wlan_objmgr_vdev *vdev, + uint8_t idx); + +/** + * ucfg_nan_set_ndp_create_transaction_id: set ndp create transaction id + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_ndp_create_transaction_id(struct wlan_objmgr_vdev *vdev, + uint16_t val); + +/** + * ucfg_nan_get_ndp_create_transaction_id: get ndp create transaction id + * vdev obj + * @vdev: pointer to vdev object + * + * Return: ndp create transaction_id + */ +uint16_t ucfg_nan_get_ndp_create_transaction_id(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_set_ndp_delete_transaction_id: set ndp delete transaction id + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_ndp_delete_transaction_id(struct wlan_objmgr_vdev *vdev, + uint16_t val); + +/** + * ucfg_nan_get_ndp_delete_transaction_id: get ndp delete transaction id from + * vdev obj + * @vdev: pointer to vdev object + * + * Return: ndp delete transaction_id + */ +uint16_t ucfg_nan_get_ndp_delete_transaction_id(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_set_ndi_delete_rsp_reason: set ndi delete response reason + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_ndi_delete_rsp_reason(struct wlan_objmgr_vdev *vdev, + uint32_t val); + +/** + * ucfg_nan_get_ndi_delete_rsp_reason: get ndi delete response reason from vdev + * obj + * @vdev: pointer to vdev object + * + * Return: ndi delete rsp reason + */ +uint32_t ucfg_nan_get_ndi_delete_rsp_reason(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_set_ndi_delete_rsp_status: set ndi delete response reason + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_set_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev, + uint32_t val); + +/** + * ucfg_nan_get_ndi_delete_rsp_status: get ndi delete response status from vdev + * obj + * @vdev: pointer to vdev object + * + * Return: ndi delete rsp status + */ +uint32_t ucfg_nan_get_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev); + +/** + * ucfg_nan_get_callbacks: ucfg API to return callbacks + * @psoc: pointer to psoc object + * @cb_obj: callback struct to populate + * + * Return: callback struct on sucess, NULL otherwise + */ +QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj); + +#endif /* _NAN_UCFG_API_H_ */ diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index c1945666b24b..3ae24b858f2a 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -20,3 +20,277 @@ * DOC: contains interface definitions for OS_IF layer */ +#include "nan_ucfg_api.h" +#include "nan_public_structs.h" +#include "../../core/src/nan_main_i.h" + +inline QDF_STATUS ucfg_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev, + uint32_t state) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->state = state; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline enum nan_datapath_state ucfg_nan_get_ndi_state( + struct wlan_objmgr_vdev *vdev) +{ + enum nan_datapath_state val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return NAN_DATA_INVALID_STATE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->state; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_active_peers(struct wlan_objmgr_vdev *vdev, + uint32_t val) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->active_ndp_peers = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint32_t ucfg_nan_get_active_peers(struct wlan_objmgr_vdev *vdev) +{ + uint32_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return 0; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->active_ndp_peers; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_active_ndp_sessions( + struct wlan_objmgr_vdev *vdev, uint32_t val, uint8_t idx) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + if (idx > MAX_PEERS) { + nan_err("peer_idx(%d) is greater than MAX(%d) is null", + idx, MAX_PEERS); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->active_ndp_sessions[idx] = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint32_t ucfg_nan_get_active_ndp_sessions(struct wlan_objmgr_vdev *vdev, + uint8_t idx) +{ + uint32_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return 0; + } + + if (idx > MAX_PEERS) { + nan_err("peer_idx(%d) is greater than MAX(%d) is null", + idx, MAX_PEERS); + return 0; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->active_ndp_sessions[idx]; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_ndp_create_transaction_id( + struct wlan_objmgr_vdev *vdev, uint16_t val) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->ndp_create_transaction_id = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint16_t ucfg_nan_get_ndp_create_transaction_id( + struct wlan_objmgr_vdev *vdev) +{ + uint16_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return 0; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->ndp_create_transaction_id; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_ndp_delete_transaction_id( + struct wlan_objmgr_vdev *vdev, uint16_t val) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->ndp_delete_transaction_id = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint16_t ucfg_nan_get_ndp_delete_transaction_id( + struct wlan_objmgr_vdev *vdev) +{ + uint16_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return 0; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->ndp_delete_transaction_id; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_ndi_delete_rsp_reason( + struct wlan_objmgr_vdev *vdev, uint32_t val) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->ndi_delete_rsp_reason = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint32_t ucfg_nan_get_ndi_delete_rsp_reason( + struct wlan_objmgr_vdev *vdev) +{ + uint32_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return 0; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->ndi_delete_rsp_reason; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_set_ndi_delete_rsp_status( + struct wlan_objmgr_vdev *vdev, uint32_t val) +{ + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + priv_obj->ndi_delete_rsp_status = val; + qdf_spin_unlock_bh(&priv_obj->lock); + + return QDF_STATUS_SUCCESS; +} + +inline uint32_t ucfg_nan_get_ndi_delete_rsp_status( + struct wlan_objmgr_vdev *vdev) +{ + uint32_t val; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + qdf_spin_lock_bh(&priv_obj->lock); + val = priv_obj->ndi_delete_rsp_status; + qdf_spin_unlock_bh(&priv_obj->lock); + + return val; +} + +inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj) +{ + struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); + + if (!psoc_obj) { + nan_err("nan psoc priv object is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + qdf_spin_lock_bh(&psoc_obj->lock); + qdf_mem_copy(cb_obj, &psoc_obj->cb_obj, sizeof(*cb_obj)); + qdf_spin_unlock_bh(&psoc_obj->lock); + + return QDF_STATUS_SUCCESS; +} From bf31492fccfc3b5830bef7a5fa7ecee7459d184c Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 21 Mar 2017 15:56:06 -0700 Subject: [PATCH 10/92] qcacmn: Implement NAN component init deinit Implement framework for NAN component and NAN init/deint. Change-Id: Ice8a7269dc646daa97014ac9667e6f07748fdfba CRs-Fixed: 2014795 --- core/inc/wlan_nan_api.h | 34 ++++++ core/src/nan_api.c | 243 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 277 insertions(+) diff --git a/core/inc/wlan_nan_api.h b/core/inc/wlan_nan_api.h index da75dd69e089..1498f23c37e1 100644 --- a/core/inc/wlan_nan_api.h +++ b/core/inc/wlan_nan_api.h @@ -23,4 +23,38 @@ #ifndef _WLAN_NAN_API_H_ #define _WLAN_NAN_API_H_ +#include "qdf_status.h" + +struct wlan_objmgr_psoc; + +/** + * nan_init: initializes NAN component, called by dispatcher init + * + * Return: status of operation + */ +QDF_STATUS nan_init(void); + +/** + * nan_deinit: de-initializes NAN component, called by dispatcher init + * + * Return: status of operation + */ +QDF_STATUS nan_deinit(void); + +/** + * nan_psoc_enable: psoc enable API for NANitioning component + * @psoc: pointer to PSOC + * + * Return: status of operation + */ +QDF_STATUS nan_psoc_enable(struct wlan_objmgr_psoc *psoc); + +/** + * nan_psoc_disable: psoc disable API for NANitioning component + * @psoc: pointer to PSOC + * + * Return: status of operation + */ +QDF_STATUS nan_psoc_disable(struct wlan_objmgr_psoc *psoc); + #endif diff --git a/core/src/nan_api.c b/core/src/nan_api.c index 4a66917b6960..bc46510d9822 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -19,3 +19,246 @@ /** * DOC: contains nan public API function definitions */ + +#include "nan_main_i.h" +#include "wlan_nan_api.h" +#include "nan_public_structs.h" +#include "wlan_objmgr_cmn.h" +#include "wlan_objmgr_global_obj.h" +#include "wlan_objmgr_psoc_obj.h" +#include "wlan_objmgr_pdev_obj.h" +#include "wlan_objmgr_vdev_obj.h" + +static QDF_STATUS nan_psoc_obj_created_notification( + struct wlan_objmgr_psoc *psoc, void *arg_list) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_psoc_priv_obj *nan_obj; + + nan_debug("nan_psoc_create_notif called"); + nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); + if (!nan_obj) { + nan_alert("malloc failed for nan prv obj"); + status = QDF_STATUS_E_NOMEM; + goto nan_psoc_notif_failed; + } + + qdf_spinlock_create(&nan_obj->lock); + status = wlan_objmgr_psoc_component_obj_attach(psoc, + WLAN_UMAC_COMP_NAN, nan_obj, + QDF_STATUS_SUCCESS); + if (QDF_IS_STATUS_ERROR(status)) { + nan_alert("obj attach with psoc failed"); + goto nan_psoc_notif_failed; + } + + return QDF_STATUS_SUCCESS; + +nan_psoc_notif_failed: + + qdf_spinlock_destroy(&nan_obj->lock); + qdf_mem_free(nan_obj); + return status; +} + +static QDF_STATUS nan_psoc_obj_destroyed_notification( + struct wlan_objmgr_psoc *psoc, void *arg_list) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_psoc_priv_obj *nan_obj = nan_get_psoc_priv_obj(psoc); + + nan_debug("nan_psoc_delete_notif called"); + if (!nan_obj) { + nan_err("nan_obj is NULL"); + return QDF_STATUS_E_FAULT; + } + + status = wlan_objmgr_psoc_component_obj_detach(psoc, + WLAN_UMAC_COMP_NAN, nan_obj); + if (QDF_IS_STATUS_ERROR(status)) + nan_err("nan_obj detach failed"); + + nan_debug("nan_obj deleted with status %d", status); + qdf_spinlock_destroy(&nan_obj->lock); + qdf_mem_free(nan_obj); + + return status; +} + +static QDF_STATUS nan_vdev_obj_created_notification( + struct wlan_objmgr_vdev *vdev, void *arg_list) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_vdev_priv_obj *nan_obj; + + if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { + nan_debug("not a ndi vdev. do nothing"); + return QDF_STATUS_SUCCESS; + } + + nan_debug("nan_vdev_create_notif called"); + nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); + if (!nan_obj) { + nan_alert("malloc failed for nan prv obj"); + status = QDF_STATUS_E_NOMEM; + goto nan_vdev_notif_failed; + } + + qdf_spinlock_create(&nan_obj->lock); + status = wlan_objmgr_vdev_component_obj_attach(vdev, + WLAN_UMAC_COMP_NAN, (void *)nan_obj, + QDF_STATUS_SUCCESS); + if (QDF_IS_STATUS_ERROR(status)) { + nan_alert("obj attach with vdev failed"); + goto nan_vdev_notif_failed; + } + + return QDF_STATUS_SUCCESS; + +nan_vdev_notif_failed: + + qdf_spinlock_destroy(&nan_obj->lock); + qdf_mem_free(nan_obj); + return status; +} + +static QDF_STATUS nan_vdev_obj_destroyed_notification( + struct wlan_objmgr_vdev *vdev, void *arg_list) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_vdev_priv_obj *nan_obj; + + if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { + nan_debug("not a ndi vdev. do nothing"); + return QDF_STATUS_SUCCESS; + } + + nan_debug("nan_vdev_delete_notif called"); + nan_obj = nan_get_vdev_priv_obj(vdev); + if (!nan_obj) { + nan_err("nan_obj is NULL"); + return QDF_STATUS_E_FAULT; + } + + status = wlan_objmgr_vdev_component_obj_detach(vdev, + WLAN_UMAC_COMP_NAN, nan_obj); + if (QDF_IS_STATUS_ERROR(status)) + nan_err("nan_obj detach failed"); + + nan_debug("nan_obj deleted with status %d", status); + qdf_spinlock_destroy(&nan_obj->lock); + qdf_mem_free(nan_obj); + + return status; +} + +QDF_STATUS nan_init(void) +{ + QDF_STATUS status; + + /* register psoc create handler functions. */ + status = wlan_objmgr_register_psoc_create_handler( + WLAN_UMAC_COMP_NAN, + nan_psoc_obj_created_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_register_psoc_create_handler failed"); + return status; + } + + /* register psoc delete handler functions. */ + status = wlan_objmgr_register_psoc_destroy_handler( + WLAN_UMAC_COMP_NAN, + nan_psoc_obj_destroyed_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_register_psoc_destroy_handler failed"); + nan_deinit(); + return status; + } + + /* register vdev create handler functions. */ + status = wlan_objmgr_register_vdev_create_handler( + WLAN_UMAC_COMP_NAN, + nan_vdev_obj_created_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_register_psoc_create_handler failed"); + nan_deinit(); + return status; + } + + /* register vdev delete handler functions. */ + status = wlan_objmgr_register_vdev_destroy_handler( + WLAN_UMAC_COMP_NAN, + nan_vdev_obj_destroyed_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_register_psoc_destroy_handler failed"); + nan_deinit(); + return status; + } + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS nan_deinit(void) +{ + QDF_STATUS ret = QDF_STATUS_SUCCESS, status; + + /* register psoc create handler functions. */ + status = wlan_objmgr_unregister_psoc_create_handler( + WLAN_UMAC_COMP_NAN, + nan_psoc_obj_created_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_unregister_psoc_create_handler failed"); + ret = status; + } + + /* register vdev create handler functions. */ + status = wlan_objmgr_unregister_psoc_destroy_handler( + WLAN_UMAC_COMP_NAN, + nan_psoc_obj_destroyed_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_deregister_psoc_destroy_handler failed"); + ret = status; + } + + /* de-register vdev create handler functions. */ + status = wlan_objmgr_unregister_vdev_create_handler( + WLAN_UMAC_COMP_NAN, + nan_vdev_obj_created_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_unregister_psoc_create_handler failed"); + ret = status; + } + + /* de-register vdev delete handler functions. */ + status = wlan_objmgr_unregister_vdev_destroy_handler( + WLAN_UMAC_COMP_NAN, + nan_vdev_obj_destroyed_notification, + NULL); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("wlan_objmgr_deregister_psoc_destroy_handler failed"); + ret = status; + } + + return ret; +} + +QDF_STATUS nan_psoc_enable(struct wlan_objmgr_psoc *psoc) +{ + /* TBD */ + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS nan_psoc_disable(struct wlan_objmgr_psoc *psoc) +{ + /* TBD */ + + return QDF_STATUS_SUCCESS; +} From e3f39345aef28b7c74cd89f6967ac42fd0e0df8c Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 22 Mar 2017 16:19:57 -0700 Subject: [PATCH 11/92] qcacmn: Add interface with LMAC for NAN Component Add interface with LMAC for NAN Component. Change-Id: Idbcdaa19a7a2b83d5a2d125419a7bc6cbe72033d CRs-Fixed: 2014795 --- core/src/nan_api.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/core/src/nan_api.c b/core/src/nan_api.c index bc46510d9822..8cca4e9445a7 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -22,6 +22,7 @@ #include "nan_main_i.h" #include "wlan_nan_api.h" +#include "target_if_nan.h" #include "nan_public_structs.h" #include "wlan_objmgr_cmn.h" #include "wlan_objmgr_global_obj.h" @@ -251,14 +252,20 @@ QDF_STATUS nan_deinit(void) QDF_STATUS nan_psoc_enable(struct wlan_objmgr_psoc *psoc) { - /* TBD */ + QDF_STATUS status = target_if_nan_register_events(psoc); + + if (QDF_IS_STATUS_ERROR(status)) + nan_err("target_if_nan_register_events failed"); return QDF_STATUS_SUCCESS; } QDF_STATUS nan_psoc_disable(struct wlan_objmgr_psoc *psoc) { - /* TBD */ + QDF_STATUS status = target_if_nan_deregister_events(psoc); + + if (QDF_IS_STATUS_ERROR(status)) + nan_err("target_if_nan_deregister_events failed"); return QDF_STATUS_SUCCESS; } From cdb624f81dd722f1a88e98548dcc2f98d1a7efce Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 22 Mar 2017 16:19:57 -0700 Subject: [PATCH 12/92] 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 fa96ba83d3ed..2563efae7d0e 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 3e46ca711d4f..cdf51d016940 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 574d9b4316d63fd4acd92b2c23e478525d60bc6e Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sun, 2 Apr 2017 18:25:54 -0700 Subject: [PATCH 13/92] qcacmn: Add framework for NDP cmd execution Add NDP command execution framework: 1) Define UCFG apis, that will be called from OS_IF layer 2) Define request proccessing functions to post to scheduler and callback. 3) Define request proccessing functions to post to serializer and callback. 4) Define functions handling activated, cancelled and timed out NDP req. Change-Id: Ibc6fe32c65f8de0c24e0537f2eb538f806cf5284 CRs-Fixed: 2014795 --- inc/os_if_nan.h | 29 +++++++++++++++ src/os_if_nan.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 125 insertions(+) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 3843abacfa52..4e263d5ef6a4 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -23,6 +23,11 @@ #ifndef _OS_IF_NAN_H_ #define _OS_IF_NAN_H_ +#include "qdf_types.h" + +struct wlan_objmgr_psoc; +struct wlan_objmgr_vdev; + #ifdef WLAN_FEATURE_NAN_CONVERGENCE #define NDP_QOS_INFO_LEN 255 @@ -114,4 +119,28 @@ enum qca_wlan_vendor_attr_ndp_sub_cmd_value { #endif /* WLAN_FEATURE_NAN_CONVERGENCE */ +/** + * os_if_nan_process_ndp_cmd: os_if api to handle nan request message + * @psoc: pointer to psoc object + * @data: request data. contains vendor cmd tlvs + * @data_len: length of data + * + * Return: status of operation + */ +int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, + const void *data, int data_len); + +/** + * os_if_nan_event_handler: os_if handler api for nan response messages + * @psoc: pointer to psoc object + * @vdev: pointer to vdev object + * @type: message type + * @msg: msg buffer + * + * Return: None + */ +void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg); + #endif diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 3ee4c4706966..5d260ecc32a9 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -20,3 +20,99 @@ * DOC: defines nan component os interface APIs */ +#include "qdf_types.h" +#include "qdf_trace.h" +#include "os_if_nan.h" +#include "wlan_nlink_srv.h" +#include "nan_public_structs.h" +#include "wlan_cfg80211.h" + +/* NLA policy */ +static const struct nla_policy +vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { + [QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID] = { .type = NLA_U16 }, + [QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { .type = NLA_STRING, + .len = IFNAMSIZ }, + [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR] = { + .type = NLA_BINARY, + .len = QDF_MAC_ADDR_SIZE }, + [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY] = { .type = NLA_U16 }, + [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS] = { .type = NLA_BINARY, + .len = NDP_QOS_INFO_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO] = { .type = NLA_BINARY, + .len = NDP_APP_INFO_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE] = { .type = NLA_U16 }, + [QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR] = { .type = NLA_BINARY, + .len = QDF_MAC_ADDR_SIZE }, + [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY] = { .type = NLA_BINARY, + .len = NDP_NUM_INSTANCE_ID }, + [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_PMK] = { .type = NLA_BINARY, + .len = NDP_PMK_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_SCID] = { .type = NLA_BINARY, + .len = NDP_SCID_BUF_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE] = { .type = + NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE] = { .type = NLA_U32 }, +}; + +int os_if_nan_process_ndp_cmd(void *ctx, struct wlan_objmgr_psoc *psoc, + const void *data, int data_len) +{ + uint32_t ndp_cmd_type; + uint16_t transaction_id; + struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1]; + char *iface_name; + + if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX, + data, data_len, vendor_attr_policy)) { + cfg80211_err("Invalid NDP vendor command attributes"); + return -EINVAL; + } + + /* Parse and fetch NDP Command Type*/ + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD]) { + cfg80211_err("NAN datapath cmd type failed"); + return -EINVAL; + } + ndp_cmd_type = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("attr transaction id failed"); + return -EINVAL; + } + transaction_id = nla_get_u16( + tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + cfg80211_err("Transaction Id: %d NDPCmd: %d iface_name: %s", + transaction_id, ndp_cmd_type, iface_name); + } else { + cfg80211_err("Transaction Id: %d NDPCmd: %d iface_name: unspecified", + transaction_id, ndp_cmd_type); + } + + switch (ndp_cmd_type) { + default: + cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); + return -EINVAL; + } + + return -EINVAL; +} + +void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg) +{ + switch (type) { + default: + break; + } +} From cdf30a61595b402d2bd85f83deee6f25b86573c8 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sun, 2 Apr 2017 18:25:54 -0700 Subject: [PATCH 14/92] qcacmn: Add framework for NDP cmd execution Add NDP command execution framework: 1) Define UCFG apis, that will be called from OS_IF layer 2) Define request proccessing functions to post to scheduler and callback. 3) Define request proccessing functions to post to serializer and callback. 4) Define functions handling activated, cancelled and timed out NDP req. Change-Id: Ibc6fe32c65f8de0c24e0537f2eb538f806cf5284 CRs-Fixed: 2014795 --- core/src/nan_main.c | 202 +++++++++++++++++++++++++++++++++- core/src/nan_main_i.h | 18 +++ dispatcher/inc/nan_ucfg_api.h | 11 ++ dispatcher/src/nan_ucfg_api.c | 23 ++++ 4 files changed, 253 insertions(+), 1 deletion(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 8506ce52ea9a..7c5e2d560573 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -21,6 +21,13 @@ */ #include "nan_main_i.h" +#include "nan_ucfg_api.h" +#include "wlan_nan_api.h" +#include "target_if_nan.h" +#include "scheduler_api.h" +#include "wlan_serialization_api.h" +#include "wlan_objmgr_cmn.h" +#include "wlan_objmgr_global_obj.h" #include "wlan_objmgr_psoc_obj.h" #include "wlan_objmgr_pdev_obj.h" #include "wlan_objmgr_vdev_obj.h" @@ -55,4 +62,197 @@ struct nan_psoc_priv_obj *nan_get_psoc_priv_obj( wlan_psoc_obj_unlock(psoc); return obj; -} \ No newline at end of file +} + +void nan_release_cmd(void *in_req, uint32_t req_type) +{ + struct wlan_objmgr_vdev *vdev = NULL; + + if (!in_req) + return; + + switch (req_type) { + case NDP_INITIATOR_REQ: { + struct nan_datapath_initiator_req *req = in_req; + vdev = req->vdev; + qdf_mem_free(req->pmk.pmk); + qdf_mem_free(req->ndp_info.ndp_app_info); + qdf_mem_free(req->ndp_config.ndp_cfg); + break; + } + case NDP_RESPONDER_REQ: { + struct nan_datapath_responder_req *req = in_req; + vdev = req->vdev; + qdf_mem_free(req->pmk.pmk); + qdf_mem_free(req->ndp_info.ndp_app_info); + qdf_mem_free(req->ndp_config.ndp_cfg); + break; + } + case NDP_END_REQ: { + struct nan_datapath_end_req *req = in_req; + vdev = req->vdev; + qdf_mem_free(req->ndp_ids); + break; + } + default: + nan_err("invalid req type: %d", req_type); + break; + } + + if (vdev) + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); + else + nan_err("vdev is null"); + + qdf_mem_free(in_req); +} + +static void nan_req_incomplete(void *req, uint32_t cmdtype) +{ + /* send msg to userspace if needed that cmd got incomplete */ +} + +static void nan_req_activated(void *in_req, uint32_t cmdtype) +{ + uint32_t req_type; + QDF_STATUS status; + struct wlan_objmgr_psoc *psoc; + struct wlan_objmgr_vdev *vdev; + struct wlan_lmac_if_nan_tx_ops *tx_ops; + + switch (cmdtype) { + case WLAN_SER_CMD_NDP_INIT_REQ: { + struct nan_datapath_initiator_req *req = in_req; + vdev = req->vdev; + req_type = NDP_INITIATOR_REQ; + break; + } + case WLAN_SER_CMD_NDP_RESP_REQ: { + struct nan_datapath_responder_req *req = in_req; + vdev = req->vdev; + req_type = NDP_RESPONDER_REQ; + break; + } + case WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: { + struct nan_datapath_end_req *req = in_req; + vdev = req->vdev; + req_type = NDP_END_REQ; + break; + } + default: + nan_alert("in correct cmdtype: %d", cmdtype); + return; + } + + if (!vdev) { + nan_alert("vdev is null"); + return; + } + + psoc = wlan_vdev_get_psoc(vdev); + if (!psoc) { + nan_alert("psoc is null"); + return; + } + + tx_ops = target_if_nan_get_tx_ops(psoc); + if (!tx_ops) { + nan_alert("tx_ops is null"); + return; + } + + /* send ndp_intiator_req/responder_req/end_req to FW */ + tx_ops->nan_req_tx(in_req, req_type); +} + +static QDF_STATUS nan_serialized_cb(void *cmd, + enum wlan_serialization_cb_reason reason) +{ + void *req; + struct wlan_serialization_command *ser_cmd = cmd; + + if (!ser_cmd || !ser_cmd->umac_cmd) { + nan_alert("cmd or umac_cmd is null"); + return QDF_STATUS_E_NULL_VALUE; + } + req = ser_cmd->umac_cmd; + + switch (reason) { + case WLAN_SER_CB_ACTIVATE_CMD: + nan_req_activated(req, ser_cmd->cmd_type); + break; + case WLAN_SER_CB_CANCEL_CMD: + case WLAN_SER_CB_ACTIVE_CMD_TIMEOUT: + nan_req_incomplete(req, ser_cmd->cmd_type); + break; + case WLAN_SER_CB_RELEASE_MEM_CMD: + nan_release_cmd(req, ser_cmd->cmd_type); + break; + default: + /* Do nothing but logging */ + nan_alert("invalid serialized cb reason: %d", reason); + break; + } + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) +{ + QDF_STATUS ref_status; + enum wlan_serialization_status status = 0; + struct wlan_serialization_command cmd = {0}; + + if (!msg || !msg->bodyptr) { + nan_alert("msg or bodyptr is null"); + return QDF_STATUS_E_NULL_VALUE; + } + switch (msg->type) { + case NDP_INITIATOR_REQ: { + struct nan_datapath_initiator_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_INIT_REQ; + cmd.vdev = req->vdev; + break; + } + case NDP_RESPONDER_REQ: { + struct nan_datapath_responder_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_RESP_REQ; + cmd.vdev = req->vdev; + break; + } + case NDP_END_REQ: { + struct nan_datapath_end_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_DATA_END_INIT_REQ; + cmd.vdev = req->vdev; + break; + } + default: + nan_err("wrong request type: %d", msg->type); + return QDF_STATUS_E_INVAL; + } + + /* try get ref now, if failure, then vdev may have been deleted */ + ref_status = wlan_objmgr_vdev_try_get_ref(cmd.vdev, WLAN_NAN_ID); + if (QDF_IS_STATUS_ERROR(ref_status)) { + nan_alert("couldn't get ref. vdev maybe deleted"); + return QDF_STATUS_E_INVAL; + } + /* reference will be released when ser command finishes */ + + /* TBD - support more than one req of same type or avoid */ + cmd.cmd_id = 0; + cmd.cmd_cb = nan_serialized_cb; + cmd.umac_cmd = msg->bodyptr; + cmd.source = WLAN_UMAC_COMP_NAN; + cmd.is_high_priority = false; + cmd.cmd_timeout_duration = 30000 /* 30 sec for now. TBD */; + + status = wlan_serialization_request(&cmd); + /* following is TBD */ + if (status != WLAN_SER_CMD_ACTIVE && status != WLAN_SER_CMD_PENDING) { + nan_err("unable to serialize command"); + wlan_objmgr_vdev_release_ref(cmd.vdev, WLAN_NAN_ID); + return QDF_STATUS_E_INVAL; + } + return QDF_STATUS_SUCCESS; +} diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index cf2929252479..c66594ceac6e 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -104,4 +104,22 @@ struct nan_vdev_priv_obj *nan_get_vdev_priv_obj(struct wlan_objmgr_vdev *vdev); */ struct nan_psoc_priv_obj *nan_get_psoc_priv_obj(struct wlan_objmgr_psoc *psoc); +/** + * nan_release_cmd: frees resources for NAN command. + * @in_req: pointer to msg buffer to be freed + * @req_type: type of request + * + * Return: None + */ +void nan_release_cmd(void *in_req, uint32_t req_type); + +/** + * nan_scheduled_msg_handler: callback pointer to be called when scheduler + * starts executing enqueued NAN command. + * @msg: pointer to msg + * + * Return: status of operation + */ +QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg); + #endif diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index 35bc40ffa647..d099b9ea6d59 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.h @@ -170,4 +170,15 @@ uint32_t ucfg_nan_get_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev); QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); +/** + * ucfg_nan_req_processor: ucfg API to be called from HDD/OS_IF to + * process nan datapath initiator request from userspace + * @in_req: NDP request + * @psoc: pointer to psoc object + * @req_type: type of request + * + * Return: status of operation + */ +QDF_STATUS ucfg_nan_req_processor(void *in_req, uint32_t req_type); + #endif /* _NAN_UCFG_API_H_ */ diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 3ae24b858f2a..b432346ab72a 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -23,6 +23,7 @@ #include "nan_ucfg_api.h" #include "nan_public_structs.h" #include "../../core/src/nan_main_i.h" +#include "scheduler_api.h" inline QDF_STATUS ucfg_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev, uint32_t state) @@ -294,3 +295,25 @@ inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_SUCCESS; } + +QDF_STATUS ucfg_nan_req_processor(void *in_req, uint32_t req_type) +{ + QDF_STATUS status; + struct scheduler_msg msg = {0}; + + if (!in_req) { + nan_alert("req is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + msg.type = req_type; + msg.bodyptr = in_req; + msg.callback = nan_scheduled_msg_handler; + status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("faild to post msg to NAN component, status: %d", + status); + } + + return status; +} From 85f642e6c6508f2d9ac4df3c0af7d1103bb32814 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sun, 2 Apr 2017 19:39:25 -0700 Subject: [PATCH 15/92] qcacmn: Add implementation for NDI Create/Delete Implement NDI create and NDI delete commands. Change-Id: Icd4c745f4d25c0f10f12271fd4fcd7720ad85860 CRs-Fixed: 2014795 --- inc/os_if_nan.h | 102 +++++++++++- src/os_if_nan.c | 413 +++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 511 insertions(+), 4 deletions(-) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 4e263d5ef6a4..9b8fc9f3db37 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -24,6 +24,8 @@ #define _OS_IF_NAN_H_ #include "qdf_types.h" +#include "nan_public_structs.h" +#include "nan_ucfg_api.h" struct wlan_objmgr_psoc; struct wlan_objmgr_vdev; @@ -117,8 +119,6 @@ enum qca_wlan_vendor_attr_ndp_sub_cmd_value { QCA_WLAN_VENDOR_ATTR_NDP_END_IND = 11 }; -#endif /* WLAN_FEATURE_NAN_CONVERGENCE */ - /** * os_if_nan_process_ndp_cmd: os_if api to handle nan request message * @psoc: pointer to psoc object @@ -143,4 +143,102 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev, uint32_t type, void *msg); +/** + * os_if_nan_register_hdd_callbacks: os_if api to register hdd callbacks + * @psoc: pointer to psoc object + * @cb_obj: struct pointer containing callbacks + * + * Return: status of operation + */ +int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj); + +/** + * os_if_nan_post_ndi_create_rsp: os_if api to pos ndi create rsp to umac nan + * component + * @psoc: pointer to psoc object + * @vdev_id: vdev id of ndi + * @success: if create was success or failure + * + * Return: None + */ +void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success); + +/** + * os_if_nan_post_ndi_delete_rsp: os_if api to pos ndi delete rsp to umac nan + * component + * @psoc: pointer to psoc object + * @vdev_id: vdev id of ndi + * @success: if delete was success or failure + * + * Return: None + */ +void os_if_nan_post_ndi_delete_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success); + +/** + * os_if_nan_ndi_session_end: os_if api to process ndi session end + * component + * @vdev: pointer to vdev deleted + * + * Return: None + */ +void os_if_nan_ndi_session_end(struct wlan_objmgr_vdev *vdev); + +/** + * os_if_nan_set_ndi_state: os_if api set NDI state + * @vdev: pointer to vdev deleted + * @state: value to set + * + * Return: status of operation + */ +static inline QDF_STATUS os_if_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev, + uint32_t state) +{ + return ucfg_nan_set_ndi_state(vdev, state); +} + +/** + * os_if_nan_set_ndp_create_transaction_id: set ndp create transaction id + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +static inline QDF_STATUS os_if_nan_set_ndp_create_transaction_id( + struct wlan_objmgr_vdev *vdev, + uint16_t val) +{ + return ucfg_nan_set_ndp_create_transaction_id(vdev, val); +} + +/** + * os_if_nan_set_ndp_delete_transaction_id: set ndp delete transaction id + * @vdev: pointer to vdev object + * @val: value to set + * + * Return: status of operation + */ +static inline QDF_STATUS os_if_nan_set_ndp_delete_transaction_id( + struct wlan_objmgr_vdev *vdev, + uint16_t val) +{ + return ucfg_nan_set_ndp_delete_transaction_id(vdev, val); +} + +#else + +static inline void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success) +{ +} + +static inline void os_if_nan_post_ndi_delete_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success) +{ +} + +#endif /* WLAN_FEATURE_NAN_CONVERGENCE */ + #endif diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 5d260ecc32a9..311a26085d73 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -23,9 +23,14 @@ #include "qdf_types.h" #include "qdf_trace.h" #include "os_if_nan.h" -#include "wlan_nlink_srv.h" +#include "wlan_nan_api.h" #include "nan_public_structs.h" +#include "wlan_osif_priv.h" +#include #include "wlan_cfg80211.h" +#include "wlan_objmgr_psoc_obj.h" +#include "wlan_objmgr_pdev_obj.h" +#include "wlan_objmgr_vdev_obj.h" /* NLA policy */ static const struct nla_policy @@ -61,7 +66,109 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE] = { .type = NLA_U32 }, }; -int os_if_nan_process_ndp_cmd(void *ctx, struct wlan_objmgr_psoc *psoc, +static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + char *iface_name; + QDF_STATUS status; + uint16_t transaction_id; + struct wlan_objmgr_vdev *nan_vdev; + struct nan_callbacks cb_obj; + + cfg80211_debug("enter"); + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + cfg80211_err("Interface name string is unavailable"); + return -EINVAL; + } + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("transaction id is unavailable"); + return -EINVAL; + } + transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("Couldn't get ballback object"); + return -EINVAL; + } + + nan_vdev = cb_obj.ndi_open(iface_name); + + if (!nan_vdev) { + cfg80211_err("ndi_open failed"); + return -EINVAL; + } + + /* + * Create transaction id is required to be saved since the firmware + * does not honor the transaction id for create request + */ + ucfg_nan_set_ndp_create_transaction_id(nan_vdev, transaction_id); + ucfg_nan_set_ndi_state(nan_vdev, NAN_DATA_NDI_CREATING_STATE); + + return cb_obj.ndi_start(wlan_vdev_get_id(nan_vdev)); +} + +static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + uint8_t vdev_id; + char *iface_name; + QDF_STATUS status; + uint32_t num_peers; + uint16_t transaction_id; + struct nan_callbacks cb_obj; + struct wlan_objmgr_vdev *nan_vdev = NULL; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + cfg80211_err("Interface name string is unavailable"); + return -EINVAL; + } + + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("Transaction id is unavailable"); + return -EINVAL; + } + + nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("Nan datapath interface is not present"); + return -EINVAL; + } + + transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + vdev_id = wlan_vdev_get_id(nan_vdev); + num_peers = ucfg_nan_get_active_peers(nan_vdev); + /* + * wlan_objmgr_get_vdev_by_opmode_from_psoc API will have incremented + * ref count - decrement here since vdev returned by that api is not + * used any more + */ + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + + /* check if there are active peers on the adapter */ + if (num_peers) { + cfg80211_err("NDP peers active: %d, cannot delete NDI", + num_peers); + return -EINVAL; + } + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("Couldn't get ballback object"); + return -EINVAL; + } + + return cb_obj.ndi_delete(vdev_id, iface_name, transaction_id); +} + +int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, const void *data, int data_len) { uint32_t ndp_cmd_type; @@ -98,7 +205,12 @@ int os_if_nan_process_ndp_cmd(void *ctx, struct wlan_objmgr_psoc *psoc, transaction_id, ndp_cmd_type); } + cfg80211_debug("Received NDP cmd: %d", ndp_cmd_type); switch (ndp_cmd_type) { + case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE: + return os_if_nan_process_ndi_create(psoc, tb); + case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: + return os_if_nan_process_ndi_delete(psoc, tb); default: cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); return -EINVAL; @@ -107,12 +219,309 @@ int os_if_nan_process_ndp_cmd(void *ctx, struct wlan_objmgr_psoc *psoc, return -EINVAL; } +/** + * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler + * @adapter: pointer to adapter context + * @rsp_params: response parameters + * + * The function is expected to send a response back to the user space + * even if the creation of BSS has failed + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE + * + * Return: none + */ +static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + void *rsp_params) +{ + QDF_STATUS status; + bool create_fail = false; + struct nan_callbacks cb_obj; + struct sk_buff *vendor_event; + uint8_t create_transaction_id; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + uint32_t create_status = NAN_DATAPATH_RSP_STATUS_ERROR; + uint32_t create_reason = NAN_DATAPATH_NAN_DATA_IFACE_CREATE_FAILED; + struct nan_datapath_inf_create_rsp *ndi_rsp = + (struct nan_datapath_inf_create_rsp *)rsp_params; + uint32_t data_len = (3 * sizeof(uint32_t)) + sizeof(uint16_t) + + NLMSG_HDRLEN + (4 * NLA_HDRLEN); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("Couldn't get ballback object"); + return; + } + + if (ndi_rsp) { + create_status = ndi_rsp->status; + create_reason = ndi_rsp->reason; + } else { + cfg80211_err("Invalid ndi create response"); + create_fail = true; + } + + create_transaction_id = ucfg_nan_get_ndp_create_transaction_id(vdev); + + /* notify response to the upper layer */ + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, + NULL, + data_len, + QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_KERNEL); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + create_fail = true; + goto close_ndi; + } + + /* Sub vendor command */ + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE)) { + cfg80211_err("QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD put fail"); + goto nla_put_failure; + } + + /* Transaction id */ + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + create_transaction_id)) { + cfg80211_err("VENDOR_ATTR_NDP_TRANSACTION_ID put fail"); + goto nla_put_failure; + } + + /* Status code */ + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + create_status)) { + cfg80211_err("VENDOR_ATTR_NDP_DRV_RETURN_TYPE put fail"); + goto nla_put_failure; + } + + /* Status return value */ + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + create_reason)) { + cfg80211_err("VENDOR_ATTR_NDP_DRV_RETURN_VALUE put fail"); + goto nla_put_failure; + } + + cfg80211_debug("sub command: %d, value: %d", + QCA_NL80211_VENDOR_SUBCMD_NDP, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE); + cfg80211_debug("create transaction id: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, create_transaction_id); + cfg80211_debug("status code: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + create_status); + cfg80211_debug("Return value: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, create_reason); + + cfg80211_vendor_event(vendor_event, GFP_KERNEL); + + if (!create_fail) { + /* update txrx queues and register self sta */ + cb_obj.drv_ndi_create_rsp_handler(wlan_vdev_get_id(vdev), + ndi_rsp); + } else { + cfg80211_err("NDI interface creation failed with reason %d", + ndi_rsp->reason); + goto close_ndi; + } + + return; + +nla_put_failure: + kfree_skb(vendor_event); +close_ndi: + cb_obj.ndi_close(wlan_vdev_get_id(vdev)); + return; +} + +/** + * os_if_ndp_iface_delete_rsp_handler() - NDP iface delete response handler + * @adapter: pointer to adapter context + * @rsp_params: response parameters + * + * Return: none + */ +static void os_if_ndp_iface_delete_rsp_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + void *rsp_params) +{ + QDF_STATUS status; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + struct nan_datapath_inf_delete_rsp *ndi_rsp = rsp_params; + struct nan_callbacks cb_obj; + + if (!ndi_rsp) { + cfg80211_err("Invalid ndi delete response"); + return; + } + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("Couldn't get ballback object"); + return; + } + + if (ndi_rsp->status == NAN_DATAPATH_RSP_STATUS_SUCCESS) + cfg80211_debug("NDI BSS successfully stopped"); + else + cfg80211_debug("NDI BSS stop failed with reason %d", + ndi_rsp->reason); + + ucfg_nan_set_ndi_delete_rsp_reason(vdev, ndi_rsp->reason); + ucfg_nan_set_ndi_delete_rsp_status(vdev, ndi_rsp->status); + cb_obj.drv_ndi_delete_rsp_handler(vdev_id); +} + void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev, uint32_t type, void *msg) { switch (type) { + case NAN_DATAPATH_INF_CREATE_RSP: + os_if_ndp_iface_create_rsp_handler(psoc, vdev, msg); + break; + case NAN_DATAPATH_INF_DELETE_RSP: + os_if_ndp_iface_delete_rsp_handler(psoc, vdev, msg); + break; default: break; } } + +int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj) +{ + return ucfg_nan_register_hdd_callbacks(psoc, cb_obj, + os_if_nan_event_handler); +} + +void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success) +{ + struct nan_datapath_inf_create_rsp rsp = {0}; + struct wlan_objmgr_vdev *vdev = wlan_objmgr_get_vdev_by_id_from_psoc( + psoc, vdev_id, WLAN_NAN_ID); + + if (success) { + rsp.status = NAN_DATAPATH_RSP_STATUS_SUCCESS; + rsp.reason = 0; + os_if_nan_event_handler(psoc, vdev, + NAN_DATAPATH_INF_CREATE_RSP, &rsp); + } else { + rsp.status = NAN_DATAPATH_RSP_STATUS_ERROR; + rsp.reason = NAN_DATAPATH_NAN_DATA_IFACE_CREATE_FAILED; + os_if_nan_event_handler(psoc, vdev, + NAN_DATAPATH_INF_CREATE_RSP, &rsp); + } + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); +} + +void os_if_nan_post_ndi_delete_rsp(struct wlan_objmgr_psoc *psoc, + uint8_t vdev_id, bool success) +{ + struct nan_datapath_inf_delete_rsp rsp = {0}; + struct wlan_objmgr_vdev *vdev = wlan_objmgr_get_vdev_by_id_from_psoc( + psoc, vdev_id, WLAN_NAN_ID); + if (success) { + rsp.status = NAN_DATAPATH_RSP_STATUS_SUCCESS; + rsp.reason = 0; + os_if_nan_event_handler(psoc, vdev, + NAN_DATAPATH_INF_DELETE_RSP, &rsp); + } else { + rsp.status = NAN_DATAPATH_RSP_STATUS_ERROR; + rsp.reason = NAN_DATAPATH_NAN_DATA_IFACE_DELETE_FAILED; + os_if_nan_event_handler(psoc, vdev, + NAN_DATAPATH_INF_DELETE_RSP, &rsp); + } + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); +} + +void os_if_nan_ndi_session_end(struct wlan_objmgr_vdev *vdev) +{ + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + uint32_t data_len = sizeof(uint32_t) * (3 + sizeof(uint16_t)) + + (NLA_HDRLEN * 4) + NLMSG_HDRLEN; + + /* + * The virtual adapters are stopped and closed even during + * driver unload or stop, the service layer is not required + * to be informed in that case (response is not expected) + */ + if (NAN_DATA_NDI_DELETING_STATE != ucfg_nan_get_ndi_state(vdev)) { + cfg80211_err("NDI interface deleted"); + return; + } + + /* notify response to the upper layer */ + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_KERNEL); + + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + /* Sub vendor command goes first */ + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE)) { + cfg80211_err("VENDOR_ATTR_NDP_SUBCMD put fail"); + goto failure; + } + + /* Transaction id */ + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + ucfg_nan_get_ndp_delete_transaction_id(vdev))) { + cfg80211_err("VENDOR_ATTR_NDP_TRANSACTION_ID put fail"); + goto failure; + } + + /* Status code */ + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + ucfg_nan_get_ndi_delete_rsp_status(vdev))) { + cfg80211_err("VENDOR_ATTR_NDP_DRV_RETURN_TYPE put fail"); + goto failure; + } + + /* Status return value */ + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + ucfg_nan_get_ndi_delete_rsp_reason(vdev))) { + cfg80211_err("VENDOR_ATTR_NDP_DRV_RETURN_VALUE put fail"); + goto failure; + } + + cfg80211_debug("sub command: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE); + cfg80211_debug("delete transaction id: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + ucfg_nan_get_ndp_delete_transaction_id(vdev)); + cfg80211_debug("status code: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + ucfg_nan_get_ndi_delete_rsp_status(vdev)); + cfg80211_debug("Return value: %d, value: %d", + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + ucfg_nan_get_ndi_delete_rsp_reason(vdev)); + + ucfg_nan_set_ndp_delete_transaction_id(vdev, 0); + ucfg_nan_set_ndi_state(vdev, NAN_DATA_NDI_DELETED_STATE); + cfg80211_vendor_event(vendor_event, GFP_KERNEL); + + return; +failure: + kfree_skb(vendor_event); +} From 22f86825158ebe516f9d50eac6d22f069c61b0ac Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sun, 2 Apr 2017 19:39:25 -0700 Subject: [PATCH 16/92] qcacmn: Add implementation for NDI Create/Delete Implement NDI create and NDI delete commands. Change-Id: Icd4c745f4d25c0f10f12271fd4fcd7720ad85860 CRs-Fixed: 2014795 --- core/inc/nan_public_structs.h | 8 +++++ core/src/nan_api.c | 45 +++++++++++++++++++++------ core/src/nan_main_i.h | 2 ++ dispatcher/inc/nan_ucfg_api.h | 43 +++++++++++++++++++++++++- dispatcher/src/nan_ucfg_api.c | 57 ++++++++++++++++++++++++++++++++++- 5 files changed, 144 insertions(+), 11 deletions(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 188dc82c724b..54f1ca6e36dc 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -484,6 +484,14 @@ struct nan_callbacks { void (*os_if_event_handler)(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev, uint32_t type, void *msg); + + struct wlan_objmgr_vdev* (*ndi_open)(char *iface_name); + int (*ndi_start)(uint8_t); + void (*ndi_close)(uint8_t); + int (*ndi_delete)(uint8_t, char *iface_name, uint16_t transaction_id); + void (*drv_ndi_create_rsp_handler)(uint8_t, + struct nan_datapath_inf_create_rsp *); + void (*drv_ndi_delete_rsp_handler)(uint8_t); }; #endif diff --git a/core/src/nan_api.c b/core/src/nan_api.c index 8cca4e9445a7..23b0bae32189 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -40,8 +40,7 @@ static QDF_STATUS nan_psoc_obj_created_notification( nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); if (!nan_obj) { nan_alert("malloc failed for nan prv obj"); - status = QDF_STATUS_E_NOMEM; - goto nan_psoc_notif_failed; + return QDF_STATUS_E_NOMEM; } qdf_spinlock_create(&nan_obj->lock); @@ -89,8 +88,10 @@ static QDF_STATUS nan_psoc_obj_destroyed_notification( static QDF_STATUS nan_vdev_obj_created_notification( struct wlan_objmgr_vdev *vdev, void *arg_list) { - QDF_STATUS status = QDF_STATUS_SUCCESS; + struct wlan_objmgr_psoc *psoc; struct nan_vdev_priv_obj *nan_obj; + struct nan_psoc_priv_obj *nan_psoc_obj; + QDF_STATUS status = QDF_STATUS_SUCCESS; if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { nan_debug("not a ndi vdev. do nothing"); @@ -98,13 +99,26 @@ static QDF_STATUS nan_vdev_obj_created_notification( } nan_debug("nan_vdev_create_notif called"); - nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); - if (!nan_obj) { - nan_alert("malloc failed for nan prv obj"); - status = QDF_STATUS_E_NOMEM; - goto nan_vdev_notif_failed; + + psoc = wlan_vdev_get_psoc(vdev); + if (!psoc) { + nan_err("psoc is null"); + return QDF_STATUS_E_NULL_VALUE; } + nan_psoc_obj = nan_get_psoc_priv_obj(psoc); + if (!nan_psoc_obj) { + nan_err("nan_psoc_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); + if (!nan_obj) { + nan_err("malloc failed for nan prv obj"); + return QDF_STATUS_E_NOMEM; + } + + nan_psoc_obj->vdev = vdev; qdf_spinlock_create(&nan_obj->lock); status = wlan_objmgr_vdev_component_obj_attach(vdev, WLAN_UMAC_COMP_NAN, (void *)nan_obj, @@ -126,8 +140,10 @@ nan_vdev_notif_failed: static QDF_STATUS nan_vdev_obj_destroyed_notification( struct wlan_objmgr_vdev *vdev, void *arg_list) { - QDF_STATUS status = QDF_STATUS_SUCCESS; + struct wlan_objmgr_psoc *psoc; struct nan_vdev_priv_obj *nan_obj; + struct nan_psoc_priv_obj *nan_psoc_obj; + QDF_STATUS status = QDF_STATUS_SUCCESS; if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { nan_debug("not a ndi vdev. do nothing"); @@ -135,6 +151,17 @@ static QDF_STATUS nan_vdev_obj_destroyed_notification( } nan_debug("nan_vdev_delete_notif called"); + psoc = wlan_vdev_get_psoc(vdev); + if (psoc) { + nan_psoc_obj = nan_get_psoc_priv_obj(psoc); + if (nan_psoc_obj) + nan_psoc_obj->vdev = NULL; + else + nan_err("nan_psoc_obj is null"); + } else { + nan_err("psoc is null"); + } + nan_obj = nan_get_vdev_priv_obj(vdev); if (!nan_obj) { nan_err("nan_obj is NULL"); diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index c66594ceac6e..b95c87b5ad06 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -59,10 +59,12 @@ struct scheduler_msg; * struct nan_psoc_priv_obj - nan private psoc obj * @lock: lock to be acquired before reading or writing to object * @cb_obj: struct contaning callback pointers + * @vdev: ndi vdev */ struct nan_psoc_priv_obj { qdf_spinlock_t lock; struct nan_callbacks cb_obj; + struct wlan_objmgr_vdev *vdev; }; /** diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index d099b9ea6d59..bec291036a0e 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.h @@ -25,10 +25,13 @@ #include "qdf_types.h" #include "qdf_status.h" +#include "wlan_objmgr_cmn.h" struct nan_callbacks; struct wlan_objmgr_vdev; struct wlan_objmgr_psoc; +struct wlan_objmgr_vdev; +struct nan_callbacks; /** * ucfg_nan_set_ndi_state: set ndi state @@ -170,15 +173,53 @@ uint32_t ucfg_nan_get_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev); QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); +/** + * ucfg_nan_get_ndi_vdev: ucfg API get ndi vdev from psoc + * @psoc: psoc obj pointer + * @dbg_id: component id that will be owner of reference + * + * Return: vdev object pointer on success, null otherwise + */ +struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, + wlan_objmgr_ref_dbgid dbg_id); + /** * ucfg_nan_req_processor: ucfg API to be called from HDD/OS_IF to * process nan datapath initiator request from userspace + * @vdev: nan vdev pointer * @in_req: NDP request * @psoc: pointer to psoc object * @req_type: type of request * * Return: status of operation */ -QDF_STATUS ucfg_nan_req_processor(void *in_req, uint32_t req_type); +QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, + void *in_req, uint32_t req_type); + +/** + * ucfg_nan_register_hdd_callbacks: ucfg API to set hdd callbacks + * @psoc: pointer to psoc object + * @cb_obj: structs containing callbacks + * @os_if_event_handler: os if event handler callback + * + * Return: status of operation + */ +int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj, + void (os_if_event_handler)( + struct wlan_objmgr_psoc *, + struct wlan_objmgr_vdev *, + uint32_t, void *)); + +/** + * ucfg_nan_get_callbacks: ucfg API to return callbacks + * @psoc: pointer to psoc object + * @cb_obj: callback struct to populate + * + * Return: callback struct on sucess, NULL otherwise + */ +QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj); #endif /* _NAN_UCFG_API_H_ */ + diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index b432346ab72a..023d36b4a2eb 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -24,6 +24,12 @@ #include "nan_public_structs.h" #include "../../core/src/nan_main_i.h" #include "scheduler_api.h" +#include "wlan_objmgr_psoc_obj.h" +#include "wlan_objmgr_pdev_obj.h" +#include "wlan_objmgr_vdev_obj.h" + +struct wlan_objmgr_psoc; +struct wlan_objmgr_vdev; inline QDF_STATUS ucfg_nan_set_ndi_state(struct wlan_objmgr_vdev *vdev, uint32_t state) @@ -296,7 +302,28 @@ inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_SUCCESS; } -QDF_STATUS ucfg_nan_req_processor(void *in_req, uint32_t req_type) +struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, + wlan_objmgr_ref_dbgid dbg_id) +{ + QDF_STATUS status; + struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); + + if (!psoc_obj) { + nan_err("nan psoc priv object is NULL"); + return NULL; + } + + status = wlan_objmgr_vdev_try_get_ref(psoc_obj->vdev, dbg_id); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("could not get vdev ref. vdev may have been deleted"); + return NULL; + } + + return psoc_obj->vdev; +} + +QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, + void *in_req, uint32_t req_type) { QDF_STATUS status; struct scheduler_msg msg = {0}; @@ -317,3 +344,31 @@ QDF_STATUS ucfg_nan_req_processor(void *in_req, uint32_t req_type) return status; } + +int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj, + void (os_if_event_handler)( + struct wlan_objmgr_psoc *, + struct wlan_objmgr_vdev *, + uint32_t, void *)) +{ + struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); + + if (!psoc_obj) { + nan_err("nan psoc priv object is NULL"); + return -EINVAL; + } + + psoc_obj->cb_obj.os_if_event_handler = os_if_event_handler; + + psoc_obj->cb_obj.ndi_open = cb_obj->ndi_open; + psoc_obj->cb_obj.ndi_start = cb_obj->ndi_start; + psoc_obj->cb_obj.ndi_delete = cb_obj->ndi_delete; + psoc_obj->cb_obj.ndi_close = cb_obj->ndi_close; + psoc_obj->cb_obj.drv_ndi_create_rsp_handler = + cb_obj->drv_ndi_create_rsp_handler; + psoc_obj->cb_obj.drv_ndi_delete_rsp_handler = + cb_obj->drv_ndi_delete_rsp_handler; + + return 0; +} From 8ea4a2cc81bde21f3ef6cf4f63ec58c53887b454 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 5 Apr 2017 17:26:18 -0700 Subject: [PATCH 17/92] 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 cdf51d016940..8203babf00e3 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 320064017e8922b773f48ff0e5c5ee9b1420bfcf Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 5 Apr 2017 17:26:18 -0700 Subject: [PATCH 18/92] qcacmn: NDP_INITIATOR_REQ implementation Add implementation for NDP_INITIATOR_REQ. Change-Id: Ieb4cb79d500fd75b23b4a3f8bfa414d14eb6fe18 CRs-Fixed: 2014795 --- inc/os_if_nan.h | 10 + src/os_if_nan.c | 524 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 534 insertions(+) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 9b8fc9f3db37..a0355e7a7025 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -153,6 +153,16 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); +/** + * os_if_nan_register_lim_callbacks: os_if api to register lim callbacks + * @psoc: pointer to psoc object + * @cb_obj: struct pointer containing callbacks + * + * Return: status of operation + */ +int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj); + /** * os_if_nan_post_ndi_create_rsp: os_if api to pos ndi create rsp to umac nan * component diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 311a26085d73..76012e2a6a3a 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -24,6 +24,7 @@ #include "qdf_trace.h" #include "os_if_nan.h" #include "wlan_nan_api.h" +#include "nan_ucfg_api.h" #include "nan_public_structs.h" #include "wlan_osif_priv.h" #include @@ -168,6 +169,147 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, return cb_obj.ndi_delete(vdev_id, iface_name, transaction_id); } +/** + * os_if_nan_process_ndp_initiator_req() - NDP initiator request handler + * @ctx: hdd context + * @tb: parsed NL attribute list + * + * tb will contain following vendor attributes: + * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID + * QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL - optional + * QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG + * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID + * QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR + * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional + * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional + * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional + * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * + * Return: 0 on success or error code on failure + */ +static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + int ret = 0; + char *iface_name; + QDF_STATUS status; + uint32_t ndp_qos_cfg; + enum nan_datapath_state state; + struct wlan_objmgr_vdev *nan_vdev; + struct nan_datapath_initiator_req req = {0}; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + cfg80211_err("Interface name string is unavailable"); + return -EINVAL; + } + + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface %s not available", iface_name); + return -EINVAL; + } + + state = ucfg_nan_get_ndi_state(nan_vdev); + if (state == NAN_DATA_NDI_DELETED_STATE || + state == NAN_DATA_NDI_DELETING_STATE || + state == NAN_DATA_NDI_CREATING_STATE) { + cfg80211_err("Data request not allowed in NDI current state: %d", + state); + ret = -EINVAL; + goto initiator_req_failed; + } + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("Transaction ID is unavailable"); + ret = -EINVAL; + goto initiator_req_failed; + } + req.transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]) + req.channel = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]); + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]) { + req.channel_cfg = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]); + } else { + cfg80211_err("Channel config is unavailable"); + ret = -EINVAL; + goto initiator_req_failed; + } + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]) { + cfg80211_err("NDP service instance ID is unavailable"); + ret = -EINVAL; + goto initiator_req_failed; + } + req.service_instance_id = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]); + + qdf_mem_copy(req.self_ndi_mac_addr.bytes, + wlan_vdev_mlme_get_macaddr(nan_vdev), QDF_MAC_ADDR_SIZE); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]) { + cfg80211_err("NDI peer discovery mac addr is unavailable"); + ret = -EINVAL; + goto initiator_req_failed; + } + qdf_mem_copy(req.peer_discovery_mac_addr.bytes, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]), + QDF_MAC_ADDR_SIZE); + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { + req.ndp_info.ndp_app_info_len = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); + req.ndp_info.ndp_app_info = + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) { + /* at present ndp config stores 4 bytes QOS info only */ + req.ndp_config.ndp_cfg_len = 4; + req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg; + ndp_qos_cfg = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] && + !tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { + cfg80211_err("PMK cannot be absent when CSID is present."); + ret = -EINVAL; + goto initiator_req_failed; + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { + req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, + QDF_TRACE_LEVEL_DEBUG, + req.pmk.pmk, req.pmk.pmk_len); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { + req.ncs_sk_type = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); + + } + + cfg80211_debug("vdev_id: %d, transaction_id: %d, channel: %d, service_instance_id: %d, ndp_app_info_len: %d, csid: %d, peer_discovery_mac_addr: %pM", + wlan_vdev_get_id(nan_vdev), req.transaction_id, req.channel, + req.service_instance_id, req.ndp_info.ndp_app_info_len, + req.ncs_sk_type, req.peer_discovery_mac_addr.bytes); + + status = ucfg_nan_req_processor(nan_vdev, &req, NDP_INITIATOR_REQ); + ret = qdf_status_to_os_return(status); +initiator_req_failed: + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + + return ret; +} + int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, const void *data, int data_len) { @@ -211,6 +353,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return os_if_nan_process_ndi_create(psoc, tb); case QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: return os_if_nan_process_ndi_delete(psoc, tb); + case QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: + return os_if_nan_process_ndp_initiator_req(psoc, tb); default: cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); return -EINVAL; @@ -219,6 +363,368 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return -EINVAL; } +/** + * os_if_ndp_initiator_rsp_handler() - NDP initiator response handler + * @vdev: pointer to vdev object + * @rsp_params: response parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) + * + * Return: none + */ +static void os_if_ndp_initiator_rsp_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_initiator_rsp *rsp) +{ + uint32_t data_len; + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + if (!rsp) { + cfg80211_err("Invalid NDP Initator response"); + return; + } + + data_len = (4 * sizeof(uint32_t)) + (1 * sizeof(uint16_t)) + + NLMSG_HDRLEN + (5 * NLA_HDRLEN); + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE)) + goto ndp_initiator_rsp_nla_failed; + + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + rsp->transaction_id)) + goto ndp_initiator_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, + rsp->ndp_instance_id)) + goto ndp_initiator_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + rsp->status)) + goto ndp_initiator_rsp_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + rsp->reason)) + goto ndp_initiator_rsp_nla_failed; + + cfg80211_debug("NDP Initiator rsp sent, tid:%d, instance id:%d, status:%d, reason: %d", + rsp->transaction_id, rsp->ndp_instance_id, rsp->status, + rsp->reason); + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; +ndp_initiator_rsp_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + +/** + * os_if_ndp_indication_handler() - NDP indication handler + * @vdev: pointer to vdev object + * @ind_params: indication parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ) + * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR (6 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size) + * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE(4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_SCID(scid_len in size) + * + * Return: none + */ +static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_indication_event *event) +{ + uint16_t data_len; + uint32_t ndp_qos_config; + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + enum nan_datapath_state state; + + if (!event) { + cfg80211_err("Invalid NDP Indication"); + return; + } + + cfg80211_debug("NDP Indication, policy: %d", event->policy); + state = ucfg_nan_get_ndi_state(vdev); + /* check if we are in middle of deleting/creating the interface */ + + if (state == NAN_DATA_NDI_DELETED_STATE || + state == NAN_DATA_NDI_DELETING_STATE || + state == NAN_DATA_NDI_CREATING_STATE) { + cfg80211_err("Data request not allowed in current NDI state: %d", + state); + return; + } + + data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + IFNAMSIZ + + event->ndp_info.ndp_app_info_len + event->scid.scid_len + + (10 * NLA_HDRLEN) + NLMSG_HDRLEN; + + /* notify response to the upper layer */ + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, + NULL, data_len, + QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND)) + goto ndp_indication_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, + IFNAMSIZ, "nan0"/* adapter->dev->name - fetch dev name */)) + goto ndp_indication_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID, + event->service_instance_id)) + goto ndp_indication_nla_failed; + + if (nla_put(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, + QDF_MAC_ADDR_SIZE, event->peer_mac_addr.bytes)) + goto ndp_indication_nla_failed; + + if (nla_put(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, + QDF_MAC_ADDR_SIZE, event->peer_discovery_mac_addr.bytes)) + goto ndp_indication_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, + event->ndp_instance_id)) + goto ndp_indication_nla_failed; + + if (event->ndp_info.ndp_app_info_len) + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, + event->ndp_info.ndp_app_info_len, + event->ndp_info.ndp_app_info)) + goto ndp_indication_nla_failed; + + if (event->ndp_config.ndp_cfg_len) { + ndp_qos_config = *((uint32_t *)event->ndp_config.ndp_cfg); + /* at present ndp config stores 4 bytes QOS info only */ + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS, + ndp_qos_config)) + goto ndp_indication_nla_failed; + } + + if (event->scid.scid_len) { + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE, + event->ncs_sk_type)) + goto ndp_indication_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SCID, + event->scid.scid_len, + event->scid.scid)) + goto ndp_indication_nla_failed; + + cfg80211_debug("csid: %d, scid_len: %d", + event->ncs_sk_type, event->scid.scid_len); + + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG, + event->scid.scid, event->scid.scid_len); + } + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; +ndp_indication_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + +/** + * os_if_ndp_confirm_ind_handler() - NDP confirm indication handler + * @vdev: pointer to vdev object + * @ind_params: indication parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR (6 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ) + * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size) + * QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_RETURN_VALUE (4 bytes) + * + * Return: none + */ +static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_confirm_event *ndp_confirm) +{ + int idx = 0; + uint32_t data_len; + QDF_STATUS status; + uint32_t ndp_qos_config = 0; + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + struct nan_callbacks cb_obj; + + if (!ndp_confirm) { + cfg80211_err("Invalid NDP Initator response"); + return; + } + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("couldn't get callbacks"); + return; + } + + /* ndp_confirm is called each time user generated ndp req succeeds */ + idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev), + &ndp_confirm->peer_ndi_mac_addr); + + if (idx < 0) + cfg80211_err("can't find addr: %pM in vdev_id: %d, peer table.", + &ndp_confirm->peer_ndi_mac_addr, + wlan_vdev_get_id(vdev)); + else if (ndp_confirm->rsp_code == NAN_DATAPATH_RESPONSE_ACCEPT) { + uint32_t active_sessions = + ucfg_nan_get_active_ndp_sessions(vdev, idx); + ucfg_nan_set_active_ndp_sessions(vdev, active_sessions + 1, + idx); + } + + data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + IFNAMSIZ + + + NLMSG_HDRLEN + (7 * NLA_HDRLEN) + + ndp_confirm->ndp_info.ndp_app_info_len; + + if (ndp_confirm->ndp_info.ndp_app_info_len) + data_len += NLA_HDRLEN + ndp_confirm->ndp_info.ndp_app_info_len; + + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND)) + goto ndp_confirm_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, + ndp_confirm->ndp_instance_id)) + goto ndp_confirm_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, + QDF_MAC_ADDR_SIZE, ndp_confirm->peer_ndi_mac_addr.bytes)) + goto ndp_confirm_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, + IFNAMSIZ, "nan0" /* TBD adapter->dev->name - fetch name */)) + goto ndp_confirm_nla_failed; + + if (ndp_confirm->ndp_info.ndp_app_info_len && nla_put(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, + ndp_confirm->ndp_info.ndp_app_info_len, + ndp_confirm->ndp_info.ndp_app_info)) + goto ndp_confirm_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE, + ndp_confirm->rsp_code)) + goto ndp_confirm_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + ndp_confirm->reason_code)) + goto ndp_confirm_nla_failed; + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM, ndp_cfg: %d, rsp_code: %d, reason_code: %d", + ndp_confirm->ndp_instance_id, + ndp_confirm->peer_ndi_mac_addr.bytes, + ndp_qos_config, ndp_confirm->rsp_code, + ndp_confirm->reason_code); + + cfg80211_debug("NDP confim, ndp app info dump"); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG, + ndp_confirm->ndp_info.ndp_app_info, + ndp_confirm->ndp_info.ndp_app_info_len); + return; +ndp_confirm_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + +/** + * os_if_new_peer_ind_handler() - NDP new peer indication handler + * @adapter: pointer to adapter context + * @ind_params: indication parameters + * + * Return: none + */ +static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_peer_ind *peer_ind) +{ + int ret; + QDF_STATUS status; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); + uint32_t active_peers = ucfg_nan_get_active_peers(vdev); + struct nan_callbacks cb_obj; + + if (NULL == peer_ind) { + cfg80211_err("Invalid new NDP peer params"); + return; + } + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("failed to get callbacks"); + return; + } + + cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d", + peer_ind->session_id, peer_ind->peer_mac_addr.bytes, + peer_ind->sta_id); + ret = cb_obj.new_peer_ind(vdev_id, peer_ind->sta_id, + &peer_ind->peer_mac_addr, + (active_peers == 0 ? true : false)); + if (ret) { + cfg80211_err("new peer handling at HDD failed %d", ret); + return; + } + + active_peers++; + ucfg_nan_set_active_peers(vdev, active_peers); + cfg80211_debug("vdev_id: %d, num_peers: %d", vdev_id, active_peers); +} + /** * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler * @adapter: pointer to adapter context @@ -393,6 +899,18 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, case NAN_DATAPATH_INF_DELETE_RSP: os_if_ndp_iface_delete_rsp_handler(psoc, vdev, msg); break; + case NDP_CONFIRM: + os_if_ndp_confirm_ind_handler(vdev, msg); + break; + case NDP_INITIATOR_RSP: + os_if_ndp_initiator_rsp_handler(vdev, msg); + break; + case NDP_INDICATION: + os_if_ndp_indication_handler(vdev, msg); + break; + case NDP_NEW_PEER: + os_if_new_peer_ind_handler(vdev, msg); + break; default: break; } @@ -405,6 +923,12 @@ int os_if_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, os_if_nan_event_handler); } +int os_if_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj) +{ + return ucfg_nan_register_lim_callbacks(psoc, cb_obj); +} + void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc, uint8_t vdev_id, bool success) { From 94b75284eaefc2871e075adf7bb559c535b3c699 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 5 Apr 2017 17:26:18 -0700 Subject: [PATCH 19/92] qcacmn: NDP_INITIATOR_REQ implementation Add implementation for NDP_INITIATOR_REQ. Change-Id: Ieb4cb79d500fd75b23b4a3f8bfa414d14eb6fe18 CRs-Fixed: 2014795 --- core/inc/nan_public_structs.h | 6 ++ core/src/nan_main.c | 158 ++++++++++++++++++++++++++++++++++ core/src/nan_main_i.h | 8 ++ dispatcher/inc/nan_ucfg_api.h | 24 ++++++ dispatcher/src/nan_ucfg_api.c | 109 ++++++++++++++++++++++- 5 files changed, 304 insertions(+), 1 deletion(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 54f1ca6e36dc..6c6f94f020cf 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -492,6 +492,12 @@ struct nan_callbacks { void (*drv_ndi_create_rsp_handler)(uint8_t, struct nan_datapath_inf_create_rsp *); void (*drv_ndi_delete_rsp_handler)(uint8_t); + + int (*new_peer_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, bool); + int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *); + QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr); + + void (*delete_peers_by_addr)(uint8_t, struct qdf_mac_addr); }; #endif diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 7c5e2d560573..611af738e610 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -256,3 +256,161 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) } return QDF_STATUS_SUCCESS; } + +static QDF_STATUS nan_handle_confirm( + struct nan_datapath_confirm_event *confirm) +{ + uint8_t vdev_id; + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct wlan_objmgr_psoc *psoc; + struct nan_psoc_priv_obj *psoc_nan_obj; + + vdev_id = wlan_vdev_get_id(confirm->vdev); + psoc = wlan_vdev_get_psoc(confirm->vdev); + if (!psoc) { + nan_err("psoc is null"); + status = QDF_STATUS_E_NULL_VALUE; + goto free_resource; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is null"); + status = QDF_STATUS_E_NULL_VALUE; + goto free_resource; + } + + if (confirm->rsp_code != NAN_DATAPATH_RESPONSE_ACCEPT && + confirm->num_active_ndps_on_peer == 0) { + /* + * This peer was created at ndp_indication but + * confirm failed, so it needs to be deleted + */ + nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDRESS_STR" on vdev_id: %d", + QDF_MAC_ADDR_ARRAY(confirm->peer_ndi_mac_addr.bytes), + vdev_id); + psoc_nan_obj->cb_obj.delete_peers_by_addr(vdev_id, + confirm->peer_ndi_mac_addr); + } + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, confirm->vdev, + NDP_CONFIRM, confirm); + +free_resource: + qdf_mem_free(confirm->ndp_info.ndp_app_info); + + return status; +} + +static QDF_STATUS nan_handle_initiator_rsp( + struct nan_datapath_initiator_rsp *rsp, + struct wlan_objmgr_vdev **vdev) +{ + struct wlan_objmgr_psoc *psoc; + struct nan_psoc_priv_obj *psoc_nan_obj; + + *vdev = rsp->vdev; + psoc = wlan_vdev_get_psoc(rsp->vdev); + if (!psoc) { + nan_err("psoc is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, rsp->vdev, + NDP_INITIATOR_RSP, rsp); + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS nan_handle_ndp_ind( + struct nan_datapath_indication_event *ndp_ind) +{ + uint8_t vdev_id; + struct wlan_objmgr_psoc *psoc; + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_psoc_priv_obj *psoc_nan_obj; + + vdev_id = wlan_vdev_get_id(ndp_ind->vdev); + psoc = wlan_vdev_get_psoc(ndp_ind->vdev); + if (!psoc) { + nan_err("psoc is null"); + status = QDF_STATUS_E_NULL_VALUE; + goto ndp_indication_failed; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is null"); + status = QDF_STATUS_E_NULL_VALUE; + goto ndp_indication_failed; + } + + nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr " + QDF_MAC_ADDRESS_STR, + ndp_ind->role, vdev_id, ndp_ind->ncs_sk_type, + QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes)); + + if ((ndp_ind->role == NAN_DATAPATH_ROLE_INITIATOR) || + ((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) && + (NAN_DATAPATH_ACCEPT_POLICY_ALL == ndp_ind->policy))) { + status = psoc_nan_obj->cb_obj.add_ndi_peer(vdev_id, + ndp_ind->peer_mac_addr); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("Couldn't add ndi peer, ndp_role: %d", + ndp_ind->role); + goto ndp_indication_failed; + } + } + if (NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ndp_ind->vdev, + NDP_INDICATION, ndp_ind); +ndp_indication_failed: + qdf_mem_free(ndp_ind->ndp_config.ndp_cfg); + qdf_mem_free(ndp_ind->ndp_info.ndp_app_info); + qdf_mem_free(ndp_ind->scid.scid); + + return status; +} + +QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) +{ + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct wlan_serialization_queued_cmd_info cmd; + + cmd.requestor = WLAN_UMAC_COMP_NAN; + cmd.cmd_id = 0; + cmd.req_type = WLAN_SER_CANCEL_NON_SCAN_CMD; + cmd.queue_type = WLAN_SERIALIZATION_ACTIVE_QUEUE; + + if (!pe_msg->bodyptr) { + nan_err("msg body is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + switch (pe_msg->type) { + case NDP_CONFIRM: { + nan_handle_confirm(pe_msg->bodyptr); + break; + } + case NDP_INITIATOR_RSP: { + nan_handle_initiator_rsp(pe_msg->bodyptr, &cmd.vdev); + cmd.cmd_type = WLAN_SER_CMD_NDP_INIT_REQ; + wlan_serialization_remove_cmd(&cmd); + break; + } + case NDP_INDICATION: { + nan_handle_ndp_ind(pe_msg->bodyptr); + break; + } + default: + nan_alert("Unhandled NDP event: %d", pe_msg->type); + status = QDF_STATUS_E_NOSUPPORT; + break; + } + return status; +} diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index b95c87b5ad06..ca467ef91d16 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -124,4 +124,12 @@ void nan_release_cmd(void *in_req, uint32_t req_type); */ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg); +/* + * nan_event_handler: function to process events from firmware + * @msg: message received from lmac + * + * Return: status of operation + */ +QDF_STATUS nan_event_handler(struct scheduler_msg *msg); + #endif diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index bec291036a0e..feb002f58bbf 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.h @@ -196,6 +196,20 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type); +/** + * ucfg_nan_event_handler: ucfg API to be called from legacy code to + * post events to os_if/hdd layer + * @psoc: pointer to psoc object + * @vdev: pointer to vdev object + * @type: message type + * @msg: msg buffer + * + * Return: None + */ +void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg); + /** * ucfg_nan_register_hdd_callbacks: ucfg API to set hdd callbacks * @psoc: pointer to psoc object @@ -211,6 +225,16 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *, uint32_t, void *)); +/* + * ucfg_nan_register_lim_callbacks: ucfg API to set lim callbacks + * @psoc: pointer to psoc object + * @cb_obj: structs containing callbacks + * + * Return: status of operation + */ +int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj); + /** * ucfg_nan_get_callbacks: ucfg API to return callbacks * @psoc: pointer to psoc object diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 023d36b4a2eb..c63fa076ac7a 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -322,9 +322,69 @@ struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, return psoc_obj->vdev; } +static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req( + struct wlan_objmgr_vdev *vdev, + struct nan_datapath_initiator_req *in_req) +{ + struct nan_datapath_initiator_req *out_req; + + out_req = qdf_mem_malloc(sizeof(*out_req)); + if (!out_req) { + nan_alert("malloc failed"); + return NULL; + } + + qdf_mem_copy(out_req, in_req, sizeof(*out_req)); + if (in_req->ndp_config.ndp_cfg_len) { + out_req->ndp_config.ndp_cfg = + qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len); + if (!out_req->ndp_config.ndp_cfg) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(out_req->ndp_config.ndp_cfg, + in_req->ndp_config.ndp_cfg, + in_req->ndp_config.ndp_cfg_len); + } + + if (in_req->ndp_info.ndp_app_info_len) { + out_req->ndp_info.ndp_app_info = + qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len); + if (!out_req->ndp_info.ndp_app_info) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(out_req->ndp_info.ndp_app_info, + in_req->ndp_info.ndp_app_info, + in_req->ndp_info.ndp_app_info_len); + } + + if (in_req->pmk.pmk_len) { + out_req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len); + if (!out_req->pmk.pmk) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(out_req->pmk.pmk, in_req->pmk.pmk, + in_req->pmk.pmk_len); + } + + /* do not get ref here, rather take ref when request is activated */ + out_req->vdev = vdev; + return out_req; + +free_resources: + qdf_mem_free(out_req->pmk.pmk); + qdf_mem_free(out_req->ndp_info.ndp_app_info); + qdf_mem_free(out_req->ndp_config.ndp_cfg); + qdf_mem_free(out_req); + return NULL; +} + QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { + void *req; QDF_STATUS status; struct scheduler_msg msg = {0}; @@ -333,8 +393,22 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, return QDF_STATUS_E_NULL_VALUE; } + switch (req_type) { + case NDP_INITIATOR_REQ: + req = ucfg_nan_copy_intiator_req(vdev, in_req); + break; + default: + nan_err("in correct message req type: %d", req_type); + return QDF_STATUS_E_INVAL; + } + + if (!req) { + nan_err("failed to create local copy"); + return QDF_STATUS_E_INVAL; + } + msg.type = req_type; - msg.bodyptr = in_req; + msg.bodyptr = req; msg.callback = nan_scheduled_msg_handler; status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg); if (QDF_IS_STATUS_ERROR(status)) { @@ -345,6 +419,20 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, return status; } +void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc, + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg) +{ + struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); + + if (!psoc_obj) { + nan_err("nan psoc priv object is NULL"); + return; + } + + psoc_obj->cb_obj.os_if_event_handler(psoc, vdev, type, msg); +} + int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj, void (os_if_event_handler)( @@ -370,5 +458,24 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, psoc_obj->cb_obj.drv_ndi_delete_rsp_handler = cb_obj->drv_ndi_delete_rsp_handler; + psoc_obj->cb_obj.get_peer_idx = cb_obj->get_peer_idx; + psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind; + + return 0; +} + +int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, + struct nan_callbacks *cb_obj) +{ + struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); + + if (!psoc_obj) { + nan_err("nan psoc priv object is NULL"); + return -EINVAL; + } + + psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer; + psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr; + return 0; } From f36006eacc8161e8f9cfca802b0e46ae3ec5b870 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:28 -0700 Subject: [PATCH 20/92] 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 8203babf00e3..5d286a9bebc4 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 3bc4aed32e61251d7a5efd994e64df8e7b28a76e Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:28 -0700 Subject: [PATCH 21/92] qcacmn: NDP_RESPONDER_REQ implementation Add implementation for NDP_RESPONDER_REQ. Change-Id: I27029eae88e0bc545c8444adf1342b2ec95f4d60 CRs-Fixed: 2014795 --- src/os_if_nan.c | 203 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 76012e2a6a3a..0459f630c69c 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -310,6 +310,138 @@ initiator_req_failed: return ret; } +/** + * os_if_nan_process_ndp_responder_req() - NDP responder request handler + * @nan_ctx: hdd context + * @tb: parsed NL attribute list + * + * tb includes following vendor attributes: + * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID + * QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE + * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional + * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional + * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional + * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * + * Return: 0 on success or error code on failure + */ +static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + int ret = 0; + char *iface_name; + QDF_STATUS status; + uint32_t ndp_qos_cfg; + enum nan_datapath_state state; + struct wlan_objmgr_vdev *nan_vdev; + struct nan_datapath_responder_req req = {0}; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + cfg80211_err("Interface name string is unavailable"); + return -EINVAL; + } + + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + /* Check if there is already an existing NAN interface */ + nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface %s not available", iface_name); + return -EINVAL; + } + + state = ucfg_nan_get_ndi_state(nan_vdev); + if (state == NAN_DATA_NDI_DELETED_STATE || + state == NAN_DATA_NDI_DELETING_STATE || + state == NAN_DATA_NDI_CREATING_STATE) { + cfg80211_err("Data request not allowed in current NDI state:%d", + state); + ret = -EAGAIN; + goto responder_req_failed; + } + + req.vdev = nan_vdev; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("Transaction ID is unavailable"); + ret = -EINVAL; + goto responder_req_failed; + } + req.transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]) { + cfg80211_err("Instance ID is unavailable"); + ret = -EINVAL; + goto responder_req_failed; + } + req.ndp_instance_id = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]) { + cfg80211_err("ndp_rsp is unavailable"); + ret = -EINVAL; + goto responder_req_failed; + } + req.ndp_rsp = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]); + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { + req.ndp_info.ndp_app_info_len = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); + if (req.ndp_info.ndp_app_info_len) { + req.ndp_info.ndp_app_info = + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); + } + } else { + cfg80211_debug("NDP app info is unavailable"); + } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) { + /* at present ndp config stores 4 bytes QOS info only */ + req.ndp_config.ndp_cfg_len = 4; + ndp_qos_cfg = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); + req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg; + } else { + cfg80211_debug("NDP config data is unavailable"); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] && + !tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { + cfg80211_err("PMK cannot be absent when CSID is present."); + ret = -EINVAL; + goto responder_req_failed; + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { + req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, + QDF_TRACE_LEVEL_DEBUG, + req.pmk.pmk, req.pmk.pmk_len); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { + req.ncs_sk_type = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); + + } + + cfg80211_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d, csid: %d", + wlan_vdev_get_id(nan_vdev), req.transaction_id, req.ndp_rsp, + req.ndp_instance_id, req.ndp_info.ndp_app_info_len, + req.ncs_sk_type); + + status = ucfg_nan_req_processor(nan_vdev, &req, NDP_RESPONDER_REQ); + ret = qdf_status_to_os_return(status); + +responder_req_failed: + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + + return ret; + +} + int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, const void *data, int data_len) { @@ -355,6 +487,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return os_if_nan_process_ndi_delete(psoc, tb); case QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: return os_if_nan_process_ndp_initiator_req(psoc, tb); + case QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: + return os_if_nan_process_ndp_responder_req(psoc, tb); default: cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); return -EINVAL; @@ -433,6 +567,72 @@ ndp_initiator_rsp_nla_failed: kfree_skb(vendor_event); } + +/* + * os_if_ndp_responder_rsp_handler() - NDP responder response handler + * @vdev: pointer to vdev object + * @rsp: response parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) + * + * Return: none + */ +static void os_if_ndp_responder_rsp_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_responder_rsp *rsp) +{ + uint16_t data_len; + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + if (!rsp) { + cfg80211_err("Invalid NDP Responder response"); + return; + } + + cfg80211_debug("NDP Responder,vdev id %d transaction_id %d status code: %d reason %d", + wlan_vdev_get_id(rsp->vdev), rsp->transaction_id, + rsp->status, rsp->reason); + data_len = 3 * sizeof(uint32_t) + sizeof(uint16_t) + + 4 * NLA_HDRLEN + NLMSG_HDRLEN; + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE)) + goto ndp_responder_rsp_nla_failed; + + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + rsp->transaction_id)) + goto ndp_responder_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + rsp->status)) + goto ndp_responder_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + rsp->reason)) + goto ndp_responder_rsp_nla_failed; + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; +ndp_responder_rsp_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + /** * os_if_ndp_indication_handler() - NDP indication handler * @vdev: pointer to vdev object @@ -911,6 +1111,9 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, case NDP_NEW_PEER: os_if_new_peer_ind_handler(vdev, msg); break; + case NDP_RESPONDER_RSP: + os_if_ndp_responder_rsp_handler(vdev, msg); + break; default: break; } From a0f6cfb91f025762da86d0287ab21bd1bf1f55b9 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:28 -0700 Subject: [PATCH 22/92] qcacmn: NDP_RESPONDER_REQ implementation Add implementation for NDP_RESPONDER_REQ. Change-Id: I27029eae88e0bc545c8444adf1342b2ec95f4d60 CRs-Fixed: 2014795 --- core/src/nan_main.c | 41 +++++++++++++++++++++++ dispatcher/src/nan_ucfg_api.c | 62 +++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 611af738e610..c8ff0dbf79bc 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -377,6 +377,42 @@ ndp_indication_failed: return status; } +static QDF_STATUS nan_handle_responder_rsp( + struct nan_datapath_responder_rsp *rsp, + struct wlan_objmgr_vdev **vdev) +{ + struct wlan_objmgr_psoc *psoc; + QDF_STATUS status = QDF_STATUS_SUCCESS; + struct nan_psoc_priv_obj *psoc_nan_obj; + + *vdev = rsp->vdev; + psoc = wlan_vdev_get_psoc(rsp->vdev); + if (!psoc) { + nan_err("psoc is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is null"); + return QDF_STATUS_E_NULL_VALUE; + } + + if (QDF_IS_STATUS_SUCCESS(rsp->status) && rsp->create_peer == true) { + status = psoc_nan_obj->cb_obj.add_ndi_peer( + wlan_vdev_get_id(rsp->vdev), + rsp->peer_mac_addr); + if (QDF_IS_STATUS_ERROR(status)) { + nan_err("Couldn't add ndi peer"); + rsp->status = QDF_STATUS_E_FAILURE; + } + } + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, rsp->vdev, + NDP_RESPONDER_RSP, rsp); + + return QDF_STATUS_SUCCESS; +} + QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) { QDF_STATUS status = QDF_STATUS_SUCCESS; @@ -407,6 +443,11 @@ QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) nan_handle_ndp_ind(pe_msg->bodyptr); break; } + case NDP_RESPONDER_RSP: + nan_handle_responder_rsp(pe_msg->bodyptr, &cmd.vdev); + cmd.cmd_type = WLAN_SER_CMD_NDP_RESP_REQ; + wlan_serialization_remove_cmd(&cmd); + break; default: nan_alert("Unhandled NDP event: %d", pe_msg->type); status = QDF_STATUS_E_NOSUPPORT; diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index c63fa076ac7a..cf0510564343 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -381,6 +381,65 @@ free_resources: return NULL; } +static struct nan_datapath_responder_req *ucfg_nan_copy_responder_req( + struct wlan_objmgr_vdev *vdev, + struct nan_datapath_responder_req *in_req) +{ + struct nan_datapath_responder_req *req; + + req = qdf_mem_malloc(sizeof(*req)); + if (!req) { + nan_alert("malloc failed"); + return NULL; + } + + qdf_mem_copy(req, in_req, sizeof(*req)); + if (in_req->ndp_config.ndp_cfg_len) { + req->ndp_config.ndp_cfg = + qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len); + if (!req->ndp_config.ndp_cfg) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->ndp_config.ndp_cfg, + in_req->ndp_config.ndp_cfg, + in_req->ndp_config.ndp_cfg_len); + } + + if (in_req->ndp_info.ndp_app_info_len) { + req->ndp_info.ndp_app_info = + qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len); + if (!req->ndp_info.ndp_app_info) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->ndp_info.ndp_app_info, + in_req->ndp_info.ndp_app_info, + in_req->ndp_info.ndp_app_info_len); + } + + if (in_req->pmk.pmk_len) { + req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len); + if (!req->pmk.pmk) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->pmk.pmk, in_req->pmk.pmk, + in_req->pmk.pmk_len); + } + + /* do not get ref here, rather take ref when request is activated */ + req->vdev = vdev; + return req; + +free_resources: + qdf_mem_free(req->pmk.pmk); + qdf_mem_free(req->ndp_info.ndp_app_info); + qdf_mem_free(req->ndp_config.ndp_cfg); + qdf_mem_free(req); + return NULL; +} + QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { @@ -397,6 +456,9 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, case NDP_INITIATOR_REQ: req = ucfg_nan_copy_intiator_req(vdev, in_req); break; + case NDP_RESPONDER_REQ: + req = ucfg_nan_copy_responder_req(vdev, in_req); + break; default: nan_err("in correct message req type: %d", req_type); return QDF_STATUS_E_INVAL; From 720b86499a90f0ce3358cb3e9b2e60c7a1e76e3a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:56 -0700 Subject: [PATCH 23/92] 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 5d286a9bebc4..2a95ab96b836 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 780272b6c77abd681cf0bf4887947d98eb8e0922 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:56 -0700 Subject: [PATCH 24/92] qcacmn: NDP_END_REQ implementation Add implementation of NDP_END_REQ. Change-Id: Ifa0bdcdee09c15c68bb12c63ba1157c71650c5bc CRs-Fixed: 2014795 --- src/os_if_nan.c | 265 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 0459f630c69c..681c01ce9c03 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -442,6 +442,61 @@ responder_req_failed: } +/** + * os_if_nan_process_ndp_end_req() - NDP end request handler + * @psoc: pointer to psoc object + * + * @tb: parsed NL attribute list + * tb includes following vendor attributes: + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID + * + * Return: 0 on success or error code on failure + */ +static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, + struct nlattr **tb) +{ + int ret = 0; + QDF_STATUS status; + struct wlan_objmgr_vdev *nan_vdev; + struct nan_datapath_end_req req = {0}; + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { + cfg80211_err("Transaction ID is unavailable"); + return -EINVAL; + } + req.transaction_id = + nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); + + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]) { + cfg80211_err("NDP instance ID array is unavailable"); + return -EINVAL; + } + + req.num_ndp_instances = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]) / + sizeof(uint32_t); + if (0 >= req.num_ndp_instances) { + cfg80211_err("Num NDP instances is 0"); + return -EINVAL; + } + req.ndp_ids = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]); + + cfg80211_debug("sending ndp_end_req to SME, transaction_id: %d", + req.transaction_id); + + nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface is not available"); + return -EINVAL; + } + + status = ucfg_nan_req_processor(nan_vdev, &req, NDP_END_REQ); + ret = qdf_status_to_os_return(status); + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + + return ret; +} + int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, const void *data, int data_len) { @@ -489,6 +544,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return os_if_nan_process_ndp_initiator_req(psoc, tb); case QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: return os_if_nan_process_ndp_responder_req(psoc, tb); + case QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: + return os_if_nan_process_ndp_end_req(psoc, tb); default: cfg80211_err("Unrecognized NDP vendor cmd %d", ndp_cmd_type); return -EINVAL; @@ -881,6 +938,169 @@ ndp_confirm_nla_failed: kfree_skb(vendor_event); } +/** + * os_if_ndp_end_rsp_handler() - NDP end response handler + * @vdev: pointer to vdev object + * @rsp_params: response parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE(4 bytest) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID (2 bytes) + * + * Return: none + */ +static void os_if_ndp_end_rsp_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_rsp_event *rsp) +{ + uint32_t data_len; + struct sk_buff *vendor_event; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + if (!rsp) { + cfg80211_err("Invalid ndp end response"); + return; + } + + data_len = NLMSG_HDRLEN + (4 * NLA_HDRLEN) + (3 * sizeof(uint32_t)) + + sizeof(uint16_t); + + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + rsp->status)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + rsp->reason)) + goto ndp_end_rsp_nla_failed; + + if (nla_put_u16(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + rsp->transaction_id)) + goto ndp_end_rsp_nla_failed; + + cfg80211_debug("NDP End rsp sent, transaction id: %d, status: %d, reason: %d", + rsp->transaction_id, rsp->status, rsp->reason); + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; + +ndp_end_rsp_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + +/** + * os_if_ndp_end_ind_handler() - NDP end indication handler + * @vdev: pointer to vdev object + * @ind_params: indication parameters + * + * Following vendor event is sent to cfg80211: + * QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD = + * QCA_WLAN_VENDOR_ATTR_NDP_END_IND (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY (4 * num of NDP Instances) + * + * Return: none + */ +static void os_if_ndp_end_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_indication_event *end_ind) +{ + QDF_STATUS status; + uint32_t data_len, i; + struct nan_callbacks cb_obj; + uint32_t *ndp_instance_array; + struct sk_buff *vendor_event; + struct wlan_objmgr_vdev *vdev_itr; + struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("failed to get callbacks"); + return; + } + + if (!end_ind) { + cfg80211_err("Invalid ndp end indication"); + return; + } + + ndp_instance_array = qdf_mem_malloc(end_ind->num_ndp_ids * + sizeof(*ndp_instance_array)); + if (!ndp_instance_array) { + cfg80211_err("Failed to allocate ndp_instance_array"); + return; + } + for (i = 0; i < end_ind->num_ndp_ids; i++) { + int idx = 0; + + ndp_instance_array[i] = end_ind->ndp_map[i].ndp_instance_id; + vdev_itr = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, + end_ind->ndp_map[i].vdev_id, WLAN_NAN_ID); + + if (vdev_itr == NULL) { + cfg80211_err("vdev not found for vdev_id: %d", + end_ind->ndp_map[i].vdev_id); + continue; + } + + idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev), + &end_ind->ndp_map[i].peer_ndi_mac_addr); + if (idx < 0) { + cfg80211_err("can't find addr: %pM in sta_ctx.", + &end_ind->ndp_map[i].peer_ndi_mac_addr); + continue; + } + /* save the value of active sessions on each peer */ + ucfg_nan_set_active_ndp_sessions(vdev, + end_ind->ndp_map[i].num_active_ndp_sessions, + idx); + } + + data_len = (sizeof(uint32_t)) + NLMSG_HDRLEN + (2 * NLA_HDRLEN) + + end_ind->num_ndp_ids * sizeof(*ndp_instance_array); + + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_END_IND)) + goto ndp_end_ind_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY, + end_ind->num_ndp_ids * sizeof(*ndp_instance_array), + ndp_instance_array)) + goto ndp_end_ind_nla_failed; + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + qdf_mem_free(ndp_instance_array); + return; + +ndp_end_ind_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); + qdf_mem_free(ndp_instance_array); +} + /** * os_if_new_peer_ind_handler() - NDP new peer indication handler * @adapter: pointer to adapter context @@ -925,6 +1145,42 @@ static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev, cfg80211_debug("vdev_id: %d, num_peers: %d", vdev_id, active_peers); } +/** + * os_if_peer_departed_ind_handler() - Handle NDP peer departed indication + * @adapter: pointer to adapter context + * @ind_params: indication parameters + * + * Return: none + */ +static void os_if_peer_departed_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_peer_ind *peer_ind) +{ + QDF_STATUS status; + struct nan_callbacks cb_obj; + uint8_t vdev_id = wlan_vdev_get_id(vdev); + struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); + uint32_t active_peers = ucfg_nan_get_active_peers(vdev); + + status = ucfg_nan_get_callbacks(psoc, &cb_obj); + if (QDF_IS_STATUS_ERROR(status)) { + cfg80211_err("failed to get callbacks"); + return; + } + + if (NULL == peer_ind) { + cfg80211_err("Invalid new NDP peer params"); + return; + } + cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d", + peer_ind->session_id, peer_ind->peer_mac_addr.bytes, + peer_ind->sta_id); + active_peers--; + ucfg_nan_set_active_peers(vdev, active_peers); + cb_obj.peer_departed_ind(vdev_id, peer_ind->sta_id, + &peer_ind->peer_mac_addr, + (active_peers == 0 ? true : false)); +} + /** * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler * @adapter: pointer to adapter context @@ -1114,6 +1370,15 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, case NDP_RESPONDER_RSP: os_if_ndp_responder_rsp_handler(vdev, msg); break; + case NDP_END_RSP: + os_if_ndp_end_rsp_handler(vdev, msg); + break; + case NDP_END_IND: + os_if_ndp_end_ind_handler(vdev, msg); + break; + case NDP_PEER_DEPARTED: + os_if_peer_departed_ind_handler(vdev, msg); + break; default: break; } From 57b2c5691691e31a1df1506f6b7436c1dab172b1 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 4 Apr 2017 19:41:56 -0700 Subject: [PATCH 25/92] qcacmn: NDP_END_REQ implementation Add implementation of NDP_END_REQ. Change-Id: Ifa0bdcdee09c15c68bb12c63ba1157c71650c5bc CRs-Fixed: 2014795 --- core/inc/nan_public_structs.h | 3 ++ core/src/nan_main.c | 60 ++++++++++++++++++++++++++++++++++- dispatcher/src/nan_ucfg_api.c | 39 +++++++++++++++++++++++ 3 files changed, 101 insertions(+), 1 deletion(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 6c6f94f020cf..4cd2785fdc3a 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -497,6 +497,9 @@ struct nan_callbacks { int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *); QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr); + void (*peer_departed_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, + bool); + void (*ndp_delete_peers)(struct peer_nan_datapath_map*, uint8_t); void (*delete_peers_by_addr)(uint8_t, struct qdf_mac_addr); }; diff --git a/core/src/nan_main.c b/core/src/nan_main.c index c8ff0dbf79bc..2aefbe335751 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -115,7 +115,6 @@ static void nan_req_incomplete(void *req, uint32_t cmdtype) static void nan_req_activated(void *in_req, uint32_t cmdtype) { uint32_t req_type; - QDF_STATUS status; struct wlan_objmgr_psoc *psoc; struct wlan_objmgr_vdev *vdev; struct wlan_lmac_if_nan_tx_ops *tx_ops; @@ -413,6 +412,57 @@ static QDF_STATUS nan_handle_responder_rsp( return QDF_STATUS_SUCCESS; } +static QDF_STATUS nan_handle_ndp_end_rsp( + struct nan_datapath_end_rsp_event *rsp, + struct wlan_objmgr_vdev **vdev) +{ + struct wlan_objmgr_psoc *psoc; + struct nan_psoc_priv_obj *psoc_nan_obj; + + *vdev = rsp->vdev; + psoc = wlan_vdev_get_psoc(rsp->vdev); + if (!psoc) { + nan_err("psoc is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, rsp->vdev, + NDP_END_RSP, rsp); + + return QDF_STATUS_SUCCESS; +} + +static QDF_STATUS nan_handle_end_ind( + struct nan_datapath_end_indication_event *ind) +{ + struct wlan_objmgr_psoc *psoc; + struct nan_psoc_priv_obj *psoc_nan_obj; + + psoc = wlan_vdev_get_psoc(ind->vdev); + if (!psoc) { + nan_err("psoc is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj->cb_obj.ndp_delete_peers(ind->ndp_map, ind->num_ndp_ids); + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ind->vdev, + NDP_END_IND, ind); + + return QDF_STATUS_SUCCESS; +} + QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) { QDF_STATUS status = QDF_STATUS_SUCCESS; @@ -448,6 +498,14 @@ QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) cmd.cmd_type = WLAN_SER_CMD_NDP_RESP_REQ; wlan_serialization_remove_cmd(&cmd); break; + case NDP_END_RSP: + nan_handle_ndp_end_rsp(pe_msg->bodyptr, &cmd.vdev); + cmd.cmd_type = WLAN_SER_CMD_NDP_DATA_END_INIT_REQ; + wlan_serialization_remove_cmd(&cmd); + break; + case NDP_END_IND: + nan_handle_end_ind(pe_msg->bodyptr); + break; default: nan_alert("Unhandled NDP event: %d", pe_msg->type); status = QDF_STATUS_E_NOSUPPORT; diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index cf0510564343..2f2d28c3a24b 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -440,6 +440,40 @@ free_resources: return NULL; } +static struct nan_datapath_end_req *ucfg_nan_copy_end_req( + struct wlan_objmgr_vdev *vdev, + struct nan_datapath_end_req *in_req) +{ + struct nan_datapath_end_req *req; + + req = qdf_mem_malloc(sizeof(*req)); + if (!req) { + nan_alert("malloc failed"); + return NULL; + } + + qdf_mem_copy(req, in_req, sizeof(*req)); + if (in_req->num_ndp_instances) { + req->ndp_ids = qdf_mem_malloc(sizeof(uint32_t) * + in_req->num_ndp_instances); + if (!req->ndp_ids) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->ndp_ids, in_req->ndp_ids, + sizeof(uint32_t) * in_req->num_ndp_instances); + } + + /* do not get ref here, rather take ref when request is activated */ + req->vdev = vdev; + return req; + +free_resources: + qdf_mem_free(req->ndp_ids); + qdf_mem_free(req); + return NULL; +} + QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { @@ -459,6 +493,9 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, case NDP_RESPONDER_REQ: req = ucfg_nan_copy_responder_req(vdev, in_req); break; + case NDP_END_REQ: + req = ucfg_nan_copy_end_req(vdev, in_req); + break; default: nan_err("in correct message req type: %d", req_type); return QDF_STATUS_E_INVAL; @@ -522,6 +559,7 @@ int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, psoc_obj->cb_obj.get_peer_idx = cb_obj->get_peer_idx; psoc_obj->cb_obj.new_peer_ind = cb_obj->new_peer_ind; + psoc_obj->cb_obj.peer_departed_ind = cb_obj->peer_departed_ind; return 0; } @@ -537,6 +575,7 @@ int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, } psoc_obj->cb_obj.add_ndi_peer = cb_obj->add_ndi_peer; + psoc_obj->cb_obj.ndp_delete_peers = cb_obj->ndp_delete_peers; psoc_obj->cb_obj.delete_peers_by_addr = cb_obj->delete_peers_by_addr; return 0; From f110ea5155768585d79703274d7e897bcbdaed11 Mon Sep 17 00:00:00 2001 From: Rajeev Kumar Date: Mon, 17 Apr 2017 17:00:41 -0700 Subject: [PATCH 26/92] 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 2a95ab96b836..07f278c71fef 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 b6304681916bdcb885935d3c5253b92ec61232b3 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Mon, 19 Jun 2017 14:52:52 -0700 Subject: [PATCH 27/92] qcacmn: Properly validate QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR Currently the QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR nla_policy specifies a type of NLA_STRING, but the underlying implementation expects a NUL-terminated string. Update the policy to correctly use a type of NLA_NUL_STRING with the len updated to remove the allocation needed for the terminating NUL. Change-Id: Ic73241511ab73ae63fd7c1a8d6422da91931919c CRs-Fixed: 2063588 --- src/os_if_nan.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 681c01ce9c03..fe443462908a 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -38,8 +38,8 @@ static const struct nla_policy vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { [QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD] = { .type = NLA_U32 }, [QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID] = { .type = NLA_U16 }, - [QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { .type = NLA_STRING, - .len = IFNAMSIZ }, + [QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { .type = NLA_NUL_STRING, + .len = IFNAMSIZ - 1 }, [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID] = { .type = NLA_U32 }, [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL] = { .type = NLA_U32 }, [QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR] = { From 61fb8171f04d0970acf239a89b34ffe789911060 Mon Sep 17 00:00:00 2001 From: Vivek Date: Fri, 23 Jun 2017 21:05:31 +0530 Subject: [PATCH 28/92] qcacmn: Remove psoc/pdev locks for trivial APIs Remove psoc/pdev locks from trivial API's. This follows the changes from which the lock requirement from few simple APIs are removed. Change-Id: Ib5769c2234c8d57f485c0eef5a4e3c61fa170508 CRs-Fixed: 2060880 --- core/src/nan_main.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 2aefbe335751..219e509968ce 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -57,9 +57,7 @@ struct nan_psoc_priv_obj *nan_get_psoc_priv_obj( nan_err("psoc is null"); return NULL; } - wlan_psoc_obj_lock(psoc); obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_NAN); - wlan_psoc_obj_unlock(psoc); return obj; } From e42381412267f4c03c0a9f8ae2c6ce7a10e050c1 Mon Sep 17 00:00:00 2001 From: Vivek Date: Wed, 21 Jun 2017 08:21:58 +0530 Subject: [PATCH 29/92] qcacmn: Remove vdev/peer locks for trivial APIs Remove vdev/peer locks from trivial API's. This follows the changes from which the lock requirement from few simple APIs are removed. Change-Id: I9972d51dfd1a42bdedbfd0fd4e67af03d030a1f5 CRs-Fixed: 2060880 --- core/src/nan_main.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 219e509968ce..9c11a809b296 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -41,9 +41,7 @@ struct nan_vdev_priv_obj *nan_get_vdev_priv_obj( nan_err("vdev is null"); return NULL; } - wlan_vdev_obj_lock(vdev); obj = wlan_objmgr_vdev_get_comp_private_obj(vdev, WLAN_UMAC_COMP_NAN); - wlan_vdev_obj_unlock(vdev); return obj; } From 7981ec30cb4a5345fa6bcdb2c701bdee2f41c2db Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 30/92] 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 --- inc/os_if_nan.h | 7 ++++ src/os_if_nan.c | 109 +++++++++++++++++++++++++++++++++--------------- 2 files changed, 82 insertions(+), 34 deletions(-) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index a0355e7a7025..31e56513fae0 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -37,6 +37,9 @@ struct wlan_objmgr_vdev; #define NDP_PMK_LEN 32 #define NDP_SCID_BUF_LEN 256 #define NDP_NUM_INSTANCE_ID 255 +#define NAN_MAX_SERVICE_NAME_LEN 255 +#define NAN_PASSPHRASE_MIN_LEN 8 +#define NAN_PASSPHRASE_MAX_LEN 63 /** * enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters @@ -60,6 +63,8 @@ struct wlan_objmgr_vdev; * @QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE: Cipher Suit ID * @QCA_WLAN_VENDOR_ATTR_NDP_PMK: Pairwise Master Key * @QCA_WLAN_VENDOR_ATTR_NDP_SCID: Security Context ID + * @QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - pass phrase + * @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - service name */ enum qca_wlan_vendor_attr_ndp_params { QCA_WLAN_VENDOR_ATTR_NDP_PARAM_INVALID = 0, @@ -83,6 +88,8 @@ enum qca_wlan_vendor_attr_ndp_params { QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE, QCA_WLAN_VENDOR_ATTR_NDP_PMK, QCA_WLAN_VENDOR_ATTR_NDP_SCID, + QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE, + QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX = diff --git a/src/os_if_nan.c b/src/os_if_nan.c index fe443462908a..31b7a00dde85 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -65,6 +65,10 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE] = { .type = NLA_U32 }, [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE] = { .type = NLA_BINARY, + .len = NAN_PASSPHRASE_MAX_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME] = { .type = NLA_BINARY, + .len = NAN_MAX_SERVICE_NAME_LEN }, }; static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, @@ -169,6 +173,67 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, return cb_obj.ndi_delete(vdev_id, iface_name, transaction_id); } +/** + * os_if_nan_parse_security_params() - parse vendor attributes for security + * params. + * @tb: parsed NL attribute list + * @ncs_sk_type: out parameter to populate ncs_sk_type + * @pmk: out parameter to populate pmk + * @passphrase: out parameter to populate passphrase + * @service_name: out parameter to populate service_name + * + * Return: 0 on success or error code on failure + */ +static int os_if_nan_parse_security_params(struct nlattr **tb, + uint32_t *ncs_sk_type, struct nan_datapath_pmk *pmk, + struct ndp_passphrase *passphrase, + struct ndp_service_name *service_name) +{ + if (!ncs_sk_type || !pmk || !passphrase || !service_name) { + cfg80211_err("out buffers for one ore more parameters is null"); + return -EINVAL; + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { + *ncs_sk_type = + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { + pmk->pmk_len = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + pmk->pmk = + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + cfg80211_err("pmk len: %d", pmk->pmk_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, + pmk->pmk, pmk->pmk_len); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]) { + passphrase->passphrase_len = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]); + passphrase->passphrase = + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]); + cfg80211_err("passphrase len: %d", passphrase->passphrase_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, + passphrase->passphrase, passphrase->passphrase_len); + } + + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]) { + service_name->service_name_len = + nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]); + service_name->service_name = + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]); + cfg80211_err("service_name len: %d", + service_name->service_name_len); + QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, + service_name->service_name, + service_name->service_name_len); + } + + return 0; +} + /** * os_if_nan_process_ndp_initiator_req() - NDP initiator request handler * @ctx: hdd context @@ -185,6 +250,8 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - optional * * Return: 0 on success or error code on failure */ @@ -276,27 +343,13 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); } - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] && - !tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { - cfg80211_err("PMK cannot be absent when CSID is present."); + if (os_if_nan_parse_security_params(tb, &req.ncs_sk_type, &req.pmk, + &req.passphrase, &req.service_name)) { + cfg80211_err("inconsistent security params in request."); ret = -EINVAL; goto initiator_req_failed; } - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { - req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); - req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, - QDF_TRACE_LEVEL_DEBUG, - req.pmk.pmk, req.pmk.pmk_len); - } - - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { - req.ncs_sk_type = - nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); - - } - cfg80211_debug("vdev_id: %d, transaction_id: %d, channel: %d, service_instance_id: %d, ndp_app_info_len: %d, csid: %d, peer_discovery_mac_addr: %pM", wlan_vdev_get_id(nan_vdev), req.transaction_id, req.channel, req.service_instance_id, req.ndp_info.ndp_app_info_len, @@ -324,6 +377,8 @@ initiator_req_failed: * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - optional * * Return: 0 on success or error code on failure */ @@ -406,27 +461,13 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, cfg80211_debug("NDP config data is unavailable"); } - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] && - !tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { - cfg80211_err("PMK cannot be absent when CSID is present."); + if (os_if_nan_parse_security_params(tb, &req.ncs_sk_type, &req.pmk, + &req.passphrase, &req.service_name)) { + cfg80211_err("inconsistent security params in request."); ret = -EINVAL; goto responder_req_failed; } - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { - req.pmk.pmk = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); - req.pmk.pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); - QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, - QDF_TRACE_LEVEL_DEBUG, - req.pmk.pmk, req.pmk.pmk_len); - } - - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { - req.ncs_sk_type = - nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); - - } - cfg80211_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d, csid: %d", wlan_vdev_get_id(nan_vdev), req.transaction_id, req.ndp_rsp, req.ndp_instance_id, req.ndp_info.ndp_app_info_len, From a5fdea9371bf088cd3545724f33198af476b589a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 31/92] 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 --- core/inc/nan_public_structs.h | 31 +++++++++++++++++- core/src/nan_main.c | 4 +++ dispatcher/src/nan_ucfg_api.c | 62 +++++++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 1 deletion(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 4cd2785fdc3a..7f1f15487b39 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -229,6 +229,28 @@ struct nan_datapath_scid { uint8_t *scid; }; +/** + * struct ndp_passphrase - structure to hold passphrase + * @passphrase_len: length of passphrase + * @passphrase: buffer containing passphrase + * + */ +struct ndp_passphrase { + uint32_t passphrase_len; + uint8_t *passphrase; +}; + +/** + * struct ndp_service_name - structure to hold service_name + * @service_name_len: length of service_name + * @service_name: buffer containing service_name + * + */ +struct ndp_service_name { + uint32_t service_name_len; + uint8_t *service_name; +}; + /** * struct peer_nan_datapath_map - mapping of NDP instances to peer to VDEV * @vdev_id: session id of the interface over which ndp is being created @@ -295,7 +317,8 @@ struct nan_datapath_inf_delete_rsp { * @ndp_info: ndp application info * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 * @pmk: pairwise master key - * + * @passphrase: passphrase + * @service_name: service name */ struct nan_datapath_initiator_req { struct wlan_objmgr_vdev *vdev; @@ -309,6 +332,8 @@ struct nan_datapath_initiator_req { struct nan_datapath_cfg ndp_config; struct nan_datapath_app_info ndp_info; struct nan_datapath_pmk pmk; + struct ndp_passphrase passphrase; + struct ndp_service_name service_name; }; /** @@ -339,6 +364,8 @@ struct nan_datapath_initiator_rsp { * @ndp_info: ndp application info * @pmk: pairwise master key * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 + * @passphrase: passphrase + * @service_name: service name * */ struct nan_datapath_responder_req { @@ -350,6 +377,8 @@ struct nan_datapath_responder_req { struct nan_datapath_app_info ndp_info; struct nan_datapath_pmk pmk; uint32_t ncs_sk_type; + struct ndp_passphrase passphrase; + struct ndp_service_name service_name; }; /** diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 9c11a809b296..9060f7b27645 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -74,6 +74,8 @@ void nan_release_cmd(void *in_req, uint32_t req_type) qdf_mem_free(req->pmk.pmk); qdf_mem_free(req->ndp_info.ndp_app_info); qdf_mem_free(req->ndp_config.ndp_cfg); + qdf_mem_free(req->passphrase.passphrase); + qdf_mem_free(req->service_name.service_name); break; } case NDP_RESPONDER_REQ: { @@ -82,6 +84,8 @@ void nan_release_cmd(void *in_req, uint32_t req_type) qdf_mem_free(req->pmk.pmk); qdf_mem_free(req->ndp_info.ndp_app_info); qdf_mem_free(req->ndp_config.ndp_cfg); + qdf_mem_free(req->passphrase.passphrase); + qdf_mem_free(req->service_name.service_name); break; } case NDP_END_REQ: { diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 2f2d28c3a24b..2e839b3ea755 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -369,11 +369,42 @@ static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req( in_req->pmk.pmk_len); } + if (in_req->passphrase.passphrase_len) { + out_req->passphrase.passphrase = + qdf_mem_malloc(in_req->passphrase.passphrase_len); + if (NULL == out_req->passphrase.passphrase) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(out_req->passphrase.passphrase, + in_req->passphrase.passphrase, + in_req->passphrase.passphrase_len); + } + + if (in_req->service_name.service_name_len) { + out_req->service_name.service_name = + qdf_mem_malloc(in_req->service_name.service_name_len); + if (NULL == out_req->service_name.service_name) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(out_req->service_name.service_name, + in_req->service_name.service_name, + in_req->service_name.service_name_len); + } + + nan_debug("pmk_len: %d, passphrase_len: %d, service_name_len: %d", + out_req->pmk.pmk_len, + out_req->passphrase.passphrase_len, + out_req->service_name.service_name_len); + /* do not get ref here, rather take ref when request is activated */ out_req->vdev = vdev; return out_req; free_resources: + qdf_mem_free(out_req->passphrase.passphrase); + qdf_mem_free(out_req->service_name.service_name); qdf_mem_free(out_req->pmk.pmk); qdf_mem_free(out_req->ndp_info.ndp_app_info); qdf_mem_free(out_req->ndp_config.ndp_cfg); @@ -428,11 +459,42 @@ static struct nan_datapath_responder_req *ucfg_nan_copy_responder_req( in_req->pmk.pmk_len); } + if (in_req->passphrase.passphrase_len) { + req->passphrase.passphrase = + qdf_mem_malloc(in_req->passphrase.passphrase_len); + if (NULL == req->passphrase.passphrase) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->passphrase.passphrase, + in_req->passphrase.passphrase, + in_req->passphrase.passphrase_len); + } + + if (in_req->service_name.service_name_len) { + req->service_name.service_name = + qdf_mem_malloc(in_req->service_name.service_name_len); + if (NULL == req->service_name.service_name) { + nan_alert("malloc failed"); + goto free_resources; + } + qdf_mem_copy(req->service_name.service_name, + in_req->service_name.service_name, + in_req->service_name.service_name_len); + } + + nan_debug("pmk_len: %d, passphrase_len: %d, service_name_len: %d", + req->pmk.pmk_len, + req->passphrase.passphrase_len, + req->service_name.service_name_len); + /* do not get ref here, rather take ref when request is activated */ req->vdev = vdev; return req; free_resources: + qdf_mem_free(req->passphrase.passphrase); + qdf_mem_free(req->service_name.service_name); qdf_mem_free(req->pmk.pmk); qdf_mem_free(req->ndp_info.ndp_app_info); qdf_mem_free(req->ndp_config.ndp_cfg); From c58bb3e18e54e0380b97cdcf5e9fbfae2722e06b Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 32/92] 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 07f278c71fef..2797a3f5b956 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 5d12cbaf80a7f585398a53c9e8e21452beeb8a90 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Mon, 3 Jul 2017 14:38:16 -0700 Subject: [PATCH 33/92] qcacmn: Allow nan data interface delete with peers attached Service layer was not allowed to delete NDI if there are active NDP sessions (peers). Service layer is expected to delete the active NDP sessions before issuing NDI delete. However, that is not guaranteed to happen. Hence allowing internal cleanup to happen by allowing the command to firmware. Change-Id: Iab9bc3bca431475792c164d16cdd18be2f346188 CRs-Fixed: 2072505 --- src/os_if_nan.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 31b7a00dde85..9facb972c7c2 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -158,11 +158,9 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); /* check if there are active peers on the adapter */ - if (num_peers) { - cfg80211_err("NDP peers active: %d, cannot delete NDI", + if (num_peers) + cfg80211_err("NDP peers active: %d, active NDPs may not be terminated", num_peers); - return -EINVAL; - } status = ucfg_nan_get_callbacks(psoc, &cb_obj); if (QDF_IS_STATUS_ERROR(status)) { From b0a5c407e2002c7df8b97d91f14c6b8f44e21372 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Mon, 3 Jul 2017 16:10:05 -0700 Subject: [PATCH 34/92] qcacmn: Fix transaction id descrepancy during NDI create Driver truncated the transaction id to 8-bits from 16-bit value causing the descrepancy in transaction id exchange during NDI create. Change-Id: I502f422620411c39bd0e75f06e9b7200bfea24ae CRs-Fixed: 2072511 --- src/os_if_nan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 31b7a00dde85..5c02c29143a2 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -1247,7 +1247,7 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, bool create_fail = false; struct nan_callbacks cb_obj; struct sk_buff *vendor_event; - uint8_t create_transaction_id; + uint16_t create_transaction_id; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); uint32_t create_status = NAN_DATAPATH_RSP_STATUS_ERROR; From 25b18872678414ba207bd7e653b791effe8941b8 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Mon, 3 Jul 2017 13:00:48 -0700 Subject: [PATCH 35/92] qcacmn: Make ndp channel config parameter optional The ndp channel config has no meaning if ndp channel itself is optional. Host will send ndp channel config as "optional" to FW if it is missing in the ndp command. Change-Id: I59e245f3fb05ae35aa185fba7bad09608f5334c8 CRs-Fixed: 2072502 --- src/os_if_nan.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 31b7a00dde85..f4d92204f794 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -296,16 +296,17 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, req.transaction_id = nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]) + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]) { req.channel = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL]); - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]) { - req.channel_cfg = - nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]); - } else { - cfg80211_err("Channel config is unavailable"); - ret = -EINVAL; - goto initiator_req_failed; + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]) { + req.channel_cfg = nla_get_u32( + tb[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG]); + } else { + cfg80211_err("Channel config is unavailable"); + ret = -EINVAL; + goto initiator_req_failed; + } } if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID]) { From 5d1f85ccb85b17a84397e8f1e649a3b044c88ed6 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 36/92] 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/os_if_nan.c | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index f4d92204f794..92e4875998a2 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -140,7 +140,7 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, return -EINVAL; } - nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, WLAN_NAN_ID); if (!nan_vdev) { cfg80211_err("Nan datapath interface is not present"); return -EINVAL; @@ -151,9 +151,8 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, vdev_id = wlan_vdev_get_id(nan_vdev); num_peers = ucfg_nan_get_active_peers(nan_vdev); /* - * wlan_objmgr_get_vdev_by_opmode_from_psoc API will have incremented - * ref count - decrement here since vdev returned by that api is not - * used any more + * wlan_util_get_vdev_by_ifname increments ref count + * decrement here since vdev returned by that api is not used any more */ wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); @@ -272,12 +271,17 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, } iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); - nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, WLAN_NAN_ID); if (!nan_vdev) { cfg80211_err("NAN data interface %s not available", iface_name); return -EINVAL; } + if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { + cfg80211_err("Interface found is not NDI"); + return -EINVAL; + } + state = ucfg_nan_get_ndi_state(nan_vdev); if (state == NAN_DATA_NDI_DELETED_STATE || state == NAN_DATA_NDI_DELETING_STATE || @@ -401,12 +405,17 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); /* Check if there is already an existing NAN interface */ - nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, WLAN_NAN_ID); if (!nan_vdev) { cfg80211_err("NAN data interface %s not available", iface_name); return -EINVAL; } + if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { + cfg80211_err("Interface found is not NDI"); + return -EINVAL; + } + state = ucfg_nan_get_ndi_state(nan_vdev); if (state == NAN_DATA_NDI_DELETED_STATE || state == NAN_DATA_NDI_DELETING_STATE || @@ -526,7 +535,8 @@ static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, cfg80211_debug("sending ndp_end_req to SME, transaction_id: %d", req.transaction_id); - nan_vdev = ucfg_nan_get_ndi_vdev(psoc, WLAN_NAN_ID); + nan_vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, QDF_NDI_MODE, + WLAN_NAN_ID); if (!nan_vdev) { cfg80211_err("NAN data interface is not available"); return -EINVAL; From 703c67d7a64e848cd7b8aa329e1ba1278725ff29 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 37/92] 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 --- core/src/nan_api.c | 33 ++------------------------------- core/src/nan_main_i.h | 2 -- dispatcher/inc/nan_ucfg_api.h | 10 ---------- dispatcher/src/nan_ucfg_api.c | 20 -------------------- 4 files changed, 2 insertions(+), 63 deletions(-) diff --git a/core/src/nan_api.c b/core/src/nan_api.c index 23b0bae32189..fe251a975864 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -88,37 +88,21 @@ static QDF_STATUS nan_psoc_obj_destroyed_notification( static QDF_STATUS nan_vdev_obj_created_notification( struct wlan_objmgr_vdev *vdev, void *arg_list) { - struct wlan_objmgr_psoc *psoc; struct nan_vdev_priv_obj *nan_obj; - struct nan_psoc_priv_obj *nan_psoc_obj; QDF_STATUS status = QDF_STATUS_SUCCESS; + nan_debug("nan_vdev_create_notif called"); if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { nan_debug("not a ndi vdev. do nothing"); return QDF_STATUS_SUCCESS; } - nan_debug("nan_vdev_create_notif called"); - - psoc = wlan_vdev_get_psoc(vdev); - if (!psoc) { - nan_err("psoc is null"); - return QDF_STATUS_E_NULL_VALUE; - } - - nan_psoc_obj = nan_get_psoc_priv_obj(psoc); - if (!nan_psoc_obj) { - nan_err("nan_psoc_obj is null"); - return QDF_STATUS_E_NULL_VALUE; - } - nan_obj = qdf_mem_malloc(sizeof(*nan_obj)); if (!nan_obj) { nan_err("malloc failed for nan prv obj"); return QDF_STATUS_E_NOMEM; } - nan_psoc_obj->vdev = vdev; qdf_spinlock_create(&nan_obj->lock); status = wlan_objmgr_vdev_component_obj_attach(vdev, WLAN_UMAC_COMP_NAN, (void *)nan_obj, @@ -140,28 +124,15 @@ nan_vdev_notif_failed: static QDF_STATUS nan_vdev_obj_destroyed_notification( struct wlan_objmgr_vdev *vdev, void *arg_list) { - struct wlan_objmgr_psoc *psoc; struct nan_vdev_priv_obj *nan_obj; - struct nan_psoc_priv_obj *nan_psoc_obj; QDF_STATUS status = QDF_STATUS_SUCCESS; + nan_debug("nan_vdev_delete_notif called"); if (wlan_vdev_mlme_get_opmode(vdev) != QDF_NDI_MODE) { nan_debug("not a ndi vdev. do nothing"); return QDF_STATUS_SUCCESS; } - nan_debug("nan_vdev_delete_notif called"); - psoc = wlan_vdev_get_psoc(vdev); - if (psoc) { - nan_psoc_obj = nan_get_psoc_priv_obj(psoc); - if (nan_psoc_obj) - nan_psoc_obj->vdev = NULL; - else - nan_err("nan_psoc_obj is null"); - } else { - nan_err("psoc is null"); - } - nan_obj = nan_get_vdev_priv_obj(vdev); if (!nan_obj) { nan_err("nan_obj is NULL"); diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index ca467ef91d16..7d2d770ce37c 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -59,12 +59,10 @@ struct scheduler_msg; * struct nan_psoc_priv_obj - nan private psoc obj * @lock: lock to be acquired before reading or writing to object * @cb_obj: struct contaning callback pointers - * @vdev: ndi vdev */ struct nan_psoc_priv_obj { qdf_spinlock_t lock; struct nan_callbacks cb_obj; - struct wlan_objmgr_vdev *vdev; }; /** diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index feb002f58bbf..7e9f16c0dcfb 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.h @@ -173,16 +173,6 @@ uint32_t ucfg_nan_get_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev); QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); -/** - * ucfg_nan_get_ndi_vdev: ucfg API get ndi vdev from psoc - * @psoc: psoc obj pointer - * @dbg_id: component id that will be owner of reference - * - * Return: vdev object pointer on success, null otherwise - */ -struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, - wlan_objmgr_ref_dbgid dbg_id); - /** * ucfg_nan_req_processor: ucfg API to be called from HDD/OS_IF to * process nan datapath initiator request from userspace diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 2e839b3ea755..32d7e2f61643 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -302,26 +302,6 @@ inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_SUCCESS; } -struct wlan_objmgr_vdev *ucfg_nan_get_ndi_vdev(struct wlan_objmgr_psoc *psoc, - wlan_objmgr_ref_dbgid dbg_id) -{ - QDF_STATUS status; - struct nan_psoc_priv_obj *psoc_obj = nan_get_psoc_priv_obj(psoc); - - if (!psoc_obj) { - nan_err("nan psoc priv object is NULL"); - return NULL; - } - - status = wlan_objmgr_vdev_try_get_ref(psoc_obj->vdev, dbg_id); - if (QDF_IS_STATUS_ERROR(status)) { - nan_err("could not get vdev ref. vdev may have been deleted"); - return NULL; - } - - return psoc_obj->vdev; -} - static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req( struct wlan_objmgr_vdev *vdev, struct nan_datapath_initiator_req *in_req) From 8e7fc37d2333b67cd485ca97f185316e2e70e7b9 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 30 Jun 2017 10:48:48 -0700 Subject: [PATCH 38/92] 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 2797a3f5b956..4872e3cd496d 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 fabadbbf6a00c32b36fee6768bab60be9107696b Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Mon, 3 Jul 2017 14:52:07 -0700 Subject: [PATCH 39/92] qcacmn: Check NAN iface with same name before creating another one There were some corner cases reported in which NDIs are getting created with same name. Providing fix for the same. Change-Id: I84ea80580faa44809e257d3b17645808637b5d51 CRs-Fixed: 2072509 --- src/os_if_nan.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 92e4875998a2..d65a1c6bc0a9 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -32,6 +32,7 @@ #include "wlan_objmgr_psoc_obj.h" #include "wlan_objmgr_pdev_obj.h" #include "wlan_objmgr_vdev_obj.h" +#include "wlan_utility.h" /* NLA policy */ static const struct nla_policy @@ -87,6 +88,14 @@ static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, } iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, WLAN_NAN_ID); + if (nan_vdev) { + cfg80211_err("NAN data interface %s is already present", + iface_name); + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + return -EEXIST; + } + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { cfg80211_err("transaction id is unavailable"); return -EINVAL; From b4270e8aa41ef9e7d568b4ae087037cefcc0a8cd Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Thu, 17 Aug 2017 17:22:34 -0700 Subject: [PATCH 40/92] qcacmn: Add wrapper for nla_parse() The Linux kernel version 4.12 introduced an API change to nla_parse(). Add conditional compilation to call nla_parse with the correct parameters based on the version of the linux kernel being compiled against. Change-Id: Ie904d217a42a2396f8245251a9c90a15dac2c0c9 CRs-Fixed: 2093354 --- src/os_if_nan.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 7820c83cd8c4..1f2269a2c400 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -564,8 +564,8 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1]; char *iface_name; - if (nla_parse(tb, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX, - data, data_len, vendor_attr_policy)) { + if (wlan_cfg80211_nla_parse(tb, QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX, + data, data_len, vendor_attr_policy)) { cfg80211_err("Invalid NDP vendor command attributes"); return -EINVAL; } From dfc120c1665e1ffaea83ea4a7bcd8e8fc4dd1a45 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 2 Nov 2017 17:06:57 -0700 Subject: [PATCH 41/92] qcacmn: Fix nan_release_cmd Fix nan_release_cmd to take serialization command type. Change-Id: I1f8ba74b4630c03dacda3bf294526a0f066d3c32 CRs-Fixed: 2137432 --- core/src/nan_main.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 9060f7b27645..7c0d0b8f8807 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -60,15 +60,15 @@ struct nan_psoc_priv_obj *nan_get_psoc_priv_obj( return obj; } -void nan_release_cmd(void *in_req, uint32_t req_type) +void nan_release_cmd(void *in_req, uint32_t cmdtype) { struct wlan_objmgr_vdev *vdev = NULL; if (!in_req) return; - switch (req_type) { - case NDP_INITIATOR_REQ: { + switch (cmdtype) { + case WLAN_SER_CMD_NDP_INIT_REQ: { struct nan_datapath_initiator_req *req = in_req; vdev = req->vdev; qdf_mem_free(req->pmk.pmk); @@ -78,7 +78,7 @@ void nan_release_cmd(void *in_req, uint32_t req_type) qdf_mem_free(req->service_name.service_name); break; } - case NDP_RESPONDER_REQ: { + case WLAN_SER_CMD_NDP_RESP_REQ: { struct nan_datapath_responder_req *req = in_req; vdev = req->vdev; qdf_mem_free(req->pmk.pmk); @@ -88,14 +88,14 @@ void nan_release_cmd(void *in_req, uint32_t req_type) qdf_mem_free(req->service_name.service_name); break; } - case NDP_END_REQ: { + case WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: { struct nan_datapath_end_req *req = in_req; vdev = req->vdev; qdf_mem_free(req->ndp_ids); break; } default: - nan_err("invalid req type: %d", req_type); + nan_err("invalid req type: %d", cmdtype); break; } @@ -245,6 +245,7 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) cmd.source = WLAN_UMAC_COMP_NAN; cmd.is_high_priority = false; cmd.cmd_timeout_duration = 30000 /* 30 sec for now. TBD */; + nan_debug("cmd_type: %d", cmd.cmd_type); status = wlan_serialization_request(&cmd); /* following is TBD */ From 779725f445b72164573b1a64724b6bdb32f94710 Mon Sep 17 00:00:00 2001 From: Mukul Sharma Date: Fri, 3 Nov 2017 19:26:54 +0530 Subject: [PATCH 42/92] 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 4872e3cd496d..3b5c6642a16e 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 6f55531d04ae5583007ba11316b2fa1747dd5909 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 21 Dec 2017 11:30:40 -0800 Subject: [PATCH 43/92] qcacmn: Avoid null pointer dereference and OOB access Avoid possible null pointer dereferece and out of bound access in NAN component. Change-Id: I40ba4e340e34e8975c782c0a6329322e3c151326 CRs-Fixed: 2160751 --- dispatcher/src/nan_ucfg_api.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 32d7e2f61643..d01f00dddb18 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -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 @@ -109,8 +109,8 @@ inline QDF_STATUS ucfg_nan_set_active_ndp_sessions( return QDF_STATUS_E_NULL_VALUE; } - if (idx > MAX_PEERS) { - nan_err("peer_idx(%d) is greater than MAX(%d) is null", + if (idx >= MAX_PEERS) { + nan_err("peer_idx(%d), MAX(%d)", idx, MAX_PEERS); return QDF_STATUS_E_NULL_VALUE; } @@ -133,8 +133,8 @@ inline uint32_t ucfg_nan_get_active_ndp_sessions(struct wlan_objmgr_vdev *vdev, return 0; } - if (idx > MAX_PEERS) { - nan_err("peer_idx(%d) is greater than MAX(%d) is null", + if (idx >= MAX_PEERS) { + nan_err("peer_idx(%d), MAX(%d)", idx, MAX_PEERS); return 0; } From df0ab768a38edb411f3dcea40378a750780b89e0 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 21 Dec 2017 11:30:40 -0800 Subject: [PATCH 44/92] qcacmn: Avoid null pointer dereference and OOB access Avoid possible null pointer dereferece and out of bound access in NAN component. Change-Id: I40ba4e340e34e8975c782c0a6329322e3c151326 CRs-Fixed: 2160751 --- src/os_if_nan.c | 99 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 68 insertions(+), 31 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 1f2269a2c400..23b86fb01497 100644 --- a/src/os_if_nan.c +++ b/src/os_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 @@ -772,12 +772,14 @@ ndp_responder_rsp_nla_failed: static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, struct nan_datapath_indication_event *event) { + uint8_t *ifname; uint16_t data_len; + uint8_t ifname_len; uint32_t ndp_qos_config; struct sk_buff *vendor_event; + enum nan_datapath_state state; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); - enum nan_datapath_state state; if (!event) { cfg80211_err("Invalid NDP Indication"); @@ -796,9 +798,20 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, return; } - data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + IFNAMSIZ + - event->ndp_info.ndp_app_info_len + event->scid.scid_len + - (10 * NLA_HDRLEN) + NLMSG_HDRLEN; + ifname = wlan_util_vdev_get_if_name(vdev); + if (!ifname) { + cfg80211_err("ifname is null"); + return; + } + ifname_len = qdf_str_len(ifname); + if (ifname_len > IFNAMSIZ) { + cfg80211_err("ifname(%d) too long", ifname_len); + return; + } + + data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + + ifname_len + event->ndp_info.ndp_app_info_len + + event->scid.scid_len + (10 * NLA_HDRLEN) + NLMSG_HDRLEN; /* notify response to the upper layer */ vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, @@ -811,44 +824,44 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, } if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, - QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND)) + QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND)) goto ndp_indication_nla_failed; if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, - IFNAMSIZ, "nan0"/* adapter->dev->name - fetch dev name */)) + ifname_len, ifname)) goto ndp_indication_nla_failed; if (nla_put_u32(vendor_event, - QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID, - event->service_instance_id)) + QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID, + event->service_instance_id)) goto ndp_indication_nla_failed; if (nla_put(vendor_event, - QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, - QDF_MAC_ADDR_SIZE, event->peer_mac_addr.bytes)) + QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, + QDF_MAC_ADDR_SIZE, event->peer_mac_addr.bytes)) goto ndp_indication_nla_failed; if (nla_put(vendor_event, - QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, - QDF_MAC_ADDR_SIZE, event->peer_discovery_mac_addr.bytes)) + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, + QDF_MAC_ADDR_SIZE, event->peer_discovery_mac_addr.bytes)) goto ndp_indication_nla_failed; if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, - event->ndp_instance_id)) + event->ndp_instance_id)) goto ndp_indication_nla_failed; if (event->ndp_info.ndp_app_info_len) if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, - event->ndp_info.ndp_app_info_len, - event->ndp_info.ndp_app_info)) + event->ndp_info.ndp_app_info_len, + event->ndp_info.ndp_app_info)) goto ndp_indication_nla_failed; if (event->ndp_config.ndp_cfg_len) { ndp_qos_config = *((uint32_t *)event->ndp_config.ndp_cfg); /* at present ndp config stores 4 bytes QOS info only */ if (nla_put_u32(vendor_event, - QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS, - ndp_qos_config)) + QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS, + ndp_qos_config)) goto ndp_indication_nla_failed; } @@ -859,15 +872,15 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, goto ndp_indication_nla_failed; if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SCID, - event->scid.scid_len, - event->scid.scid)) + event->scid.scid_len, + event->scid.scid)) goto ndp_indication_nla_failed; cfg80211_debug("csid: %d, scid_len: %d", - event->ncs_sk_type, event->scid.scid_len); + event->ncs_sk_type, event->scid.scid_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG, - event->scid.scid, event->scid.scid_len); + event->scid.scid, event->scid.scid_len); } cfg80211_vendor_event(vendor_event, GFP_ATOMIC); @@ -898,8 +911,10 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, struct nan_datapath_confirm_event *ndp_confirm) { int idx = 0; + uint8_t *ifname; uint32_t data_len; QDF_STATUS status; + uint8_t ifname_len; uint32_t ndp_qos_config = 0; struct sk_buff *vendor_event; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); @@ -933,7 +948,18 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, idx); } - data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + IFNAMSIZ + + ifname = wlan_util_vdev_get_if_name(vdev); + if (!ifname) { + cfg80211_err("ifname is null"); + return; + } + ifname_len = qdf_str_len(ifname); + if (ifname_len > IFNAMSIZ) { + cfg80211_err("ifname(%d) too long", ifname_len); + return; + } + + data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + ifname_len + + NLMSG_HDRLEN + (7 * NLA_HDRLEN) + ndp_confirm->ndp_info.ndp_app_info_len; @@ -957,14 +983,15 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, goto ndp_confirm_nla_failed; if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, - QDF_MAC_ADDR_SIZE, ndp_confirm->peer_ndi_mac_addr.bytes)) + QDF_MAC_ADDR_SIZE, ndp_confirm->peer_ndi_mac_addr.bytes)) goto ndp_confirm_nla_failed; if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, - IFNAMSIZ, "nan0" /* TBD adapter->dev->name - fetch name */)) + ifname_len, ifname)) goto ndp_confirm_nla_failed; - if (ndp_confirm->ndp_info.ndp_app_info_len && nla_put(vendor_event, + if (ndp_confirm->ndp_info.ndp_app_info_len && + nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, ndp_confirm->ndp_info.ndp_app_info_len, ndp_confirm->ndp_info.ndp_app_info)) @@ -982,10 +1009,10 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, cfg80211_vendor_event(vendor_event, GFP_ATOMIC); cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM, ndp_cfg: %d, rsp_code: %d, reason_code: %d", - ndp_confirm->ndp_instance_id, - ndp_confirm->peer_ndi_mac_addr.bytes, - ndp_qos_config, ndp_confirm->rsp_code, - ndp_confirm->reason_code); + ndp_confirm->ndp_instance_id, + ndp_confirm->peer_ndi_mac_addr.bytes, + ndp_qos_config, ndp_confirm->rsp_code, + ndp_confirm->reason_code); cfg80211_debug("NDP confim, ndp app info dump"); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG, @@ -1352,7 +1379,7 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, ndi_rsp); } else { cfg80211_err("NDI interface creation failed with reason %d", - ndi_rsp->reason); + create_reason); goto close_ndi; } @@ -1463,6 +1490,11 @@ void os_if_nan_post_ndi_create_rsp(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev = wlan_objmgr_get_vdev_by_id_from_psoc( psoc, vdev_id, WLAN_NAN_ID); + if (!vdev) { + cfg80211_err("vdev is null"); + return; + } + if (success) { rsp.status = NAN_DATAPATH_RSP_STATUS_SUCCESS; rsp.reason = 0; @@ -1483,6 +1515,11 @@ void os_if_nan_post_ndi_delete_rsp(struct wlan_objmgr_psoc *psoc, struct nan_datapath_inf_delete_rsp rsp = {0}; struct wlan_objmgr_vdev *vdev = wlan_objmgr_get_vdev_by_id_from_psoc( psoc, vdev_id, WLAN_NAN_ID); + if (!vdev) { + cfg80211_err("vdev is null"); + return; + } + if (success) { rsp.status = NAN_DATAPATH_RSP_STATUS_SUCCESS; rsp.reason = 0; From 79574b42a5332a95a99ac1a2c4383b9bf56f273f Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 14 Dec 2017 13:24:31 -0800 Subject: [PATCH 45/92] 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 --- core/inc/nan_public_structs.h | 42 +++--- core/src/nan_main.c | 37 +----- dispatcher/src/nan_ucfg_api.c | 232 ++-------------------------------- 3 files changed, 43 insertions(+), 268 deletions(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 7f1f15487b39..2a473c20b714 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.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 @@ -31,6 +31,15 @@ struct wlan_objmgr_psoc; struct wlan_objmgr_vdev; #define IFACE_NAME_SIZE 64 +#define NDP_QOS_INFO_LEN 255 +#define NDP_APP_INFO_LEN 255 +#define NDP_PMK_LEN 32 +#define NDP_SCID_BUF_LEN 256 +#define NDP_NUM_INSTANCE_ID 255 +#define NAN_MAX_SERVICE_NAME_LEN 255 +#define NAN_PASSPHRASE_MIN_LEN 8 +#define NAN_PASSPHRASE_MAX_LEN 63 + #define NAN_DATAPATH_INF_CREATE_REQ 0 #define NAN_DATAPATH_INF_CREATE_RSP 1 @@ -193,7 +202,7 @@ enum nan_datapath_state { */ struct nan_datapath_app_info { uint32_t ndp_app_info_len; - uint8_t *ndp_app_info; + uint8_t ndp_app_info[NDP_APP_INFO_LEN]; }; /** @@ -204,7 +213,7 @@ struct nan_datapath_app_info { */ struct nan_datapath_cfg { uint32_t ndp_cfg_len; - uint8_t *ndp_cfg; + uint8_t ndp_cfg[NDP_QOS_INFO_LEN]; }; /** @@ -215,7 +224,7 @@ struct nan_datapath_cfg { */ struct nan_datapath_pmk { uint32_t pmk_len; - uint8_t *pmk; + uint8_t pmk[NDP_PMK_LEN]; }; /** @@ -226,7 +235,7 @@ struct nan_datapath_pmk { */ struct nan_datapath_scid { uint32_t scid_len; - uint8_t *scid; + uint8_t scid[NDP_SCID_BUF_LEN]; }; /** @@ -237,7 +246,7 @@ struct nan_datapath_scid { */ struct ndp_passphrase { uint32_t passphrase_len; - uint8_t *passphrase; + uint8_t passphrase[NAN_PASSPHRASE_MAX_LEN]; }; /** @@ -248,7 +257,7 @@ struct ndp_passphrase { */ struct ndp_service_name { uint32_t service_name_len; - uint8_t *service_name; + uint8_t service_name[NAN_MAX_SERVICE_NAME_LEN]; }; /** @@ -306,8 +315,8 @@ struct nan_datapath_inf_delete_rsp { /** * struct nan_datapath_initiator_req - ndp initiator request params + * @vdev: pointer to vdev object * @transaction_id: unique identifier - * @vdev_id: session id of the interface over which ndp is being created * @channel: suggested channel for ndp creation * @channel_cfg: channel config, 0=no channel, 1=optional, 2=mandatory * @service_instance_id: Service identifier @@ -338,8 +347,8 @@ struct nan_datapath_initiator_req { /** * struct nan_datapath_initiator_rsp - response event from FW + * @vdev: pointer to vdev object * @transaction_id: unique identifier - * @vdev_id: session id of the interface over which ndp is being created * @ndp_instance_id: locally created NDP instance ID * @status: status of the ndp request * @reason: reason for failure if any @@ -356,8 +365,8 @@ struct nan_datapath_initiator_rsp { /** * struct nan_datapath_responder_req - responder's response to ndp create * request + * @vdev: pointer to vdev object * @transaction_id: unique identifier - * @vdev_id: session id of the interface over which ndp is being created * @ndp_instance_id: locally created NDP instance ID * @ndp_rsp: response to the ndp create request * @ndp_config: ndp configuration params @@ -383,8 +392,8 @@ struct nan_datapath_responder_req { /** * struct nan_datapath_responder_rsp - response to responder's request + * @vdev: pointer to vdev object * @transaction_id: unique identifier - * @vdev_id: session id of the interface over which ndp is being created * @status: command status * @reason: reason for failure if any * @peer_mac_addr: Peer's mac address @@ -401,20 +410,22 @@ struct nan_datapath_responder_rsp { /** * struct nan_datapath_end_req - ndp end request + * @vdev: pointer to vdev object * @transaction_id: unique transaction identifier * @num_ndp_instances: number of ndp instances to be terminated - * @ndp_ids: pointer to array of ndp_instance_id to be terminated + * @ndp_ids: array of ndp_instance_id to be terminated * */ struct nan_datapath_end_req { struct wlan_objmgr_vdev *vdev; uint32_t transaction_id; uint32_t num_ndp_instances; - uint32_t *ndp_ids; + uint32_t ndp_ids[NDP_NUM_INSTANCE_ID]; }; /** * struct nan_datapath_end_rsp_event - firmware response to ndp end request + * @vdev: pointer to vdev object * @transaction_id: unique identifier for the request * @status: status of operation * @reason: reason(opaque to host driver) @@ -430,6 +441,7 @@ struct nan_datapath_end_rsp_event { /** * struct nan_datapath_end_indication_event - ndp termination notification from * FW + * @vdev: pointer to vdev object * @num_ndp_ids: number of NDP ids * @ndp_map: mapping of NDP instances to peer and vdev * @@ -442,7 +454,7 @@ struct nan_datapath_end_indication_event { /** * struct nan_datapath_confirm_event - ndp confirmation event from FW - * @vdev_id: session id of the interface over which ndp is being created + * @vdev: pointer to vdev object * @ndp_instance_id: ndp instance id for which confirm is being generated * @reason_code : reason code(opaque to driver) * @num_active_ndps_on_peer: number of ndp instances on peer @@ -463,7 +475,7 @@ struct nan_datapath_confirm_event { /** * struct nan_datapath_indication_event - create ndp indication on the responder - * @vdev_id: session id of the interface over which ndp is being created + * @vdev: pointer to vdev object * @service_instance_id: Service identifier * @peer_discovery_mac_addr: Peer's discovery mac address * @peer_mac_addr: Peer's NDI mac address diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 7c0d0b8f8807..e5ade7813dce 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.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 @@ -71,27 +71,16 @@ void nan_release_cmd(void *in_req, uint32_t cmdtype) case WLAN_SER_CMD_NDP_INIT_REQ: { struct nan_datapath_initiator_req *req = in_req; vdev = req->vdev; - qdf_mem_free(req->pmk.pmk); - qdf_mem_free(req->ndp_info.ndp_app_info); - qdf_mem_free(req->ndp_config.ndp_cfg); - qdf_mem_free(req->passphrase.passphrase); - qdf_mem_free(req->service_name.service_name); break; } case WLAN_SER_CMD_NDP_RESP_REQ: { struct nan_datapath_responder_req *req = in_req; vdev = req->vdev; - qdf_mem_free(req->pmk.pmk); - qdf_mem_free(req->ndp_info.ndp_app_info); - qdf_mem_free(req->ndp_config.ndp_cfg); - qdf_mem_free(req->passphrase.passphrase); - qdf_mem_free(req->service_name.service_name); break; } case WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: { struct nan_datapath_end_req *req = in_req; vdev = req->vdev; - qdf_mem_free(req->ndp_ids); break; } default: @@ -261,7 +250,6 @@ static QDF_STATUS nan_handle_confirm( struct nan_datapath_confirm_event *confirm) { uint8_t vdev_id; - QDF_STATUS status = QDF_STATUS_SUCCESS; struct wlan_objmgr_psoc *psoc; struct nan_psoc_priv_obj *psoc_nan_obj; @@ -269,15 +257,13 @@ static QDF_STATUS nan_handle_confirm( psoc = wlan_vdev_get_psoc(confirm->vdev); if (!psoc) { nan_err("psoc is null"); - status = QDF_STATUS_E_NULL_VALUE; - goto free_resource; + return QDF_STATUS_E_NULL_VALUE; } psoc_nan_obj = nan_get_psoc_priv_obj(psoc); if (!psoc_nan_obj) { nan_err("psoc_nan_obj is null"); - status = QDF_STATUS_E_NULL_VALUE; - goto free_resource; + return QDF_STATUS_E_NULL_VALUE; } if (confirm->rsp_code != NAN_DATAPATH_RESPONSE_ACCEPT && @@ -295,10 +281,7 @@ static QDF_STATUS nan_handle_confirm( psoc_nan_obj->cb_obj.os_if_event_handler(psoc, confirm->vdev, NDP_CONFIRM, confirm); -free_resource: - qdf_mem_free(confirm->ndp_info.ndp_app_info); - - return status; + return QDF_STATUS_SUCCESS; } static QDF_STATUS nan_handle_initiator_rsp( @@ -339,15 +322,13 @@ static QDF_STATUS nan_handle_ndp_ind( psoc = wlan_vdev_get_psoc(ndp_ind->vdev); if (!psoc) { nan_err("psoc is null"); - status = QDF_STATUS_E_NULL_VALUE; - goto ndp_indication_failed; + return QDF_STATUS_E_NULL_VALUE; } psoc_nan_obj = nan_get_psoc_priv_obj(psoc); if (!psoc_nan_obj) { nan_err("psoc_nan_obj is null"); - status = QDF_STATUS_E_NULL_VALUE; - goto ndp_indication_failed; + return QDF_STATUS_E_NULL_VALUE; } nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr " @@ -363,16 +344,12 @@ static QDF_STATUS nan_handle_ndp_ind( if (QDF_IS_STATUS_ERROR(status)) { nan_err("Couldn't add ndi peer, ndp_role: %d", ndp_ind->role); - goto ndp_indication_failed; + return status; } } if (NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ndp_ind->vdev, NDP_INDICATION, ndp_ind); -ndp_indication_failed: - qdf_mem_free(ndp_ind->ndp_config.ndp_cfg); - qdf_mem_free(ndp_ind->ndp_info.ndp_app_info); - qdf_mem_free(ndp_ind->scid.scid); return status; } diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index d01f00dddb18..dc9412ac8bad 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -302,224 +302,10 @@ inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_SUCCESS; } -static struct nan_datapath_initiator_req *ucfg_nan_copy_intiator_req( - struct wlan_objmgr_vdev *vdev, - struct nan_datapath_initiator_req *in_req) -{ - struct nan_datapath_initiator_req *out_req; - - out_req = qdf_mem_malloc(sizeof(*out_req)); - if (!out_req) { - nan_alert("malloc failed"); - return NULL; - } - - qdf_mem_copy(out_req, in_req, sizeof(*out_req)); - if (in_req->ndp_config.ndp_cfg_len) { - out_req->ndp_config.ndp_cfg = - qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len); - if (!out_req->ndp_config.ndp_cfg) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(out_req->ndp_config.ndp_cfg, - in_req->ndp_config.ndp_cfg, - in_req->ndp_config.ndp_cfg_len); - } - - if (in_req->ndp_info.ndp_app_info_len) { - out_req->ndp_info.ndp_app_info = - qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len); - if (!out_req->ndp_info.ndp_app_info) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(out_req->ndp_info.ndp_app_info, - in_req->ndp_info.ndp_app_info, - in_req->ndp_info.ndp_app_info_len); - } - - if (in_req->pmk.pmk_len) { - out_req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len); - if (!out_req->pmk.pmk) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(out_req->pmk.pmk, in_req->pmk.pmk, - in_req->pmk.pmk_len); - } - - if (in_req->passphrase.passphrase_len) { - out_req->passphrase.passphrase = - qdf_mem_malloc(in_req->passphrase.passphrase_len); - if (NULL == out_req->passphrase.passphrase) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(out_req->passphrase.passphrase, - in_req->passphrase.passphrase, - in_req->passphrase.passphrase_len); - } - - if (in_req->service_name.service_name_len) { - out_req->service_name.service_name = - qdf_mem_malloc(in_req->service_name.service_name_len); - if (NULL == out_req->service_name.service_name) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(out_req->service_name.service_name, - in_req->service_name.service_name, - in_req->service_name.service_name_len); - } - - nan_debug("pmk_len: %d, passphrase_len: %d, service_name_len: %d", - out_req->pmk.pmk_len, - out_req->passphrase.passphrase_len, - out_req->service_name.service_name_len); - - /* do not get ref here, rather take ref when request is activated */ - out_req->vdev = vdev; - return out_req; - -free_resources: - qdf_mem_free(out_req->passphrase.passphrase); - qdf_mem_free(out_req->service_name.service_name); - qdf_mem_free(out_req->pmk.pmk); - qdf_mem_free(out_req->ndp_info.ndp_app_info); - qdf_mem_free(out_req->ndp_config.ndp_cfg); - qdf_mem_free(out_req); - return NULL; -} - -static struct nan_datapath_responder_req *ucfg_nan_copy_responder_req( - struct wlan_objmgr_vdev *vdev, - struct nan_datapath_responder_req *in_req) -{ - struct nan_datapath_responder_req *req; - - req = qdf_mem_malloc(sizeof(*req)); - if (!req) { - nan_alert("malloc failed"); - return NULL; - } - - qdf_mem_copy(req, in_req, sizeof(*req)); - if (in_req->ndp_config.ndp_cfg_len) { - req->ndp_config.ndp_cfg = - qdf_mem_malloc(in_req->ndp_config.ndp_cfg_len); - if (!req->ndp_config.ndp_cfg) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->ndp_config.ndp_cfg, - in_req->ndp_config.ndp_cfg, - in_req->ndp_config.ndp_cfg_len); - } - - if (in_req->ndp_info.ndp_app_info_len) { - req->ndp_info.ndp_app_info = - qdf_mem_malloc(in_req->ndp_info.ndp_app_info_len); - if (!req->ndp_info.ndp_app_info) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->ndp_info.ndp_app_info, - in_req->ndp_info.ndp_app_info, - in_req->ndp_info.ndp_app_info_len); - } - - if (in_req->pmk.pmk_len) { - req->pmk.pmk = qdf_mem_malloc(in_req->pmk.pmk_len); - if (!req->pmk.pmk) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->pmk.pmk, in_req->pmk.pmk, - in_req->pmk.pmk_len); - } - - if (in_req->passphrase.passphrase_len) { - req->passphrase.passphrase = - qdf_mem_malloc(in_req->passphrase.passphrase_len); - if (NULL == req->passphrase.passphrase) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->passphrase.passphrase, - in_req->passphrase.passphrase, - in_req->passphrase.passphrase_len); - } - - if (in_req->service_name.service_name_len) { - req->service_name.service_name = - qdf_mem_malloc(in_req->service_name.service_name_len); - if (NULL == req->service_name.service_name) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->service_name.service_name, - in_req->service_name.service_name, - in_req->service_name.service_name_len); - } - - nan_debug("pmk_len: %d, passphrase_len: %d, service_name_len: %d", - req->pmk.pmk_len, - req->passphrase.passphrase_len, - req->service_name.service_name_len); - - /* do not get ref here, rather take ref when request is activated */ - req->vdev = vdev; - return req; - -free_resources: - qdf_mem_free(req->passphrase.passphrase); - qdf_mem_free(req->service_name.service_name); - qdf_mem_free(req->pmk.pmk); - qdf_mem_free(req->ndp_info.ndp_app_info); - qdf_mem_free(req->ndp_config.ndp_cfg); - qdf_mem_free(req); - return NULL; -} - -static struct nan_datapath_end_req *ucfg_nan_copy_end_req( - struct wlan_objmgr_vdev *vdev, - struct nan_datapath_end_req *in_req) -{ - struct nan_datapath_end_req *req; - - req = qdf_mem_malloc(sizeof(*req)); - if (!req) { - nan_alert("malloc failed"); - return NULL; - } - - qdf_mem_copy(req, in_req, sizeof(*req)); - if (in_req->num_ndp_instances) { - req->ndp_ids = qdf_mem_malloc(sizeof(uint32_t) * - in_req->num_ndp_instances); - if (!req->ndp_ids) { - nan_alert("malloc failed"); - goto free_resources; - } - qdf_mem_copy(req->ndp_ids, in_req->ndp_ids, - sizeof(uint32_t) * in_req->num_ndp_instances); - } - - /* do not get ref here, rather take ref when request is activated */ - req->vdev = vdev; - return req; - -free_resources: - qdf_mem_free(req->ndp_ids); - qdf_mem_free(req); - return NULL; -} - QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { - void *req; + uint32_t len; QDF_STATUS status; struct scheduler_msg msg = {0}; @@ -530,26 +316,26 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, switch (req_type) { case NDP_INITIATOR_REQ: - req = ucfg_nan_copy_intiator_req(vdev, in_req); + len = sizeof(struct nan_datapath_initiator_req); break; case NDP_RESPONDER_REQ: - req = ucfg_nan_copy_responder_req(vdev, in_req); + len = sizeof(struct nan_datapath_responder_req); break; case NDP_END_REQ: - req = ucfg_nan_copy_end_req(vdev, in_req); + len = sizeof(struct nan_datapath_end_req); break; default: nan_err("in correct message req type: %d", req_type); return QDF_STATUS_E_INVAL; } - if (!req) { - nan_err("failed to create local copy"); - return QDF_STATUS_E_INVAL; + msg.bodyptr = qdf_mem_malloc(len); + if (!msg.bodyptr) { + nan_err("malloc failed"); + return QDF_STATUS_E_NOMEM; } - + qdf_mem_copy(msg.bodyptr, in_req, len); msg.type = req_type; - msg.bodyptr = req; msg.callback = nan_scheduled_msg_handler; status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg); if (QDF_IS_STATUS_ERROR(status)) { From 1c5aaf61ad94802152ac63045db955345deab88f Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 14 Dec 2017 13:24:31 -0800 Subject: [PATCH 46/92] 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 --- inc/os_if_nan.h | 11 +---------- src/os_if_nan.c | 43 ++++++++++++++++++++++--------------------- 2 files changed, 23 insertions(+), 31 deletions(-) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 31e56513fae0..151c457bbfc5 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2012-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 @@ -32,15 +32,6 @@ struct wlan_objmgr_vdev; #ifdef WLAN_FEATURE_NAN_CONVERGENCE -#define NDP_QOS_INFO_LEN 255 -#define NDP_APP_INFO_LEN 255 -#define NDP_PMK_LEN 32 -#define NDP_SCID_BUF_LEN 256 -#define NDP_NUM_INSTANCE_ID 255 -#define NAN_MAX_SERVICE_NAME_LEN 255 -#define NAN_PASSPHRASE_MIN_LEN 8 -#define NAN_PASSPHRASE_MAX_LEN 63 - /** * enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters * @QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD: NDP Sub command diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 23b86fb01497..e7d91d46c7f2 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -206,10 +206,10 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, } if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { - pmk->pmk_len = - nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); - pmk->pmk = - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + pmk->pmk_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]); + qdf_mem_copy(pmk->pmk, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]), + pmk->pmk_len); cfg80211_err("pmk len: %d", pmk->pmk_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, pmk->pmk, pmk->pmk_len); @@ -218,8 +218,9 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]) { passphrase->passphrase_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]); - passphrase->passphrase = - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]); + qdf_mem_copy(passphrase->passphrase, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE]), + passphrase->passphrase_len); cfg80211_err("passphrase len: %d", passphrase->passphrase_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, passphrase->passphrase, passphrase->passphrase_len); @@ -228,8 +229,9 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, if (tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]) { service_name->service_name_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]); - service_name->service_name = - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]); + qdf_mem_copy(service_name->service_name, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]), + service_name->service_name_len); cfg80211_err("service_name len: %d", service_name->service_name_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, @@ -267,7 +269,6 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, int ret = 0; char *iface_name; QDF_STATUS status; - uint32_t ndp_qos_cfg; enum nan_datapath_state state; struct wlan_objmgr_vdev *nan_vdev; struct nan_datapath_initiator_req req = {0}; @@ -343,15 +344,15 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { req.ndp_info.ndp_app_info_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); - req.ndp_info.ndp_app_info = - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); + qdf_mem_copy(req.ndp_info.ndp_app_info, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]), + req.ndp_info.ndp_app_info_len); } if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) { /* at present ndp config stores 4 bytes QOS info only */ req.ndp_config.ndp_cfg_len = 4; - req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg; - ndp_qos_cfg = + *((uint32_t *)req.ndp_config.ndp_cfg) = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); } @@ -400,7 +401,6 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, int ret = 0; char *iface_name; QDF_STATUS status; - uint32_t ndp_qos_cfg; enum nan_datapath_state state; struct wlan_objmgr_vdev *nan_vdev; struct nan_datapath_responder_req req = {0}; @@ -461,19 +461,18 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { req.ndp_info.ndp_app_info_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); - if (req.ndp_info.ndp_app_info_len) { - req.ndp_info.ndp_app_info = - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); - } + qdf_mem_copy(req.ndp_info.ndp_app_info, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]), + req.ndp_info.ndp_app_info_len); } else { cfg80211_debug("NDP app info is unavailable"); } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]) { /* at present ndp config stores 4 bytes QOS info only */ req.ndp_config.ndp_cfg_len = 4; - ndp_qos_cfg = + *((uint32_t *)req.ndp_config.ndp_cfg) = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); - req.ndp_config.ndp_cfg = (uint8_t *)&ndp_qos_cfg; } else { cfg80211_debug("NDP config data is unavailable"); } @@ -537,7 +536,9 @@ static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, cfg80211_err("Num NDP instances is 0"); return -EINVAL; } - req.ndp_ids = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]); + qdf_mem_copy(req.ndp_ids, + tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY], + req.num_ndp_instances * sizeof(uint32_t)); cfg80211_debug("sending ndp_end_req to SME, transaction_id: %d", req.transaction_id); From fee11bd5705e7fe3613c12faacf0b6c06d9f9c0c Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 14 Dec 2017 13:24:31 -0800 Subject: [PATCH 47/92] 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 3b5c6642a16e..2f0c8305f576 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 e27c05b705a78a47ec44f24f3945581aac1a963a Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Thu, 25 Jan 2018 11:46:31 -0800 Subject: [PATCH 48/92] qcacmn: Replace QDF_MAC_ADDRESS_STR QDF_MAC_ADDRESS_STR has been depreciated in favor of QDF_MAC_ADDR_STR. Replace all usages with the new macro. Change-Id: I534923783a32288f7861caf9ae52ca3aac965809 CRs-Fixed: 2179126 --- core/src/nan_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index e5ade7813dce..cc84277e9c33 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -272,7 +272,7 @@ static QDF_STATUS nan_handle_confirm( * This peer was created at ndp_indication but * confirm failed, so it needs to be deleted */ - nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDRESS_STR" on vdev_id: %d", + nan_err("NDP confirm with reject and no active ndp sessions. deleting peer: "QDF_MAC_ADDR_STR" on vdev_id: %d", QDF_MAC_ADDR_ARRAY(confirm->peer_ndi_mac_addr.bytes), vdev_id); psoc_nan_obj->cb_obj.delete_peers_by_addr(vdev_id, @@ -332,7 +332,7 @@ static QDF_STATUS nan_handle_ndp_ind( } nan_debug("role: %d, vdev: %d, csid: %d, peer_mac_addr " - QDF_MAC_ADDRESS_STR, + QDF_MAC_ADDR_STR, ndp_ind->role, vdev_id, ndp_ind->ncs_sk_type, QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes)); From c62ac3d5253c5a3c40bedcd806a37bd627821c88 Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Tue, 27 Feb 2018 11:32:55 -0800 Subject: [PATCH 49/92] qcacmn: Use size_t for qdf_str_len() return type A recent commit changed the return type for qdf_str_len() to size_t from int32_t. Update call sites for qdf_str_len() to store the return value as size_t to match. Change-Id: Ib8bfad2c1fc7de1f6fc601d1be69e734d3a49dcf CRs-Fixed: 2196858 --- src/os_if_nan.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index e7d91d46c7f2..f3409a5fd43c 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -775,7 +775,7 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, { uint8_t *ifname; uint16_t data_len; - uint8_t ifname_len; + qdf_size_t ifname_len; uint32_t ndp_qos_config; struct sk_buff *vendor_event; enum nan_datapath_state state; @@ -806,7 +806,7 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, } ifname_len = qdf_str_len(ifname); if (ifname_len > IFNAMSIZ) { - cfg80211_err("ifname(%d) too long", ifname_len); + cfg80211_err("ifname(%zu) too long", ifname_len); return; } @@ -915,7 +915,7 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, uint8_t *ifname; uint32_t data_len; QDF_STATUS status; - uint8_t ifname_len; + qdf_size_t ifname_len; uint32_t ndp_qos_config = 0; struct sk_buff *vendor_event; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); @@ -956,7 +956,7 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, } ifname_len = qdf_str_len(ifname); if (ifname_len > IFNAMSIZ) { - cfg80211_err("ifname(%d) too long", ifname_len); + cfg80211_err("ifname(%zu) too long", ifname_len); return; } From ed557e9e5b0aea4d985e97bcb3c5008e585c8f30 Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Mon, 26 Feb 2018 13:00:20 -0800 Subject: [PATCH 50/92] qcacmn: Include qdf_str.h The qdf_str APIs have recently been moved from qdf_mem. Reference the new qdf_str.h header file where appropriate. Change-Id: If97c9c37a7d720a7b93e50ec228da67a8e980c2e CRs-Fixed: 2196129 --- src/os_if_nan.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index f3409a5fd43c..c1fa9b8d0c2c 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -20,8 +20,9 @@ * DOC: defines nan component os interface APIs */ -#include "qdf_types.h" +#include "qdf_str.h" #include "qdf_trace.h" +#include "qdf_types.h" #include "os_if_nan.h" #include "wlan_nan_api.h" #include "nan_ucfg_api.h" From faa3ce91bb0224cdc96d298373ba349389e1546a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Fri, 2 Feb 2018 15:13:05 -0800 Subject: [PATCH 51/92] 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 2f0c8305f576..1470c756b695 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 ddbaec0f4b7b5bf71eb585c17bdf80a72f153229 Mon Sep 17 00:00:00 2001 From: Ravi Joshi Date: Tue, 10 Apr 2018 15:21:13 -0700 Subject: [PATCH 52/92] qcacmn: Accept nan responder request without iface name The service layer need not provide the iface name in the responder request to the driver if the request is being rejected. The service layer maps the ndp_instance_id only after accepting the request, if the ndp indication is rejected, the user space has no knowledge of the iface name on which the NDP would have gotten mapped if it were successful CRs-Fixed: 2222041 Change-Id: I94a7de0c98c14dbe2389dd8364b6dd78858a9d0a --- src/os_if_nan.c | 42 ++++++++++++++++++++++++++++-------------- 1 file changed, 28 insertions(+), 14 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index c1fa9b8d0c2c..1f1d3630cddd 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -406,22 +406,36 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *nan_vdev; struct nan_datapath_responder_req req = {0}; - if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { - cfg80211_err("Interface name string is unavailable"); - return -EINVAL; - } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); - iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); - /* Check if there is already an existing NAN interface */ - nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, WLAN_NAN_ID); - if (!nan_vdev) { - cfg80211_err("NAN data interface %s not available", iface_name); - return -EINVAL; - } + /* Check if there is already an existing NAN interface */ + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, + WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface %s not available", + iface_name); + return -ENODEV; + } - if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { - cfg80211_err("Interface found is not NDI"); - return -EINVAL; + if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { + cfg80211_err("Interface found is not NDI"); + return -ENODEV; + } + } else { + /* + * If the data indication is rejected, the userspace + * may not send the iface name. Use the first available NDI + * in that case + */ + cfg80211_debug("ndp rsp rejected, using first available NDI"); + + nan_vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, + QDF_NDI_MODE, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data interface is not available"); + return -ENODEV; + } } state = ucfg_nan_get_ndi_state(nan_vdev); From f6cf25d1543670562819458e425926552b814087 Mon Sep 17 00:00:00 2001 From: Ravi Joshi Date: Tue, 10 Apr 2018 16:06:39 -0700 Subject: [PATCH 53/92] qcacmn: Fix issue while handling ndp response without iface name Check for interface name only when ndp response is "accept" from user. In case of "reject" discard interface name provided and instead use first NDI available. CRs-Fixed: 2222041 Change-Id: Ib02fe7d5b93f8e388658e511317664a4999b5fa6 --- src/os_if_nan.c | 57 +++++++++++++++++++++++++++---------------------- 1 file changed, 31 insertions(+), 26 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 1f1d3630cddd..5473bebceb32 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -403,37 +403,49 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, char *iface_name; QDF_STATUS status; enum nan_datapath_state state; - struct wlan_objmgr_vdev *nan_vdev; + struct wlan_objmgr_vdev *nan_vdev = NULL; struct nan_datapath_responder_req req = {0}; - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { - iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]) { + cfg80211_err("ndp_rsp is unavailable"); + ret = -EINVAL; + goto responder_req_failed; + } + req.ndp_rsp = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]); - /* Check if there is already an existing NAN interface */ - nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, - WLAN_NAN_ID); - if (!nan_vdev) { - cfg80211_err("NAN data interface %s not available", - iface_name); - return -ENODEV; - } + if (req.ndp_rsp == NAN_DATAPATH_RESPONSE_ACCEPT) { + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + iface_name = + nla_data( + tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); - if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { - cfg80211_err("Interface found is not NDI"); - return -ENODEV; + /* Check for an existing NAN interface */ + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, + iface_name, WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data iface %s not available", + iface_name); + return -ENODEV; + } + + if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { + cfg80211_err("Interface found is not NDI"); + return -ENODEV; + } } } else { + /* * If the data indication is rejected, the userspace - * may not send the iface name. Use the first available NDI + * may not send the iface name. Use the first NDI * in that case */ - cfg80211_debug("ndp rsp rejected, using first available NDI"); + cfg80211_debug("ndp rsp rejected, using first NDI"); - nan_vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc(psoc, - QDF_NDI_MODE, WLAN_NAN_ID); + nan_vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc( + psoc, QDF_NDI_MODE, WLAN_NAN_ID); if (!nan_vdev) { - cfg80211_err("NAN data interface is not available"); + cfg80211_err("NAN data iface is not available"); return -ENODEV; } } @@ -466,13 +478,6 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, req.ndp_instance_id = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]); - if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]) { - cfg80211_err("ndp_rsp is unavailable"); - ret = -EINVAL; - goto responder_req_failed; - } - req.ndp_rsp = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]); - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { req.ndp_info.ndp_app_info_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]); From 2c59b94216d4c59696a264444c21eed766d2d50a Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Sun, 15 Apr 2018 22:48:48 -0700 Subject: [PATCH 54/92] qcacmn: Re-factor buffer len calculation for NDP events Re-factor vendor event buffer length calculation for NDP events to a separate function call. Change-Id: I6828067d0e81987d7c903fd7f7df05b3a4eadbe3 CRs-Fixed: 2183658 --- src/os_if_nan.c | 303 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 244 insertions(+), 59 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 5473bebceb32..b696cb8b8535 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -38,39 +38,90 @@ /* NLA policy */ static const struct nla_policy vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { - [QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID] = { .type = NLA_U16 }, - [QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { .type = NLA_NUL_STRING, - .len = IFNAMSIZ - 1 }, - [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL] = { .type = NLA_U32 }, + [QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID] = { + .type = NLA_U16, + .len = sizeof(uint16_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR] = { + .type = NLA_NUL_STRING, + .len = IFNAMSIZ - 1 + }, + [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, [QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR] = { - .type = NLA_BINARY, - .len = QDF_MAC_ADDR_SIZE }, - [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY] = { .type = NLA_U16 }, - [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS] = { .type = NLA_BINARY, - .len = NDP_QOS_INFO_LEN }, - [QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO] = { .type = NLA_BINARY, - .len = NDP_APP_INFO_LEN }, - [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE] = { .type = NLA_U16 }, - [QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR] = { .type = NLA_BINARY, - .len = QDF_MAC_ADDR_SIZE }, - [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY] = { .type = NLA_BINARY, - .len = NDP_NUM_INSTANCE_ID }, - [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_PMK] = { .type = NLA_BINARY, - .len = NDP_PMK_LEN }, - [QCA_WLAN_VENDOR_ATTR_NDP_SCID] = { .type = NLA_BINARY, - .len = NDP_SCID_BUF_LEN }, - [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE] = { .type = - NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE] = { .type = NLA_U32 }, - [QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE] = { .type = NLA_BINARY, - .len = NAN_PASSPHRASE_MAX_LEN }, - [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME] = { .type = NLA_BINARY, - .len = NAN_MAX_SERVICE_NAME_LEN }, + .type = NLA_BINARY, + .len = QDF_MAC_ADDR_SIZE + }, + [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY] = { + .type = NLA_U16, + .len = sizeof(uint16_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS] = { + .type = NLA_BINARY, + .len = NDP_QOS_INFO_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO] = { + .type = NLA_BINARY, + .len = NDP_APP_INFO_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE] = { + .type = NLA_U16, + .len = sizeof(uint16_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR] = { + .type = NLA_BINARY, + .len = QDF_MAC_ADDR_SIZE + }, + [QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY] = { + .type = NLA_BINARY, + .len = NDP_NUM_INSTANCE_ID + }, + [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_PMK] = { + .type = NLA_BINARY, + .len = NDP_PMK_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_SCID] = { + .type = NLA_BINARY, + .len = NDP_SCID_BUF_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE] = { + .type = NLA_BINARY, + .len = NAN_PASSPHRASE_MAX_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME] = { + .type = NLA_BINARY, + .len = NAN_MAX_SERVICE_NAME_LEN + }, }; static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, @@ -634,6 +685,24 @@ int os_if_nan_process_ndp_cmd(struct wlan_objmgr_psoc *psoc, return -EINVAL; } +static inline uint32_t osif_ndp_get_ndp_initiator_rsp_len(void) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + + return data_len; +} + /** * os_if_ndp_initiator_rsp_handler() - NDP initiator response handler * @vdev: pointer to vdev object @@ -662,8 +731,7 @@ static void os_if_ndp_initiator_rsp_handler(struct wlan_objmgr_vdev *vdev, return; } - data_len = (4 * sizeof(uint32_t)) + (1 * sizeof(uint16_t)) + - NLMSG_HDRLEN + (5 * NLA_HDRLEN); + data_len = osif_ndp_get_ndp_initiator_rsp_len(); vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, GFP_ATOMIC); @@ -704,6 +772,21 @@ ndp_initiator_rsp_nla_failed: kfree_skb(vendor_event); } +static inline uint32_t osif_ndp_get_ndp_responder_rsp_len(void) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + + return data_len; +} /* * os_if_ndp_responder_rsp_handler() - NDP responder response handler @@ -735,8 +818,7 @@ static void os_if_ndp_responder_rsp_handler(struct wlan_objmgr_vdev *vdev, cfg80211_debug("NDP Responder,vdev id %d transaction_id %d status code: %d reason %d", wlan_vdev_get_id(rsp->vdev), rsp->transaction_id, rsp->status, rsp->reason); - data_len = 3 * sizeof(uint32_t) + sizeof(uint16_t) + - 4 * NLA_HDRLEN + NLMSG_HDRLEN; + data_len = osif_ndp_get_ndp_responder_rsp_len(); vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, GFP_ATOMIC); @@ -770,6 +852,36 @@ ndp_responder_rsp_nla_failed: kfree_skb(vendor_event); } +static inline uint32_t osif_ndp_get_ndp_req_ind_len( + struct nan_datapath_indication_event *event) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE].len); + /* allocate space including NULL terminator */ + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR].len + 1); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR].len); + if (event->scid.scid_len) + data_len += nla_total_size(event->scid.scid_len); + if (event->ndp_info.ndp_app_info_len) + data_len += nla_total_size(event->ndp_info.ndp_app_info_len); + + return data_len; +} + /** * os_if_ndp_indication_handler() - NDP indication handler * @vdev: pointer to vdev object @@ -830,10 +942,7 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, return; } - data_len = (5 * sizeof(uint32_t)) + (2 * QDF_MAC_ADDR_SIZE) + - ifname_len + event->ndp_info.ndp_app_info_len + - event->scid.scid_len + (10 * NLA_HDRLEN) + NLMSG_HDRLEN; - + data_len = osif_ndp_get_ndp_req_ind_len(event); /* notify response to the upper layer */ vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, @@ -911,6 +1020,31 @@ ndp_indication_nla_failed: kfree_skb(vendor_event); } +static inline uint32_t osif_ndp_get_ndp_confirm_ind_len( + struct nan_datapath_confirm_event *ndp_confirm) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR].len); + /* allocate space including NULL terminator */ + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR].len + 1); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + if (ndp_confirm->ndp_info.ndp_app_info_len) + data_len += + nla_total_size(ndp_confirm->ndp_info.ndp_app_info_len); + + return data_len; +} + /** * os_if_ndp_confirm_ind_handler() - NDP confirm indication handler * @vdev: pointer to vdev object @@ -924,7 +1058,7 @@ ndp_indication_nla_failed: * QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR (IFNAMSIZ) * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size) * QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE (4 bytes) - * QCA_WLAN_VENDOR_ATTR_NDP_RETURN_VALUE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) * * Return: none */ @@ -980,13 +1114,7 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, return; } - data_len = (4 * sizeof(uint32_t)) + QDF_MAC_ADDR_SIZE + ifname_len + - + NLMSG_HDRLEN + (7 * NLA_HDRLEN) + - ndp_confirm->ndp_info.ndp_app_info_len; - - if (ndp_confirm->ndp_info.ndp_app_info_len) - data_len += NLA_HDRLEN + ndp_confirm->ndp_info.ndp_app_info_len; - + data_len = osif_ndp_get_ndp_confirm_ind_len(ndp_confirm); vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, GFP_ATOMIC); @@ -1045,6 +1173,22 @@ ndp_confirm_nla_failed: kfree_skb(vendor_event); } +static inline uint32_t osif_ndp_get_ndp_end_rsp_len(void) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID].len); + + return data_len; +} + /** * os_if_ndp_end_rsp_handler() - NDP end response handler * @vdev: pointer to vdev object @@ -1072,9 +1216,7 @@ static void os_if_ndp_end_rsp_handler(struct wlan_objmgr_vdev *vdev, return; } - data_len = NLMSG_HDRLEN + (4 * NLA_HDRLEN) + (3 * sizeof(uint32_t)) + - sizeof(uint16_t); - + data_len = osif_ndp_get_ndp_end_rsp_len(); vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, GFP_ATOMIC); @@ -1110,6 +1252,20 @@ ndp_end_rsp_nla_failed: kfree_skb(vendor_event); } +static inline uint32_t osif_ndp_get_ndp_end_ind_len( + struct nan_datapath_end_indication_event *end_ind) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + if (end_ind->num_ndp_ids) + data_len += nla_total_size(end_ind->num_ndp_ids * + sizeof(uint32_t)); + + return data_len; +} + /** * os_if_ndp_end_ind_handler() - NDP end indication handler * @vdev: pointer to vdev object @@ -1178,9 +1334,7 @@ static void os_if_ndp_end_ind_handler(struct wlan_objmgr_vdev *vdev, idx); } - data_len = (sizeof(uint32_t)) + NLMSG_HDRLEN + (2 * NLA_HDRLEN) + - end_ind->num_ndp_ids * sizeof(*ndp_instance_array); - + data_len = osif_ndp_get_ndp_end_ind_len(end_ind); vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, GFP_ATOMIC); @@ -1288,6 +1442,22 @@ static void os_if_peer_departed_ind_handler(struct wlan_objmgr_vdev *vdev, (active_peers == 0 ? true : false)); } +static inline uint32_t osif_ndp_get_ndi_create_rsp_len(void) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + + return data_len; +} + /** * os_if_ndp_iface_create_rsp_handler() - NDP iface create response handler * @adapter: pointer to adapter context @@ -1309,6 +1479,7 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev, void *rsp_params) { + uint32_t data_len; QDF_STATUS status; bool create_fail = false; struct nan_callbacks cb_obj; @@ -1320,8 +1491,6 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, uint32_t create_reason = NAN_DATAPATH_NAN_DATA_IFACE_CREATE_FAILED; struct nan_datapath_inf_create_rsp *ndi_rsp = (struct nan_datapath_inf_create_rsp *)rsp_params; - uint32_t data_len = (3 * sizeof(uint32_t)) + sizeof(uint16_t) + - NLMSG_HDRLEN + (4 * NLA_HDRLEN); status = ucfg_nan_get_callbacks(psoc, &cb_obj); if (QDF_IS_STATUS_ERROR(status)) { @@ -1338,7 +1507,7 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, } create_transaction_id = ucfg_nan_get_ndp_create_transaction_id(vdev); - + data_len = osif_ndp_get_ndi_create_rsp_len(); /* notify response to the upper layer */ vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, @@ -1555,13 +1724,28 @@ void os_if_nan_post_ndi_delete_rsp(struct wlan_objmgr_psoc *psoc, wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); } +static inline uint32_t osif_ndp_get_ndi_delete_rsp_len(void) +{ + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE].len); + + return data_len; +} + void os_if_nan_ndi_session_end(struct wlan_objmgr_vdev *vdev) { + uint32_t data_len; struct sk_buff *vendor_event; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); - uint32_t data_len = sizeof(uint32_t) * (3 + sizeof(uint16_t)) + - (NLA_HDRLEN * 4) + NLMSG_HDRLEN; /* * The virtual adapters are stopped and closed even during @@ -1573,6 +1757,7 @@ void os_if_nan_ndi_session_end(struct wlan_objmgr_vdev *vdev) return; } + data_len = osif_ndp_get_ndi_delete_rsp_len(); /* notify response to the upper layer */ vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, From 8e2eb4e4041516ff8b782e2afbe626dbdf1e4190 Mon Sep 17 00:00:00 2001 From: Akshay Kosigi Date: Tue, 6 Feb 2018 16:02:25 +0530 Subject: [PATCH 55/92] 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 1470c756b695..570c5dffdf9a 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 654aee1236dd8094f3f1a1cf1ed73fb2659e77b3 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Mon, 7 May 2018 17:42:32 -0700 Subject: [PATCH 56/92] qcacmn: Fix NDP Discovery MAC address policy The current qca_wlan_vendor_ndp_policy for attribute QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR uses type NLA_BINARY. Unfortunately this type uses the len as a maximum length and not a minimum length which means that nla_parse() cannot guarantee that 6 bytes of MAC address are present. Change the policy to use type NLA_UNSPEC so that nla_parse() will ensure that the NDP Discovery MAC address TLV contains (at least) 6 bytes. Change-Id: I2c7e1efdb413dbd2f79c36ed1626c006b86e8b5b CRs-Fixed: 2237658 --- src/os_if_nan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index b696cb8b8535..a5c6bb454a65 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -59,7 +59,7 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .len = sizeof(uint32_t) }, [QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR] = { - .type = NLA_BINARY, + .type = NLA_UNSPEC, .len = QDF_MAC_ADDR_SIZE }, [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY] = { From bc404efdf3220f540dd4f07848cc611fd3d2426a Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Mon, 7 May 2018 17:46:00 -0700 Subject: [PATCH 57/92] qcacmn: Fix NDP Response Code policy The qca_wlan_vendor_ndp_policy for the attribute QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE currently specifies type NLA_U16. However this attribute is defined to be an unsigned 32 bit value, and nla_get_u32() is used to read the value, so change the policy to use type NLA_U32 so that nla_parse() can properly verify that the TLV payload has (at least) 4 bytes of data. Change-Id: I915a94e7449c2bc1abde64e2a7f5df6a58488ed6 CRs-Fixed: 2237659 --- src/os_if_nan.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index a5c6bb454a65..f395725711b5 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -79,8 +79,8 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .len = sizeof(uint32_t) }, [QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE] = { - .type = NLA_U16, - .len = sizeof(uint16_t) + .type = NLA_U32, + .len = sizeof(uint32_t) }, [QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR] = { .type = NLA_BINARY, From c3fd2a0d86003c0958a71c0b581277a3c6e707b7 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Mon, 7 May 2018 17:55:20 -0700 Subject: [PATCH 58/92] qcacmn: Fix NDP Config QoS policy The qca_wlan_vendor_ndp_policy for the attribute QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS currently specifies type NLA_BINARY with a maximum length of NDP_QOS_INFO_LEN (255). However this attribute is defined to be an unsigned 32 bit value, and nla_get_u32() is used to read the value, so change the policy to use type NLA_U32 so that nla_parse() can properly verify that the TLV payload has (at least) 4 bytes of data. Change-Id: Iee5b620ef199b731fc6a449d0055db328430921b CRs-Fixed: 2237660 --- src/os_if_nan.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index f395725711b5..f9a35beb7358 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -67,8 +67,8 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .len = sizeof(uint16_t) }, [QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS] = { - .type = NLA_BINARY, - .len = NDP_QOS_INFO_LEN + .type = NLA_U32, + .len = sizeof(uint32_t) }, [QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO] = { .type = NLA_BINARY, From 94763f52614624e3f5498afb53225bd5f8e5fba0 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 9 May 2018 11:09:41 -0700 Subject: [PATCH 59/92] qcacmn: Use NDP vendor attribute from qca_vendor.h Update qca_vendor.h with latest NDP vendor attribute definitions and use those definitions in NAN component. Change-Id: I43f0457690b1c4027adcd0abe4ef2ac2a8f9b068 CRs-Fixed: 2239047 --- inc/os_if_nan.h | 85 ------------------------------------------------- src/os_if_nan.c | 16 +++++----- 2 files changed, 8 insertions(+), 93 deletions(-) diff --git a/inc/os_if_nan.h b/inc/os_if_nan.h index 151c457bbfc5..338ea7462d45 100644 --- a/inc/os_if_nan.h +++ b/inc/os_if_nan.h @@ -32,91 +32,6 @@ struct wlan_objmgr_vdev; #ifdef WLAN_FEATURE_NAN_CONVERGENCE -/** - * enum qca_wlan_vendor_attr_ndp_params - vendor attribute parameters - * @QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD: NDP Sub command - * @QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID: Transaction id reference - * @QCA_WLAN_VENDOR_ATTR_NDP_STATUS_ID: NDP status id - * @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID: Service instance id - * @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL: Requested channel - * @QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR: Peer discovery mac addr - * @QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR: Iface name - * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY: Security configuration - * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS: Qos configuration - * @QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO: Application info - * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID: NDP instance id - * @QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY: NDP instance id array - * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE: Schedule response - * @QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR: NDI mac address - * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE: Driver return status - * @QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE: Driver return value - * @QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG: Channel config request type - * @QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE: Cipher Suit ID - * @QCA_WLAN_VENDOR_ATTR_NDP_PMK: Pairwise Master Key - * @QCA_WLAN_VENDOR_ATTR_NDP_SCID: Security Context ID - * @QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - pass phrase - * @QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - service name - */ -enum qca_wlan_vendor_attr_ndp_params { - QCA_WLAN_VENDOR_ATTR_NDP_PARAM_INVALID = 0, - QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, - QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, - QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_INSTANCE_ID, - QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL, - QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, - QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR, - /* CONFIG_SECURITY is deprecated, use NCS_SK_TYPE/PMK/SCID instead */ - QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_SECURITY, - QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS, - QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO, - QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID, - QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY, - QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE, - QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR, - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, - QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_CONFIG, - QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE, - QCA_WLAN_VENDOR_ATTR_NDP_PMK, - QCA_WLAN_VENDOR_ATTR_NDP_SCID, - QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE, - QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME, - - QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST, - QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX = - QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_AFTER_LAST - 1, -}; - -/** - * enum qca_wlan_vendor_attr_ndp_sub_cmd_value - NDP subcmd value - * @QCA_WLAN_VENDOR_ATTR_NDP_INVALID: Unused subcmd value - * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE: iface create - * @QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE: iface delete - * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST: NDP initiator request - * @QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE: NDP initiator response - * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST: NDP responder request - * @QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE: NDP responder response - * @QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST: NDP end request - * @QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE: NDP end response - * @QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND: NDP request indication - * @QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND: NDP confirm indication - * @QCA_WLAN_VENDOR_ATTR_NDP_END_IND: NDP End indication - */ -enum qca_wlan_vendor_attr_ndp_sub_cmd_value { - QCA_WLAN_VENDOR_ATTR_NDP_INVALID = 0, - QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE = 1, - QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE = 2, - QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_REQUEST = 3, - QCA_WLAN_VENDOR_ATTR_NDP_INITIATOR_RESPONSE = 4, - QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_REQUEST = 5, - QCA_WLAN_VENDOR_ATTR_NDP_RESPONDER_RESPONSE = 6, - QCA_WLAN_VENDOR_ATTR_NDP_END_REQUEST = 7, - QCA_WLAN_VENDOR_ATTR_NDP_END_RESPONSE = 8, - QCA_WLAN_VENDOR_ATTR_NDP_REQUEST_IND = 9, - QCA_WLAN_VENDOR_ATTR_NDP_CONFIRM_IND = 10, - QCA_WLAN_VENDOR_ATTR_NDP_END_IND = 11 -}; - /** * os_if_nan_process_ndp_cmd: os_if api to handle nan request message * @psoc: pointer to psoc object diff --git a/src/os_if_nan.c b/src/os_if_nan.c index f9a35beb7358..fc06c42f0a11 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -94,7 +94,7 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .type = NLA_U32, .len = sizeof(uint32_t) }, - [QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE] = { + [QCA_WLAN_VENDOR_ATTR_NDP_CSID] = { .type = NLA_U32, .len = sizeof(uint32_t) }, @@ -252,9 +252,9 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, return -EINVAL; } - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]) { + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_CSID]) { *ncs_sk_type = - nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE]); + nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CSID]); } if (tb[QCA_WLAN_VENDOR_ATTR_NDP_PMK]) { @@ -309,7 +309,7 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional - * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_CSID - optional * QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - optional * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - optional * @@ -441,7 +441,7 @@ initiator_req_failed: * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO - optional * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS - optional * QCA_WLAN_VENDOR_ATTR_NDP_PMK - optional - * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE - optional + * QCA_WLAN_VENDOR_ATTR_NDP_CSID - optional * QCA_WLAN_VENDOR_ATTR_NDP_PASSPHRASE - optional * QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME - optional * @@ -866,7 +866,7 @@ static inline uint32_t osif_ndp_get_ndp_req_ind_len( data_len += nla_total_size(vendor_attr_policy[ QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS].len); data_len += nla_total_size(vendor_attr_policy[ - QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE].len); + QCA_WLAN_VENDOR_ATTR_NDP_CSID].len); /* allocate space including NULL terminator */ data_len += nla_total_size(vendor_attr_policy[ QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR].len + 1); @@ -897,7 +897,7 @@ static inline uint32_t osif_ndp_get_ndp_req_ind_len( * QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID (4 bytes) * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size) * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS (4 bytes) - * QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE(4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_CSID(4 bytes) * QCA_WLAN_VENDOR_ATTR_NDP_SCID(scid_len in size) * * Return: none @@ -997,7 +997,7 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, if (event->scid.scid_len) { if (nla_put_u32(vendor_event, - QCA_WLAN_VENDOR_ATTR_NDP_NCS_SK_TYPE, + QCA_WLAN_VENDOR_ATTR_NDP_CSID, event->ncs_sk_type)) goto ndp_indication_nla_failed; From 8a810cf7370c580c4d0e9b8fc836a907f594f859 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Sun, 6 May 2018 00:09:31 -0700 Subject: [PATCH 60/92] qcacmn: Fix typo "sucess" Replace typo "sucess" with correct spelling "success" Change-Id: Ieacb299890210d67848268a389a57168e2a2badd CRs-Fixed: 2238309 --- dispatcher/inc/nan_ucfg_api.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dispatcher/inc/nan_ucfg_api.h b/dispatcher/inc/nan_ucfg_api.h index 7e9f16c0dcfb..2c24a483760c 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/dispatcher/inc/nan_ucfg_api.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 @@ -168,7 +168,7 @@ uint32_t ucfg_nan_get_ndi_delete_rsp_status(struct wlan_objmgr_vdev *vdev); * @psoc: pointer to psoc object * @cb_obj: callback struct to populate * - * Return: callback struct on sucess, NULL otherwise + * Return: callback struct on success, NULL otherwise */ QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); @@ -230,7 +230,7 @@ int ucfg_nan_register_lim_callbacks(struct wlan_objmgr_psoc *psoc, * @psoc: pointer to psoc object * @cb_obj: callback struct to populate * - * Return: callback struct on sucess, NULL otherwise + * Return: callback struct on success, NULL otherwise */ QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, struct nan_callbacks *cb_obj); From c13a5a3e5a106ddaf7af43f700232d3222c66bf1 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Sat, 12 May 2018 13:22:27 -0700 Subject: [PATCH 61/92] qcacmn: umac: Fix misspellings Address the following issues in the umac folder: CHECK: 'defintions' may be misspelled - perhaps 'definitions'? CHECK: 'destory' may be misspelled - perhaps 'destroy'? CHECK: 'faild' may be misspelled - perhaps 'failed'? CHECK: 'initilization' may be misspelled - perhaps 'initialization'? CHECK: 'managment' may be misspelled - perhaps 'management'? CHECK: 'muticast' may be misspelled - perhaps 'multicast'? CHECK: 'ouput' may be misspelled - perhaps 'output'? CHECK: 'segement' may be misspelled - perhaps 'segment'? CHECK: 'successfull' may be misspelled - perhaps 'successful'? CHECK: 'untill' may be misspelled - perhaps 'until'? Change-Id: If60c276c134ef10ce6be26cd5a4036d53d5724b6 CRs-Fixed: 2241586 --- dispatcher/src/nan_ucfg_api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index dc9412ac8bad..8482c4390d14 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -339,7 +339,7 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, msg.callback = nan_scheduled_msg_handler; status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg); if (QDF_IS_STATUS_ERROR(status)) { - nan_err("faild to post msg to NAN component, status: %d", + nan_err("failed to post msg to NAN component, status: %d", status); } From 366330a4177db9b12b327edd8d987a212e01c634 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 9 Jan 2018 17:54:41 -0800 Subject: [PATCH 62/92] 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/os_if_nan.c | 248 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 241 insertions(+), 7 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index fc06c42f0a11..92f00d2bd8f5 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -122,6 +122,14 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .type = NLA_BINARY, .len = NAN_MAX_SERVICE_NAME_LEN }, + [QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO] = { + .type = NLA_BINARY, + .len = NAN_CH_INFO_MAX_LEN + }, + [QCA_WLAN_VENDOR_ATTR_NDP_NSS] = { + .type = NLA_U32, + .len = sizeof(uint32_t) + }, }; static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, @@ -1023,6 +1031,7 @@ ndp_indication_nla_failed: static inline uint32_t osif_ndp_get_ndp_confirm_ind_len( struct nan_datapath_confirm_event *ndp_confirm) { + uint32_t ch_info_len = 0; uint32_t data_len = NLMSG_HDRLEN; data_len += nla_total_size(vendor_attr_policy[ @@ -1042,9 +1051,62 @@ static inline uint32_t osif_ndp_get_ndp_confirm_ind_len( data_len += nla_total_size(ndp_confirm->ndp_info.ndp_app_info_len); + /* ch_info is a nested array of following attributes */ + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL].len); + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH].len); + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_NSS].len); + + if (ndp_confirm->num_channels) + data_len += ndp_confirm->num_channels * + nla_total_size(ch_info_len); + return data_len; } +static QDF_STATUS os_if_ndp_confirm_pack_ch_info(struct sk_buff *event, + struct nan_datapath_confirm_event *ndp_confirm) +{ + int idx = 0; + struct nlattr *ch_array, *ch_element; + + cfg80211_debug("num_ch: %d", ndp_confirm->num_channels); + if (!ndp_confirm->num_channels) + return QDF_STATUS_SUCCESS; + + ch_array = nla_nest_start(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO); + if (!ch_array) + return QDF_STATUS_E_FAULT; + + for (idx = 0; idx < ndp_confirm->num_channels; idx++) { + cfg80211_debug("ch[%d]: freq: %d, width: %d, nss: %d", + idx, ndp_confirm->ch[idx].channel, + ndp_confirm->ch[idx].ch_width, + ndp_confirm->ch[idx].nss); + ch_element = nla_nest_start(event, idx); + if (!ch_element) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL, + ndp_confirm->ch[idx].channel)) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH, + ndp_confirm->ch[idx].ch_width)) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_NSS, + ndp_confirm->ch[idx].nss)) + return QDF_STATUS_E_FAULT; + nla_nest_end(event, ch_element); + } + nla_nest_end(event, ch_array); + + return QDF_STATUS_SUCCESS; +} + /** * os_if_ndp_confirm_ind_handler() - NDP confirm indication handler * @vdev: pointer to vdev object @@ -1062,20 +1124,20 @@ static inline uint32_t osif_ndp_get_ndp_confirm_ind_len( * * Return: none */ -static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, - struct nan_datapath_confirm_event *ndp_confirm) +static void +os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, + struct nan_datapath_confirm_event *ndp_confirm) { int idx = 0; uint8_t *ifname; uint32_t data_len; QDF_STATUS status; qdf_size_t ifname_len; - uint32_t ndp_qos_config = 0; + struct nan_callbacks cb_obj; struct sk_buff *vendor_event; struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(vdev); struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); - struct nan_callbacks cb_obj; if (!ndp_confirm) { cfg80211_err("Invalid NDP Initator response"); @@ -1156,12 +1218,19 @@ static void os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, ndp_confirm->reason_code)) goto ndp_confirm_nla_failed; + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS, + ndp_confirm->num_channels)) + goto ndp_confirm_nla_failed; + + status = os_if_ndp_confirm_pack_ch_info(vendor_event, ndp_confirm); + if (QDF_IS_STATUS_ERROR(status)) + goto ndp_confirm_nla_failed; + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); - cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM, ndp_cfg: %d, rsp_code: %d, reason_code: %d", + cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM rsp_code: %d, reason_code: %d", ndp_confirm->ndp_instance_id, ndp_confirm->peer_ndi_mac_addr.bytes, - ndp_qos_config, ndp_confirm->rsp_code, - ndp_confirm->reason_code); + ndp_confirm->rsp_code, ndp_confirm->reason_code); cfg80211_debug("NDP confim, ndp app info dump"); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG, @@ -1620,6 +1689,168 @@ static void os_if_ndp_iface_delete_rsp_handler(struct wlan_objmgr_psoc *psoc, cb_obj.drv_ndi_delete_rsp_handler(vdev_id); } +static inline uint32_t osif_ndp_get_ndp_sch_update_ind_len( + struct nan_datapath_sch_update_event *sch_update) +{ + uint32_t ch_info_len = 0; + uint32_t data_len = NLMSG_HDRLEN; + + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR].len); + if (sch_update->num_ndp_instances) + data_len += nla_total_size(sch_update->num_ndp_instances * + sizeof(uint32_t)); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REASON].len); + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS].len); + /* ch_info is a nested array of following attributes */ + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL].len); + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH].len); + ch_info_len += nla_total_size( + vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_NSS].len); + + if (sch_update->num_ndp_instances) + data_len += sch_update->num_ndp_instances * + nla_total_size(ch_info_len); + + return data_len; +} + +static QDF_STATUS os_if_ndp_sch_update_pack_ch_info(struct sk_buff *event, + struct nan_datapath_sch_update_event *sch_update) +{ + int idx = 0; + struct nlattr *ch_array, *ch_element; + + cfg80211_debug("num_ch: %d", sch_update->num_channels); + if (!sch_update->num_channels) + return QDF_STATUS_SUCCESS; + + ch_array = nla_nest_start(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_INFO); + if (!ch_array) + return QDF_STATUS_E_FAULT; + + for (idx = 0; idx < sch_update->num_channels; idx++) { + cfg80211_debug("ch[%d]: freq: %d, width: %d, nss: %d", + idx, sch_update->ch[idx].channel, + sch_update->ch[idx].ch_width, + sch_update->ch[idx].nss); + ch_element = nla_nest_start(event, idx); + if (!ch_element) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL, + sch_update->ch[idx].channel)) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL_WIDTH, + sch_update->ch[idx].ch_width)) + return QDF_STATUS_E_FAULT; + + if (nla_put_u32(event, QCA_WLAN_VENDOR_ATTR_NDP_NSS, + sch_update->ch[idx].nss)) + return QDF_STATUS_E_FAULT; + nla_nest_end(event, ch_element); + } + nla_nest_end(event, ch_array); + + return QDF_STATUS_SUCCESS; +} + +/** + * os_if_ndp_sch_update_ind_handler() - NDP schedule update handler + * @vdev: vdev object pointer + * @ind: sch update pointer + * + * Following vendor event is sent to cfg80211: + * + * Return: none + */ +static void os_if_ndp_sch_update_ind_handler(struct wlan_objmgr_vdev *vdev, + void *ind) +{ + int idx = 0; + uint8_t *ifname; + QDF_STATUS status; + uint32_t data_len; + uint8_t ifname_len; + struct sk_buff *vendor_event; + struct nan_datapath_sch_update_event *sch_update = ind; + struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev); + struct pdev_osif_priv *os_priv = wlan_pdev_get_ospriv(pdev); + + if (!sch_update) { + cfg80211_err("Invalid sch update params"); + return; + } + + ifname = wlan_util_vdev_get_if_name(vdev); + if (!ifname) { + cfg80211_err("ifname is null"); + return; + } + ifname_len = qdf_str_len(ifname); + if (ifname_len > IFNAMSIZ) { + cfg80211_err("ifname(%d) too long", ifname_len); + return; + } + + data_len = osif_ndp_get_ndp_sch_update_ind_len(sch_update); + vendor_event = cfg80211_vendor_event_alloc(os_priv->wiphy, NULL, + data_len, QCA_NL80211_VENDOR_SUBCMD_NDP_INDEX, + GFP_ATOMIC); + if (!vendor_event) { + cfg80211_err("cfg80211_vendor_event_alloc failed"); + return; + } + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_IND)) + goto ndp_sch_ind_nla_failed; + + if (nla_put(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR, + QDF_MAC_ADDR_SIZE, sch_update->peer_addr.bytes)) + goto ndp_sch_ind_nla_failed; + + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY, + sch_update->num_ndp_instances * sizeof(uint32_t), + sch_update->ndp_instances)) + goto ndp_sch_ind_nla_failed; + + if (nla_put_u32(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_SCHEDULE_UPDATE_REASON, + sch_update->flags)) + goto ndp_sch_ind_nla_failed; + + if (nla_put_u32(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_NUM_CHANNELS, + sch_update->num_channels)) + goto ndp_sch_ind_nla_failed; + + status = os_if_ndp_sch_update_pack_ch_info(vendor_event, sch_update); + if (QDF_IS_STATUS_ERROR(status)) + goto ndp_sch_ind_nla_failed; + + cfg80211_debug("Flags: %d, num_instance_id: %d", sch_update->flags, + sch_update->num_ndp_instances); + + for (idx = 0; idx < sch_update->num_ndp_instances; idx++) + cfg80211_debug("ndp_instance[%d]: %d", idx, + sch_update->ndp_instances[idx]); + + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); + return; + +ndp_sch_ind_nla_failed: + cfg80211_err("nla_put api failed"); + kfree_skb(vendor_event); +} + void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_vdev *vdev, uint32_t type, void *msg) @@ -1655,6 +1886,9 @@ void os_if_nan_event_handler(struct wlan_objmgr_psoc *psoc, case NDP_PEER_DEPARTED: os_if_peer_departed_ind_handler(vdev, msg); break; + case NDP_SCHEDULE_UPDATE: + os_if_ndp_sch_update_ind_handler(vdev, msg); + break; default: break; } From a955debb8cd8de555450a5e05c63ea2540362b47 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 9 Jan 2018 17:54:41 -0800 Subject: [PATCH 63/92] 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 --- core/inc/nan_public_structs.h | 95 +++++++++++++++++++++++++++++------ core/src/nan_main.c | 27 ++++++++++ 2 files changed, 106 insertions(+), 16 deletions(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 2a473c20b714..a4da6e8225b3 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -39,23 +39,45 @@ struct wlan_objmgr_vdev; #define NAN_MAX_SERVICE_NAME_LEN 255 #define NAN_PASSPHRASE_MIN_LEN 8 #define NAN_PASSPHRASE_MAX_LEN 63 +#define NAN_CH_INFO_MAX_CHANNELS 4 - -#define NAN_DATAPATH_INF_CREATE_REQ 0 -#define NAN_DATAPATH_INF_CREATE_RSP 1 -#define NAN_DATAPATH_INF_DELETE_REQ 2 -#define NAN_DATAPATH_INF_DELETE_RSP 3 -#define NDP_INITIATOR_REQ 4 -#define NDP_INITIATOR_RSP 5 -#define NDP_RESPONDER_REQ 6 -#define NDP_RESPONDER_RSP 7 -#define NDP_END_REQ 8 -#define NDP_END_RSP 9 -#define NDP_INDICATION 10 -#define NDP_CONFIRM 11 -#define NDP_END_IND 12 -#define NDP_NEW_PEER 13 -#define NDP_PEER_DEPARTED 14 +/** + * enum nan_datapath_msg_type - NDP msg type + * @NAN_DATAPATH_INF_CREATE_REQ: ndi create request + * @NAN_DATAPATH_INF_CREATE_RSP: ndi create response + * @NAN_DATAPATH_INF_DELETE_REQ: ndi delete request + * @NAN_DATAPATH_INF_DELETE_RSP: ndi delete response + * @NDP_INITIATOR_REQ: ndp initiator request + * @NDP_INITIATOR_RSP: ndp initiator response + * @NDP_RESPONDER_REQ: ndp responder request + * @NDP_RESPONDER_RSP: ndp responder response + * @NDP_END_REQ: ndp end request + * @NDP_END_RSP: ndp end response + * @NDP_INDICATION: ndp indication + * @NDP_CONFIRM: ndp confirm + * @NDP_END_IND: ndp end indication + * @NDP_NEW_PEER: ndp new peer created + * @NDP_PEER_DEPARTED: ndp peer departed/deleted + * @NDP_SCHEDULE_UPDATE: ndp schedule update + */ +enum nan_datapath_msg_type { + NAN_DATAPATH_INF_CREATE_REQ = 0, + NAN_DATAPATH_INF_CREATE_RSP = 1, + NAN_DATAPATH_INF_DELETE_REQ = 2, + NAN_DATAPATH_INF_DELETE_RSP = 3, + NDP_INITIATOR_REQ = 4, + NDP_INITIATOR_RSP = 5, + NDP_RESPONDER_REQ = 6, + NDP_RESPONDER_RSP = 7, + NDP_END_REQ = 8, + NDP_END_RSP = 9, + NDP_INDICATION = 10, + NDP_CONFIRM = 11, + NDP_END_IND = 12, + NDP_NEW_PEER = 13, + NDP_PEER_DEPARTED = 14, + NDP_SCHEDULE_UPDATE = 15, +}; /** * enum nan_datapath_status_type - NDP status type @@ -279,6 +301,22 @@ struct peer_nan_datapath_map { uint32_t ndp_instance_id; }; +/** + * struct nan_datapath_channel_info - ndp channel and channel bandwidth + * @channel: channel freq in mhz of the ndp connection + * @ch_width: channel width (wmi_channel_width) of the ndp connection + * @nss: nss used for ndp connection + * + */ +struct nan_datapath_channel_info { + uint32_t channel; + uint32_t ch_width; + uint32_t nss; +}; + +#define NAN_CH_INFO_MAX_LEN \ + (NAN_CH_INFO_MAX_CHANNELS * sizeof(struct nan_datapath_channel_info)) + /** * struct nan_datapath_inf_create_req - ndi create request params * @transaction_id: unique identifier @@ -460,6 +498,8 @@ struct nan_datapath_end_indication_event { * @num_active_ndps_on_peer: number of ndp instances on peer * @peer_ndi_mac_addr: peer NDI mac address * @rsp_code: ndp response code + * @num_channels: num channels + * @ch: channel info struct array * @ndp_info: ndp application info * */ @@ -470,6 +510,8 @@ struct nan_datapath_confirm_event { uint32_t num_active_ndps_on_peer; struct qdf_mac_addr peer_ndi_mac_addr; enum nan_datapath_response_code rsp_code; + uint32_t num_channels; + struct nan_datapath_channel_info ch[NAN_CH_INFO_MAX_CHANNELS]; struct nan_datapath_app_info ndp_info; }; @@ -516,6 +558,27 @@ struct nan_datapath_peer_ind { uint16_t sta_id; }; +/** + * struct nan_datapath_sch_update_event - ndp schedule update indication + * @vdev: vdev schedule update was received + * @peer_addr: peer for which schedule update was received + * @flags: reason for sch update (opaque to driver) + * @num_channels: num of channels + * @num_ndp_instances: num of ndp instances + * @ch: channel info array + * @ndp_instances: array of ndp instances + * + */ +struct nan_datapath_sch_update_event { + struct wlan_objmgr_vdev *vdev; + struct qdf_mac_addr peer_addr; + uint32_t flags; + uint32_t num_channels; + uint32_t num_ndp_instances; + struct nan_datapath_channel_info ch[NAN_CH_INFO_MAX_CHANNELS]; + uint32_t ndp_instances[NDP_NUM_INSTANCE_ID]; +}; + /** * struct nan_callbacks - struct containing callback to non-converged driver * diff --git a/core/src/nan_main.c b/core/src/nan_main.c index cc84277e9c33..bdedd2fd926b 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -441,6 +441,30 @@ static QDF_STATUS nan_handle_end_ind( return QDF_STATUS_SUCCESS; } +static QDF_STATUS nan_handle_schedule_update( + struct nan_datapath_sch_update_event *ind) +{ + struct wlan_objmgr_psoc *psoc; + struct nan_psoc_priv_obj *psoc_nan_obj; + + psoc = wlan_vdev_get_psoc(ind->vdev); + if (!psoc) { + nan_err("psoc is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj = nan_get_psoc_priv_obj(psoc); + if (!psoc_nan_obj) { + nan_err("psoc_nan_obj is NULL"); + return QDF_STATUS_E_NULL_VALUE; + } + + psoc_nan_obj->cb_obj.os_if_event_handler(psoc, ind->vdev, + NDP_SCHEDULE_UPDATE, ind); + + return QDF_STATUS_SUCCESS; +} + QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) { QDF_STATUS status = QDF_STATUS_SUCCESS; @@ -484,6 +508,9 @@ QDF_STATUS nan_event_handler(struct scheduler_msg *pe_msg) case NDP_END_IND: nan_handle_end_ind(pe_msg->bodyptr); break; + case NDP_SCHEDULE_UPDATE: + nan_handle_schedule_update(pe_msg->bodyptr); + break; default: nan_alert("Unhandled NDP event: %d", pe_msg->type); status = QDF_STATUS_E_NOSUPPORT; From ad053f2b832c900af1965718f4ea7ced9ff4f825 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 9 Jan 2018 17:54:41 -0800 Subject: [PATCH 64/92] 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 570c5dffdf9a..da883b342294 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 93a3d3a358ce0af790c4d4c33c3f9844d1b33866 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 7 Jun 2018 11:50:40 -0700 Subject: [PATCH 65/92] qcacmn: Fix NPD in function os_if_nan_process_ndp_responder_req While processing of NDP responder request if NDP response code is accept NDI interface is must. Throw error if interface is not provided and bail out of the function. Change-Id: I7266e3c82062130f6dbeb078cddfaa15a87d9197 CRs-Fixed: 2247586 --- src/os_if_nan.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 92f00d2bd8f5..bf8b29c5d6fc 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -473,24 +473,24 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, req.ndp_rsp = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]); if (req.ndp_rsp == NAN_DATAPATH_RESPONSE_ACCEPT) { - if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { - iface_name = - nla_data( - tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); + if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]) { + cfg80211_err("Interface not provided"); + return -ENODEV; + } + iface_name = nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IFACE_STR]); - /* Check for an existing NAN interface */ - nan_vdev = wlan_util_get_vdev_by_ifname(psoc, - iface_name, WLAN_NAN_ID); - if (!nan_vdev) { - cfg80211_err("NAN data iface %s not available", - iface_name); - return -ENODEV; - } + /* Check for an existing NAN interface */ + nan_vdev = wlan_util_get_vdev_by_ifname(psoc, iface_name, + WLAN_NAN_ID); + if (!nan_vdev) { + cfg80211_err("NAN data iface %s not available", + iface_name); + return -ENODEV; + } - if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { - cfg80211_err("Interface found is not NDI"); - return -ENODEV; - } + if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { + cfg80211_err("Interface found is not NDI"); + return -ENODEV; } } else { From 6cc4310a8b6309bdb703df6db78f8ae56999bc29 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 30 May 2018 17:47:15 -0700 Subject: [PATCH 66/92] qcacmn: Fix NDI create sequence Create NDI vdev after adapter is added to back of hdd adapter list, so that vdev create completion callback can identify right adapter and set corresponding completion variable. Change-Id: Id0d78a5e482c875fee346224f37c29a874814133 CRs-Fixed: 2252031 --- core/inc/nan_public_structs.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index a4da6e8225b3..1ac7483a7c1e 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -589,8 +589,8 @@ struct nan_callbacks { struct wlan_objmgr_vdev *vdev, uint32_t type, void *msg); - struct wlan_objmgr_vdev* (*ndi_open)(char *iface_name); - int (*ndi_start)(uint8_t); + int (*ndi_open)(char *iface_name); + int (*ndi_start)(char *iface_name, uint16_t); void (*ndi_close)(uint8_t); int (*ndi_delete)(uint8_t, char *iface_name, uint16_t transaction_id); void (*drv_ndi_create_rsp_handler)(uint8_t, From fad2a7d06b56ad87151af752cae29553096c3044 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 30 May 2018 17:47:15 -0700 Subject: [PATCH 67/92] qcacmn: Fix NDI create sequence Create NDI vdev after adapter is added to back of hdd adapter list, so that vdev create completion callback can identify right adapter and set corresponding completion variable. Change-Id: Id0d78a5e482c875fee346224f37c29a874814133 CRs-Fixed: 2252031 --- src/os_if_nan.c | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index bf8b29c5d6fc..6a08c88adbdc 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -135,6 +135,7 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, struct nlattr **tb) { + int ret; char *iface_name; QDF_STATUS status; uint16_t transaction_id; @@ -169,21 +170,14 @@ static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, return -EINVAL; } - nan_vdev = cb_obj.ndi_open(iface_name); - - if (!nan_vdev) { + ret = cb_obj.ndi_open(iface_name); + if (ret) { cfg80211_err("ndi_open failed"); - return -EINVAL; + return ret; } - /* - * Create transaction id is required to be saved since the firmware - * does not honor the transaction id for create request - */ - ucfg_nan_set_ndp_create_transaction_id(nan_vdev, transaction_id); - ucfg_nan_set_ndi_state(nan_vdev, NAN_DATA_NDI_CREATING_STATE); - return cb_obj.ndi_start(wlan_vdev_get_id(nan_vdev)); + return cb_obj.ndi_start(iface_name, transaction_id); } static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, From 8cec49f25c14c29d38a5ccfb8e88add331d1da92 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 31 May 2018 10:40:32 -0700 Subject: [PATCH 68/92] qcacmn: Fix vdev reference in NDP commands Assign the vdev in NDP request message and hold the vdev reference till the command is processed. Else the consumer of message will fail when trying to take reference since vdev was not set in request packet. Change-Id: I4c7e50690eff1f92f151f00209ec786a03252e76 CRs-Fixed: 2252035 --- core/src/nan_main.c | 9 --------- 1 file changed, 9 deletions(-) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index bdedd2fd926b..6cbe0288f0dd 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -187,7 +187,6 @@ static QDF_STATUS nan_serialized_cb(void *cmd, QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) { - QDF_STATUS ref_status; enum wlan_serialization_status status = 0; struct wlan_serialization_command cmd = {0}; @@ -219,14 +218,6 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) return QDF_STATUS_E_INVAL; } - /* try get ref now, if failure, then vdev may have been deleted */ - ref_status = wlan_objmgr_vdev_try_get_ref(cmd.vdev, WLAN_NAN_ID); - if (QDF_IS_STATUS_ERROR(ref_status)) { - nan_alert("couldn't get ref. vdev maybe deleted"); - return QDF_STATUS_E_INVAL; - } - /* reference will be released when ser command finishes */ - /* TBD - support more than one req of same type or avoid */ cmd.cmd_id = 0; cmd.cmd_cb = nan_serialized_cb; From 39a489d82d9a896dfcf42dfa22937f065dba9e66 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 31 May 2018 10:40:32 -0700 Subject: [PATCH 69/92] qcacmn: Fix vdev reference in NDP commands Assign the vdev in NDP request message and hold the vdev reference till the command is processed. Else the consumer of message will fail when trying to take reference since vdev was not set in request packet. Change-Id: I4c7e50690eff1f92f151f00209ec786a03252e76 CRs-Fixed: 2252035 --- src/os_if_nan.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 6a08c88adbdc..06edb07f4b0f 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -341,7 +341,8 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { cfg80211_err("Interface found is not NDI"); - return -EINVAL; + ret = -EINVAL; + goto initiator_req_failed; } state = ucfg_nan_get_ndi_state(nan_vdev); @@ -422,10 +423,12 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, req.service_instance_id, req.ndp_info.ndp_app_info_len, req.ncs_sk_type, req.peer_discovery_mac_addr.bytes); + req.vdev = nan_vdev; status = ucfg_nan_req_processor(nan_vdev, &req, NDP_INITIATOR_REQ); ret = qdf_status_to_os_return(status); initiator_req_failed: - wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + if (ret) + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); return ret; } @@ -461,8 +464,7 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]) { cfg80211_err("ndp_rsp is unavailable"); - ret = -EINVAL; - goto responder_req_failed; + return -EINVAL; } req.ndp_rsp = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE]); @@ -484,7 +486,8 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, if (nan_vdev->vdev_mlme.vdev_opmode != QDF_NDI_MODE) { cfg80211_err("Interface found is not NDI"); - return -ENODEV; + ret = -ENODEV; + goto responder_req_failed; } } else { @@ -513,8 +516,6 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, goto responder_req_failed; } - req.vdev = nan_vdev; - if (!tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) { cfg80211_err("Transaction ID is unavailable"); ret = -EINVAL; @@ -562,11 +563,13 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, req.ndp_instance_id, req.ndp_info.ndp_app_info_len, req.ncs_sk_type); + req.vdev = nan_vdev; status = ucfg_nan_req_processor(nan_vdev, &req, NDP_RESPONDER_REQ); ret = qdf_status_to_os_return(status); responder_req_failed: - wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + if (ret) + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); return ret; @@ -623,9 +626,11 @@ static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, return -EINVAL; } + req.vdev = nan_vdev; status = ucfg_nan_req_processor(nan_vdev, &req, NDP_END_REQ); ret = qdf_status_to_os_return(status); - wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); + if (ret) + wlan_objmgr_vdev_release_ref(nan_vdev, WLAN_NAN_ID); return ret; } From 5a2ac039a97d9f2365738e6ace4000e14cf58c62 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 31 May 2018 15:04:59 -0700 Subject: [PATCH 70/92] qcacmn: Add support for NDP TCP/IP params Add support for NDP TCP/IP params in ndp initiator request, responder request, indication and confirm. Change-Id: I5d60af154ea4a2f33d18d9b86049f316e7fbc524 CRs-Fixed: 2252227 --- core/inc/nan_public_structs.h | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 1ac7483a7c1e..615b124ee9ff 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -366,6 +366,8 @@ struct nan_datapath_inf_delete_rsp { * @pmk: pairwise master key * @passphrase: passphrase * @service_name: service name + * @is_ipv6_addr_present: indicates if following ipv6 address is valid + * @ipv6_addr: ipv6 address address used by ndp */ struct nan_datapath_initiator_req { struct wlan_objmgr_vdev *vdev; @@ -381,6 +383,8 @@ struct nan_datapath_initiator_req { struct nan_datapath_pmk pmk; struct ndp_passphrase passphrase; struct ndp_service_name service_name; + bool is_ipv6_addr_present; + uint8_t ipv6_addr[QDF_IPV6_ADDR_SIZE]; }; /** @@ -413,6 +417,12 @@ struct nan_datapath_initiator_rsp { * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 * @passphrase: passphrase * @service_name: service name + * @is_ipv6_addr_present: indicates if following ipv6 address is valid + * @ipv6_addr: ipv6 address address used by ndp + * @is_port_present: indicates if following port is valid + * @port: port specified by for this NDP + * @is_protocol_present: indicates if following protocol is valid + * @protocol: protocol used by this NDP * */ struct nan_datapath_responder_req { @@ -426,6 +436,12 @@ struct nan_datapath_responder_req { uint32_t ncs_sk_type; struct ndp_passphrase passphrase; struct ndp_service_name service_name; + bool is_ipv6_addr_present; + uint8_t ipv6_addr[QDF_IPV6_ADDR_SIZE]; + bool is_port_present; + uint16_t port; + bool is_protocol_present; + uint8_t protocol; }; /** @@ -501,6 +517,12 @@ struct nan_datapath_end_indication_event { * @num_channels: num channels * @ch: channel info struct array * @ndp_info: ndp application info + * @is_ipv6_addr_present: indicates if following ipv6 address is valid + * @ipv6_addr: ipv6 address address used by ndp + * @is_port_present: indicates if following port is valid + * @port: port specified by for this NDP + * @is_protocol_present: indicates if following protocol is valid + * @protocol: protocol used by this NDP * */ struct nan_datapath_confirm_event { @@ -513,6 +535,12 @@ struct nan_datapath_confirm_event { uint32_t num_channels; struct nan_datapath_channel_info ch[NAN_CH_INFO_MAX_CHANNELS]; struct nan_datapath_app_info ndp_info; + bool is_ipv6_addr_present; + uint8_t ipv6_addr[QDF_IPV6_ADDR_SIZE]; + bool is_port_present; + uint16_t port; + bool is_protocol_present; + uint8_t protocol; }; /** @@ -529,6 +557,8 @@ struct nan_datapath_confirm_event { * @ndp_info: ndp application info * @ncs_sk_type: indicates NCS_SK_128 or NCS_SK_256 * @scid: security context identifier + * @is_ipv6_addr_present: indicates if following ipv6 address is valid + * @ipv6_addr: ipv6 address address used by ndp * */ struct nan_datapath_indication_event { @@ -543,6 +573,8 @@ struct nan_datapath_indication_event { struct nan_datapath_app_info ndp_info; uint32_t ncs_sk_type; struct nan_datapath_scid scid; + bool is_ipv6_addr_present; + uint8_t ipv6_addr[QDF_IPV6_ADDR_SIZE]; }; /** From 4ceeebe462a7a234a79f27da6907235e4f4e2341 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 31 May 2018 15:04:59 -0700 Subject: [PATCH 71/92] qcacmn: Add support for NDP TCP/IP params Add support for NDP TCP/IP params in ndp initiator request, responder request, indication and confirm. Change-Id: I5d60af154ea4a2f33d18d9b86049f316e7fbc524 CRs-Fixed: 2252227 --- src/os_if_nan.c | 92 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 91 insertions(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 06edb07f4b0f..95ab8154df7f 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -130,6 +130,18 @@ vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_PARAMS_MAX + 1] = { .type = NLA_U32, .len = sizeof(uint32_t) }, + [QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR] = { + .type = NLA_UNSPEC, + .len = QDF_IPV6_ADDR_SIZE + }, + [QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT] = { + .type = NLA_U16, + .len = sizeof(uint16_t) + }, + [QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL] = { + .type = NLA_U8, + .len = sizeof(uint8_t) + }, }; static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, @@ -411,6 +423,15 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS]); } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR]) { + req.is_ipv6_addr_present = true; + qdf_mem_copy(req.ipv6_addr, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR]), + QDF_IPV6_ADDR_SIZE); + } + cfg80211_debug("ipv6 addr present: %d, addr: %pI6", + req.is_ipv6_addr_present, req.ipv6_addr); + if (os_if_nan_parse_security_params(tb, &req.ncs_sk_type, &req.pmk, &req.passphrase, &req.service_name)) { cfg80211_err("inconsistent security params in request."); @@ -490,7 +511,6 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, goto responder_req_failed; } } else { - /* * If the data indication is rejected, the userspace * may not send the iface name. Use the first NDI @@ -551,6 +571,28 @@ static int os_if_nan_process_ndp_responder_req(struct wlan_objmgr_psoc *psoc, cfg80211_debug("NDP config data is unavailable"); } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR]) { + req.is_ipv6_addr_present = true; + qdf_mem_copy(req.ipv6_addr, + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR]), + QDF_IPV6_ADDR_SIZE); + } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT]) { + req.is_port_present = true; + req.port = nla_get_u16( + tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT]); + } + if (tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL]) { + req.is_protocol_present = true; + req.protocol = nla_get_u8( + tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL]); + } + cfg80211_debug("ipv6 addr present: %d, addr: %pI6", + req.is_ipv6_addr_present, req.ipv6_addr); + cfg80211_debug("port %d, present: %d", req.port, req.is_port_present); + cfg80211_debug("protocol %d, present: %d", + req.protocol, req.is_protocol_present); + if (os_if_nan_parse_security_params(tb, &req.ncs_sk_type, &req.pmk, &req.passphrase, &req.service_name)) { cfg80211_err("inconsistent security params in request."); @@ -881,6 +923,9 @@ static inline uint32_t osif_ndp_get_ndp_req_ind_len( QCA_WLAN_VENDOR_ATTR_NDP_NDI_MAC_ADDR].len); data_len += nla_total_size(vendor_attr_policy[ QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR].len); + if (event->is_ipv6_addr_present) + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR].len); if (event->scid.scid_len) data_len += nla_total_size(event->scid.scid_len); if (event->ndp_info.ndp_app_info_len) @@ -906,6 +951,7 @@ static inline uint32_t osif_ndp_get_ndp_req_ind_len( * QCA_WLAN_VENDOR_ATTR_NDP_CONFIG_QOS (4 bytes) * QCA_WLAN_VENDOR_ATTR_NDP_CSID(4 bytes) * QCA_WLAN_VENDOR_ATTR_NDP_SCID(scid_len in size) + * QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR (16 bytes) * * Return: none */ @@ -1020,6 +1066,14 @@ static void os_if_ndp_indication_handler(struct wlan_objmgr_vdev *vdev, event->scid.scid, event->scid.scid_len); } + if (event->is_ipv6_addr_present) { + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR, + QDF_IPV6_ADDR_SIZE, event->ipv6_addr)) + goto ndp_indication_nla_failed; + } + cfg80211_debug("ipv6 addr present: %d, addr: %pI6", + event->is_ipv6_addr_present, event->ipv6_addr); + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); return; ndp_indication_nla_failed: @@ -1050,6 +1104,16 @@ static inline uint32_t osif_ndp_get_ndp_confirm_ind_len( data_len += nla_total_size(ndp_confirm->ndp_info.ndp_app_info_len); + if (ndp_confirm->is_ipv6_addr_present) + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR].len); + if (ndp_confirm->is_port_present) + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT].len); + if (ndp_confirm->is_protocol_present) + data_len += nla_total_size(vendor_attr_policy[ + QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL].len); + /* ch_info is a nested array of following attributes */ ch_info_len += nla_total_size( vendor_attr_policy[QCA_WLAN_VENDOR_ATTR_NDP_CHANNEL].len); @@ -1120,6 +1184,9 @@ static QDF_STATUS os_if_ndp_confirm_pack_ch_info(struct sk_buff *event, * QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO (ndp_app_info_len size) * QCA_WLAN_VENDOR_ATTR_NDP_RESPONSE_CODE (4 bytes) * QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE (4 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR (16 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT (2 bytes) + * QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL (1 byte) * * Return: none */ @@ -1225,6 +1292,29 @@ os_if_ndp_confirm_ind_handler(struct wlan_objmgr_vdev *vdev, if (QDF_IS_STATUS_ERROR(status)) goto ndp_confirm_nla_failed; + if (ndp_confirm->is_ipv6_addr_present) { + if (nla_put(vendor_event, QCA_WLAN_VENDOR_ATTR_NDP_IPV6_ADDR, + QDF_IPV6_ADDR_SIZE, ndp_confirm->ipv6_addr)) + goto ndp_confirm_nla_failed; + } + if (ndp_confirm->is_port_present) + if (nla_put_u16(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PORT, + ndp_confirm->port)) + goto ndp_confirm_nla_failed; + if (ndp_confirm->is_protocol_present) + if (nla_put_u8(vendor_event, + QCA_WLAN_VENDOR_ATTR_NDP_TRANSPORT_PROTOCOL, + ndp_confirm->protocol)) + goto ndp_confirm_nla_failed; + cfg80211_debug("ipv6 addr present: %d, addr: %pI6", + ndp_confirm->is_ipv6_addr_present, + ndp_confirm->ipv6_addr); + cfg80211_debug("port %d, present: %d", + ndp_confirm->port, ndp_confirm->is_port_present); + cfg80211_debug("protocol %d, present: %d", + ndp_confirm->protocol, ndp_confirm->is_protocol_present); + cfg80211_vendor_event(vendor_event, GFP_ATOMIC); cfg80211_debug("NDP confim sent, ndp instance id: %d, peer addr: %pM rsp_code: %d, reason_code: %d", ndp_confirm->ndp_instance_id, From 2c7138276f44100a980eff92a388ea2367af94b8 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 20 Jun 2018 19:48:17 -0700 Subject: [PATCH 72/92] qcacmn: Free NDI peers/vdev at time of ndi_delete/driver unload Sometime user may not delete active NDP sessions before deleting NDI or may not delete NDI before driver unload. In such case vdev/peer object memory will leak. Free all NDI peers for that vdev before processing NDI delete and free all NDI peers/vdev at driver unload. Change-Id: I04631ffd611d6ded318ddfb65b2dfeba479c9bdc CRs-Fixed: 2262769 --- core/src/nan_api.c | 47 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/core/src/nan_api.c b/core/src/nan_api.c index fe251a975864..8dd6ff9130ca 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.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 @@ -61,6 +61,43 @@ nan_psoc_notif_failed: return status; } +static void nan_psoc_delete_peer(struct wlan_objmgr_psoc *psoc, + void *peer, void *arg) +{ + if (WLAN_PEER_NDP == wlan_peer_get_peer_type(peer)) + wlan_objmgr_peer_obj_delete(peer); +} + +static void nan_psoc_delete_vdev(struct wlan_objmgr_psoc *psoc, + void *vdev, void *arg) +{ + enum nan_datapath_state state; + struct nan_vdev_priv_obj *priv_obj = nan_get_vdev_priv_obj(vdev); + + if (!priv_obj) { + nan_err("priv_obj is null"); + return; + } + /* + * user may issue rrmod wlan without explicitly NDI Delete. + * In that case pending NDI vdev state will not be DELETED/DELETEING + * Forcefully delete vdev object + */ + if (QDF_NDI_MODE != wlan_vdev_mlme_get_opmode(vdev)) + return; + + qdf_spin_lock_bh(&priv_obj->lock); + state = priv_obj->state; + qdf_spin_unlock_bh(&priv_obj->lock); + + /* if already in deleted or deleting state - do not delete */ + if (state == NAN_DATA_NDI_DELETED_STATE || + state == NAN_DATA_NDI_DELETING_STATE) + return; + + wlan_objmgr_vdev_obj_delete(vdev); +} + static QDF_STATUS nan_psoc_obj_destroyed_notification( struct wlan_objmgr_psoc *psoc, void *arg_list) { @@ -73,6 +110,14 @@ static QDF_STATUS nan_psoc_obj_destroyed_notification( return QDF_STATUS_E_FAULT; } + wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, + nan_psoc_delete_peer, + NULL, 1, WLAN_UMAC_COMP_NAN); + + wlan_objmgr_iterate_obj_list(psoc, WLAN_VDEV_OP, + nan_psoc_delete_vdev, + NULL, 1, WLAN_UMAC_COMP_NAN); + status = wlan_objmgr_psoc_component_obj_detach(psoc, WLAN_UMAC_COMP_NAN, nan_obj); if (QDF_IS_STATUS_ERROR(status)) From b85908687851d1704d676bb98f671326e200c039 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Wed, 20 Jun 2018 19:48:17 -0700 Subject: [PATCH 73/92] qcacmn: Free NDI peers/vdev at time of ndi_delete/driver unload Sometime user may not delete active NDP sessions before deleting NDI or may not delete NDI before driver unload. In such case vdev/peer object memory will leak. Free all NDI peers for that vdev before processing NDI delete and free all NDI peers/vdev at driver unload. Change-Id: I04631ffd611d6ded318ddfb65b2dfeba479c9bdc CRs-Fixed: 2262769 --- src/os_if_nan.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 95ab8154df7f..614bf2febbc8 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -33,6 +33,7 @@ #include "wlan_objmgr_psoc_obj.h" #include "wlan_objmgr_pdev_obj.h" #include "wlan_objmgr_vdev_obj.h" +#include "wlan_objmgr_peer_obj.h" #include "wlan_utility.h" /* NLA policy */ @@ -188,10 +189,20 @@ static int os_if_nan_process_ndi_create(struct wlan_objmgr_psoc *psoc, return ret; } - return cb_obj.ndi_start(iface_name, transaction_id); } +static void os_if_nan_vdev_delete_peer(struct wlan_objmgr_psoc *psoc, + void *peer, void *nan_vdev) +{ + /* if peer belongs to nan vdev */ + if (nan_vdev == wlan_peer_get_vdev(peer)) { + cfg80211_debug("deleting peer: %pM", + wlan_peer_get_macaddr(peer)); + wlan_objmgr_peer_obj_delete(peer); + } +} + static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, struct nlattr **tb) { @@ -225,6 +236,12 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, nla_get_u16(tb[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); vdev_id = wlan_vdev_get_id(nan_vdev); num_peers = ucfg_nan_get_active_peers(nan_vdev); + + /* delete all peer for this interface first */ + wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, + os_if_nan_vdev_delete_peer, + nan_vdev, 1, WLAN_UMAC_COMP_NAN); + /* * wlan_util_get_vdev_by_ifname increments ref count * decrement here since vdev returned by that api is not used any more From a4a7894195aa8cd8ba71b241e696dc439022a2b1 Mon Sep 17 00:00:00 2001 From: Jianmin Zhu Date: Fri, 29 Jun 2018 11:42:13 +0800 Subject: [PATCH 74/92] qcacmn: Fix compile implicit conversion from enumeration type error Error: implicit conversion from enumeration type 'enum wlan_umac_comp_id' to different enumeration type 'wlan_objmgr_ref_dbgid' [-Werror,-Wenum-conversion] Change-Id: I641c1eee77e977547841cebb4fd2fef8c06ca18c CRs-Fixed: 2271058 --- core/src/nan_api.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/nan_api.c b/core/src/nan_api.c index 8dd6ff9130ca..f35a7f18ba43 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -112,11 +112,11 @@ static QDF_STATUS nan_psoc_obj_destroyed_notification( wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, nan_psoc_delete_peer, - NULL, 1, WLAN_UMAC_COMP_NAN); + NULL, 1, WLAN_NAN_ID); wlan_objmgr_iterate_obj_list(psoc, WLAN_VDEV_OP, nan_psoc_delete_vdev, - NULL, 1, WLAN_UMAC_COMP_NAN); + NULL, 1, WLAN_NAN_ID); status = wlan_objmgr_psoc_component_obj_detach(psoc, WLAN_UMAC_COMP_NAN, nan_obj); From 803f628422de9cb6ae585e56e3b11091218155e6 Mon Sep 17 00:00:00 2001 From: Jianmin Zhu Date: Fri, 29 Jun 2018 11:42:13 +0800 Subject: [PATCH 75/92] qcacmn: Fix compile implicit conversion from enumeration type error Error: implicit conversion from enumeration type 'enum wlan_umac_comp_id' to different enumeration type 'wlan_objmgr_ref_dbgid' [-Werror,-Wenum-conversion] Change-Id: I641c1eee77e977547841cebb4fd2fef8c06ca18c CRs-Fixed: 2271058 --- src/os_if_nan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 614bf2febbc8..b55ec22fec38 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -240,7 +240,7 @@ static int os_if_nan_process_ndi_delete(struct wlan_objmgr_psoc *psoc, /* delete all peer for this interface first */ wlan_objmgr_iterate_obj_list(psoc, WLAN_PEER_OP, os_if_nan_vdev_delete_peer, - nan_vdev, 1, WLAN_UMAC_COMP_NAN); + nan_vdev, 1, WLAN_NAN_ID); /* * wlan_util_get_vdev_by_ifname increments ref count From 7a54fa2301c0a7ed58c7ab6d7a476ce0b535a209 Mon Sep 17 00:00:00 2001 From: Nirav Shah Date: Sat, 23 Jun 2018 14:43:23 +0530 Subject: [PATCH 76/92] qcacmn: Map all module logs to per-level log APIs Map all module level log APIs to per-level log APIs to compile out specific log level if required. Change-Id: I4072b6740cb43200fd95c40943b66e1d5f8f1847 CRs-Fixed: 2266719 --- core/src/nan_main_i.h | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index 7d2d770ce37c..be7ab2b611c5 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2012-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 @@ -33,23 +33,18 @@ struct wlan_objmgr_vdev; struct wlan_objmgr_psoc; struct scheduler_msg; -#define nan_log(level, args...) \ - QDF_TRACE(QDF_MODULE_ID_NAN, level, ## args) -#define nan_logfl(level, format, args...) \ - nan_log(level, FL(format), ## args) - -#define nan_alert(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_FATAL, format, ## args) -#define nan_err(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_ERROR, format, ## args) -#define nan_warn(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_WARN, format, ## args) -#define nan_notice(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_INFO, format, ## args) -#define nan_info(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_INFO_HIGH, format, ## args) -#define nan_debug(format, args...) \ - nan_logfl(QDF_TRACE_LEVEL_DEBUG, format, ## args) +#define nan_alert(params...) \ + QDF_TRACE_FATAL(QDF_MODULE_ID_NAN, params) +#define nan_err(params...) \ + QDF_TRACE_ERROR(QDF_MODULE_ID_NAN, params) +#define nan_warn(params...) \ + QDF_TRACE_WARN(QDF_MODULE_ID_NAN, params) +#define nan_notice(params...) \ + QDF_TRACE_INFO(QDF_MODULE_ID_NAN, params) +#define nan_info(params...) \ + QDF_TRACE_INFO(QDF_MODULE_ID_NAN, params) +#define nan_debug(params...) \ + QDF_TRACE_DEBUG(QDF_MODULE_ID_NAN, params) #ifndef MAX_PEERS #define MAX_PEERS 32 From 634d8e81113519b5939cc9cf0db29871f17f503a Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Tue, 24 Jul 2018 09:44:39 -0700 Subject: [PATCH 77/92] qcacmn: Remove session_id from nan_datapath_peer_ind (Step 1) Currently struct nan_datapath_peer_ind contains the following: uint8_t session_id; This is problematic since "session_id" is a legacy concept and should not be used in the converged project. Fortunately this field does not actually serve any purpose. But in order to cleanly remove it a 3-step approach is required. Step 1 (this change): Remove the logic from the converged NAN code which currently reads this field and logs the value. Step 2 (qcacld-3.0 Change I2819556d48a9dd901158aaa04d6bda9c36f33012): Remove the logic from the legacy NAN code which sets this field. Step 3 (qcacld Change Ibeb8007c96ae1a902bfd7dd99a42ba4a291a1dc6): Remove the session_id field from struct nan_datapath_peer_ind. Change-Id: If6cf48ccbfe87b23b275720df51c6cc26af9fa5e CRs-Fixed: 2284399 --- src/os_if_nan.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index b55ec22fec38..37f97272c240 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -1565,9 +1565,9 @@ static void os_if_new_peer_ind_handler(struct wlan_objmgr_vdev *vdev, return; } - cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d", - peer_ind->session_id, peer_ind->peer_mac_addr.bytes, - peer_ind->sta_id); + cfg80211_debug("vdev_id: %d, peer_mac: %pM, sta_id: %d", + vdev_id, peer_ind->peer_mac_addr.bytes, + peer_ind->sta_id); ret = cb_obj.new_peer_ind(vdev_id, peer_ind->sta_id, &peer_ind->peer_mac_addr, (active_peers == 0 ? true : false)); @@ -1607,9 +1607,9 @@ static void os_if_peer_departed_ind_handler(struct wlan_objmgr_vdev *vdev, cfg80211_err("Invalid new NDP peer params"); return; } - cfg80211_debug("session_id: %d, peer_mac: %pM, sta_id: %d", - peer_ind->session_id, peer_ind->peer_mac_addr.bytes, - peer_ind->sta_id); + cfg80211_debug("vdev_id: %d, peer_mac: %pM, sta_id: %d", + vdev_id, peer_ind->peer_mac_addr.bytes, + peer_ind->sta_id); active_peers--; ucfg_nan_set_active_peers(vdev, active_peers); cb_obj.peer_departed_ind(vdev_id, peer_ind->sta_id, From ade24f225494c9fd3b1ec251847e608be2ce5d88 Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Tue, 24 Jul 2018 10:07:17 -0700 Subject: [PATCH 78/92] qcacmn: Remove session_id from nan_datapath_peer_ind (Step 3) Currently struct nan_datapath_peer_ind contains the following: uint8_t session_id; This is problematic since "session_id" is a legacy concept and should not be used in the converged project. Fortunately this field does not actually serve any purpose. But in order to cleanly remove it a 3-step approach is required. Step 1 (qcacld Change If6cf48ccbfe87b23b275720df51c6cc26af9fa5e): Remove the logic from the converged NAN code which currently reads this field and logs the value. Step 2 (qcacld-3.0 Change I2819556d48a9dd901158aaa04d6bda9c36f33012): Remove the logic from the legacy NAN code which sets this field. Step 3 (this change): Remove the session_id field from struct nan_datapath_peer_ind. Change-Id: Ibeb8007c96ae1a902bfd7dd99a42ba4a291a1dc6 CRs-Fixed: 2284401 --- core/inc/nan_public_structs.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/inc/nan_public_structs.h b/core/inc/nan_public_structs.h index 615b124ee9ff..7f65d9ee33e9 100644 --- a/core/inc/nan_public_structs.h +++ b/core/inc/nan_public_structs.h @@ -579,13 +579,11 @@ struct nan_datapath_indication_event { /** * struct nan_datapath_peer_ind - ndp peer indication - * @session_id: session id * @peer_mac_addr: peer mac address * @sta_id: station id * */ struct nan_datapath_peer_ind { - uint8_t session_id; struct qdf_mac_addr peer_mac_addr; uint16_t sta_id; }; From 3df2270588b9d6fede8115e499bdee21c9b09440 Mon Sep 17 00:00:00 2001 From: Manikandan Mohan Date: Thu, 2 Aug 2018 18:04:16 -0700 Subject: [PATCH 79/92] qcacmn: Add support for converged NAN config params Update NAN module to support INI configuration params based on converged CFG component. Change-Id: I2253daf8cbbce6d2afa28c5834179f21c2b76660 CRs-fixed: 2290357 --- core/src/nan_api.c | 54 ++++++++++++++ core/src/nan_main_i.h | 19 +++++ dispatcher/inc/cfg_nan.h | 138 +++++++++++++++++++++++++++++++++++ dispatcher/inc/cfg_nan_api.h | 88 ++++++++++++++++++++++ dispatcher/src/cfg_nan.c | 80 ++++++++++++++++++++ 5 files changed, 379 insertions(+) create mode 100644 dispatcher/inc/cfg_nan.h create mode 100644 dispatcher/inc/cfg_nan_api.h create mode 100644 dispatcher/src/cfg_nan.c diff --git a/core/src/nan_api.c b/core/src/nan_api.c index f35a7f18ba43..d23b3e548232 100644 --- a/core/src/nan_api.c +++ b/core/src/nan_api.c @@ -29,6 +29,57 @@ #include "wlan_objmgr_psoc_obj.h" #include "wlan_objmgr_pdev_obj.h" #include "wlan_objmgr_vdev_obj.h" +#include "cfg_nan.h" +#include "cfg_ucfg_api.h" + +/** + * nan_cfg_init() - Initialize NAN config params + * @psoc: Pointer to PSOC Object + * @nan_obj: Pointer to NAN private object + * + * This function initialize NAN config params + */ +#ifdef WLAN_FEATURE_NAN +static void nan_cfg_init(struct wlan_objmgr_psoc *psoc, + struct nan_psoc_priv_obj *nan_obj) +{ + if (!psoc || !nan_obj) + return; + + nan_obj->cfg_param.enable = cfg_get(psoc, CFG_NAN_ENABLE); +} +#else +static void nan_cfg_init(struct wlan_objmgr_psoc *psoc, + struct nan_psoc_priv_obj *nan_obj) +{ +} +#endif + +/** + * nan_cfg_dp_init() - Initialize NAN Datapath config params + * @psoc: Pointer to PSOC Object + * @nan_obj: Pointer to NAN private object + * + * This function initialize NAN config params + */ +#ifdef WLAN_FEATURE_NAN_DATAPATH +static void nan_cfg_dp_init(struct wlan_objmgr_psoc *psoc, + struct nan_psoc_priv_obj *nan_obj) +{ + if (!psoc || !nan_obj) + return; + nan_obj->cfg_param.dp_enable = cfg_get(psoc, + CFG_NAN_DATAPATH_ENABLE); + nan_obj->cfg_param.ndi_ch = cfg_get(psoc, CFG_NAN_NDI_CHANNEL); + nan_obj->cfg_param.ndi_mac_randomize = + cfg_get(psoc, CFG_NAN_RANDOMIZE_NDI_MAC); +} +#else +static void nan_cfg_dp_init(struct wlan_objmgr_psoc *psoc, + struct nan_psoc_priv_obj *nan_obj) +{ +} +#endif static QDF_STATUS nan_psoc_obj_created_notification( struct wlan_objmgr_psoc *psoc, void *arg_list) @@ -52,6 +103,9 @@ static QDF_STATUS nan_psoc_obj_created_notification( goto nan_psoc_notif_failed; } + nan_cfg_init(psoc, nan_obj); + nan_cfg_dp_init(psoc, nan_obj); + return QDF_STATUS_SUCCESS; nan_psoc_notif_failed: diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index be7ab2b611c5..235bf397a9e9 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -50,6 +50,24 @@ struct scheduler_msg; #define MAX_PEERS 32 #endif +/** + * struct nan_cfg_params - NAN INI config params + * @enable: NAN feature enable + * @dp_enable: NAN Datapath feature enable + * @ndi_ch: NAN Datapath channel + * @ndi_mac_randomize: Randomize NAN datapath interface MAC + */ +struct nan_cfg_params { +#ifdef WLAN_FEATURE_NAN + bool enable; +#endif +#ifdef WLAN_FEATURE_NAN_DATAPATH + bool dp_enable; + uint32_t ndi_ch; + bool ndi_mac_randomize; +#endif +}; + /** * struct nan_psoc_priv_obj - nan private psoc obj * @lock: lock to be acquired before reading or writing to object @@ -58,6 +76,7 @@ struct scheduler_msg; struct nan_psoc_priv_obj { qdf_spinlock_t lock; struct nan_callbacks cb_obj; + struct nan_cfg_params cfg_param; }; /** diff --git a/dispatcher/inc/cfg_nan.h b/dispatcher/inc/cfg_nan.h new file mode 100644 index 000000000000..394ff20d4d90 --- /dev/null +++ b/dispatcher/inc/cfg_nan.h @@ -0,0 +1,138 @@ +/* + * Copyright (c) 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 + * 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. + */ + +#if !defined(__NAN_CFG_H__) +#define __NAN_CFG_H__ + +/** + * + * DOC: nan_cfg.h + * + * NAN feature INI configuration parameter definitions + */ +#include "cfg_define.h" +#include "cfg_converged.h" +#include "qdf_types.h" + +/* + * + * gEnableNanSupport - NAN feature support configuration + * @Min: 0 + * @Max: 1 + * @Default: 0 + * + * When set to 1 NAN feature will be enabled. + * + * Related: None + * + * Supported Feature: NAN + * + * Usage: External + * + * + */ +#define CFG_NAN_ENABLE CFG_INI_BOOL("gEnableNanSupport", \ + 0, \ + "Enable NAN Support") +/* + * + * genable_nan_datapath - Enable NaN data path feature. NaN data path + * enables NAN supported devices to exchange + * data over TCP/UDP network stack. + * @Min: 0 + * @Max: 1 + * @Default: 0 + * + * When set to 1 NAN Datapath feature will be enabled. + * + * Related: gEnableNanSupport + * + * Supported Feature: NAN + * + * Usage: External + * + * + */ +#define CFG_NAN_DATAPATH_ENABLE CFG_INI_BOOL("genable_nan_datapath", \ + 0, \ + "Enable NAN Datapath support") + +/* + * + * gnan_datapath_ndi_channel - Default channel for NAN Datapath + * @Min: 6 + * @Max: 149 + * @Default: 6 + * + * Host suggests this channel for NAN datapath. But FW is free to + * choose other channels based on system constraints. + * + * Related: genable_nan_datapath + * + * Supported Feature: NAN + * + * Usage: External + * + * + */ +/* + * NAN channel on which NAN data interface to start + */ +#define CFG_NAN_NDI_CHANNEL CFG_INI_UINT("gnan_datapath_ndi_channel", \ + 6, 149, 6, \ + CFG_VALUE_OR_DEFAULT, \ + "NAN Datapath Channel") +/* + * + * gEnableNDIMacRandomization - When enabled this will randomize NDI Mac + * @Min: 0 + * @Max: 1 + * @Default: 1 + * + * When enabled this will randomize NDI Mac + * + * Related: gEnableNanSupport + * + * Supported Feature: NAN + * + * Usage: External + * + * + */ +#define CFG_NAN_RANDOMIZE_NDI_MAC CFG_INI_BOOL("gEnableNDIMacRandomization", \ + 1, \ + "Enable NAN MAC Randomization") + +#ifdef WLAN_FEATURE_NAN +#define CFG_NAN_DISC CFG(CFG_NAN_ENABLE) +#else +#define CFG_NAN_DISC +#endif + +#ifdef WLAN_FEATURE_NAN_DATAPATH +#define CFG_NAN_DP CFG(CFG_NAN_DATAPATH_ENABLE) \ + CFG(CFG_NAN_NDI_CHANNEL) \ + CFG(CFG_NAN_RANDOMIZE_NDI_MAC) +#else +#define CFG_NAN_DP +#endif + +#define CFG_NAN_ALL CFG_NAN_DISC \ + CFG_NAN_DP + +#endif diff --git a/dispatcher/inc/cfg_nan_api.h b/dispatcher/inc/cfg_nan_api.h new file mode 100644 index 000000000000..c37821c97357 --- /dev/null +++ b/dispatcher/inc/cfg_nan_api.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 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 + * 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. + */ + +#if !defined(__NAN_CFG_API_H__) +#define __NAN_CFG_API_H__ + +/** + * + * DOC: nan_cfg_api.h + * + * NAN feature INI configuration parameters get/set APIs + */ +#include "qdf_types.h" + +struct wlan_objmgr_psoc; + +#ifdef WLAN_FEATURE_NAN +/** + * cfg_nan_get_enable() - get NAN support enable status + * @psoc: pointer to psoc object + * + * This function returns NAN enable status + */ +bool cfg_nan_get_enable(struct wlan_objmgr_psoc *psoc); +#else +static inline bool cfg_nan_get_enable(struct wlan_objmgr_psoc *psoc) +{ + return false; +} +#endif + +#ifdef WLAN_FEATURE_NAN_DATAPATH +/** + * cfg_nan_get_datapath_enable() - get NAN Datapath support enable status + * @psoc: pointer to psoc object + * + * This function returns NAN Datapath enable status + */ +bool cfg_nan_get_datapath_enable(struct wlan_objmgr_psoc *psoc); + +/** + * cfg_nan_get_ndi_channel() - get NAN Datapath channel + * @psoc: pointer to psoc object + * + * This function returns NAN Datapath channel + */ +uint32_t cfg_nan_get_ndi_channel(struct wlan_objmgr_psoc *psoc); + +/** + * cfg_nan_get_ndi_mac_randomize() - get NDI MAC randomize enable status + * @psoc: pointer to psoc object + * + * This function returns NAN Datapath Interface MAC randomization status + */ +bool cfg_nan_get_ndi_mac_randomize(struct wlan_objmgr_psoc *psoc); +#else +static inline bool cfg_nan_get_datapath_enable(struct wlan_objmgr_psoc *psoc) +{ + return false; +} + +static inline uint32_t cfg_nan_get_ndi_channel(struct wlan_objmgr_psoc *psoc) +{ + return 0; +} + +static inline bool cfg_nan_get_ndi_mac_randomize(struct wlan_objmgr_psoc *psoc) +{ + return false; +} +#endif +#endif + diff --git a/dispatcher/src/cfg_nan.c b/dispatcher/src/cfg_nan.c new file mode 100644 index 000000000000..5b852da1f947 --- /dev/null +++ b/dispatcher/src/cfg_nan.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 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 + * 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 INI configurations + */ + +#include "wlan_objmgr_psoc_obj.h" +#include "cfg_nan_api.h" +#include "../../core/src/nan_main_i.h" + +static inline struct nan_psoc_priv_obj + *cfg_nan_get_priv_obj(struct wlan_objmgr_psoc *psoc) +{ + if (!psoc) { + nan_err("PSOC obj null"); + return NULL; + } + return wlan_objmgr_psoc_get_comp_private_obj(psoc, WLAN_UMAC_COMP_NAN); +} + +bool cfg_nan_get_enable(struct wlan_objmgr_psoc *psoc) +{ + struct nan_psoc_priv_obj *nan_obj = cfg_nan_get_priv_obj(psoc); + + if (!nan_obj) { + nan_err("NAN obj null"); + return false; + } + return nan_obj->cfg_param.enable; +} + +bool cfg_nan_get_datapath_enable(struct wlan_objmgr_psoc *psoc) +{ + struct nan_psoc_priv_obj *nan_obj = cfg_nan_get_priv_obj(psoc); + + if (!nan_obj) { + nan_err("NAN obj null"); + return false; + } + return nan_obj->cfg_param.dp_enable; +} + +uint32_t cfg_nan_get_ndi_channel(struct wlan_objmgr_psoc *psoc) +{ + struct nan_psoc_priv_obj *nan_obj = cfg_nan_get_priv_obj(psoc); + + if (!nan_obj) { + nan_err("NAN obj null"); + return 0; + } + return nan_obj->cfg_param.ndi_ch; +} + +bool cfg_nan_get_ndi_mac_randomize(struct wlan_objmgr_psoc *psoc) +{ + struct nan_psoc_priv_obj *nan_obj = cfg_nan_get_priv_obj(psoc); + + if (!nan_obj) { + nan_err("NAN obj null"); + return false; + } + return nan_obj->cfg_param.ndi_mac_randomize; +} + From f92db6b335410c70a6987bb9ab0ab092267251b9 Mon Sep 17 00:00:00 2001 From: Nirav Shah Date: Tue, 24 Jul 2018 16:33:11 +0530 Subject: [PATCH 80/92] qcacmn: umac: Add logging macros without function/line info Add per module logging macros without function/line info to avoid adding function/line info where it is not required. Change-Id: I34ba6f6485f9b506264daf4e116052d2858bed40 CRs-Fixed: 2278876 --- core/src/nan_main_i.h | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/core/src/nan_main_i.h b/core/src/nan_main_i.h index 235bf397a9e9..07f1619951ed 100644 --- a/core/src/nan_main_i.h +++ b/core/src/nan_main_i.h @@ -46,6 +46,17 @@ struct scheduler_msg; #define nan_debug(params...) \ QDF_TRACE_DEBUG(QDF_MODULE_ID_NAN, params) +#define nan_nofl_alert(params...) \ + QDF_TRACE_FATAL_NO_FL(QDF_MODULE_ID_NAN, params) +#define nan_nofl_err(params...) \ + QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_NAN, params) +#define nan_nofl_warn(params...) \ + QDF_TRACE_WARN_NO_FL(QDF_MODULE_ID_NAN, params) +#define nan_nofl_info(params...) \ + QDF_TRACE_INFO_NO_FL(QDF_MODULE_ID_NAN, params) +#define nan_nofl_debug(params...) \ + QDF_TRACE_DEBUG_NO_FL(QDF_MODULE_ID_NAN, params) + #ifndef MAX_PEERS #define MAX_PEERS 32 #endif From cd67bb136dd206cedbf7d194d3ec6e11378986d9 Mon Sep 17 00:00:00 2001 From: gaurank kathpalia Date: Tue, 28 Aug 2018 19:34:37 +0530 Subject: [PATCH 81/92] qcacmn: Add src, and dst id support in UCFG/HDD 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: I37532d323a0945b522087a23a65396ba2899fb5b CRs-Fixed: 2306011 --- dispatcher/src/nan_ucfg_api.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 8482c4390d14..78dca19ce228 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -337,7 +337,9 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, qdf_mem_copy(msg.bodyptr, in_req, len); msg.type = req_type; msg.callback = nan_scheduled_msg_handler; - status = scheduler_post_msg(QDF_MODULE_ID_OS_IF, &msg); + status = scheduler_post_message(QDF_MODULE_ID_HDD, + QDF_MODULE_ID_NAN, + QDF_MODULE_ID_OS_IF, &msg); if (QDF_IS_STATUS_ERROR(status)) { nan_err("failed to post msg to NAN component, status: %d", status); From 52d4acd828ed514d9aee2e56d25ebcc3eb968ead Mon Sep 17 00:00:00 2001 From: gaurank kathpalia Date: Tue, 28 Aug 2018 20:03:29 +0530 Subject: [PATCH 82/92] 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 da883b342294..4d5ca4104215 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 236146d16fb0ab35c41c379c0b9cac853136a018 Mon Sep 17 00:00:00 2001 From: Jianmin Zhu Date: Thu, 30 Aug 2018 13:23:30 +0800 Subject: [PATCH 83/92] qcacmn: MCL part change after serialization enhancement 1. Keep serialization legacy api not broken. Serialization enhancement have much changes on internal struct and API, need re-implement serialization legacy APIs. 2. Set all cmds on MCL platform as blocking type. MCL dones't support cmd concurrency on multi vdevs, while WIN need it. Change-Id: I5d5d6e0e16becb0b0f285fd8ed20982f2819659c CRs-Fixed: 2315407 --- core/src/nan_main.c | 1 + 1 file changed, 1 insertion(+) diff --git a/core/src/nan_main.c b/core/src/nan_main.c index 6cbe0288f0dd..8d1d78a8e757 100644 --- a/core/src/nan_main.c +++ b/core/src/nan_main.c @@ -226,6 +226,7 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) cmd.is_high_priority = false; cmd.cmd_timeout_duration = 30000 /* 30 sec for now. TBD */; nan_debug("cmd_type: %d", cmd.cmd_type); + cmd.is_blocking = true; status = wlan_serialization_request(&cmd); /* following is TBD */ From 1d96b30a990115d3ca7acb4057e29e6548eca4b1 Mon Sep 17 00:00:00 2001 From: Jingxiang Ge Date: Fri, 21 Sep 2018 15:46:20 +0800 Subject: [PATCH 84/92] 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 4d5ca4104215..0cf64e449e34 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 85/92] 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 0cf64e449e34..99d707cb01c8 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 1c9262fb9869a272d60e40bf5b326fc79b0aec49 Mon Sep 17 00:00:00 2001 From: Yeshwanth Sriram Guntuka Date: Thu, 20 Sep 2018 16:59:00 +0530 Subject: [PATCH 86/92] 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/os_if_nan.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 37f97272c240..0dd33424d19b 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -1496,17 +1496,19 @@ static void os_if_ndp_end_ind_handler(struct wlan_objmgr_vdev *vdev, continue; } - idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev), + idx = cb_obj.get_peer_idx(wlan_vdev_get_id(vdev_itr), &end_ind->ndp_map[i].peer_ndi_mac_addr); if (idx < 0) { cfg80211_err("can't find addr: %pM in sta_ctx.", &end_ind->ndp_map[i].peer_ndi_mac_addr); + wlan_objmgr_vdev_release_ref(vdev_itr, WLAN_NAN_ID); continue; } /* save the value of active sessions on each peer */ - ucfg_nan_set_active_ndp_sessions(vdev, + ucfg_nan_set_active_ndp_sessions(vdev_itr, end_ind->ndp_map[i].num_active_ndp_sessions, idx); + wlan_objmgr_vdev_release_ref(vdev_itr, WLAN_NAN_ID); } data_len = osif_ndp_get_ndp_end_ind_len(end_ind); From 71fb6bc49d8309a42e06b675322bef0a2ae4d007 Mon Sep 17 00:00:00 2001 From: Yeshwanth Sriram Guntuka Date: Thu, 20 Sep 2018 16:59:00 +0530 Subject: [PATCH 87/92] 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 99d707cb01c8..abb5eec245a9 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 0bfde711e4e71dab8cc05ed5a3d315f19c0e0c9a Mon Sep 17 00:00:00 2001 From: Yeshwanth Sriram Guntuka Date: Thu, 4 Oct 2018 12:42:17 +0530 Subject: [PATCH 88/92] qcacmn: Fix incorrect NDP ids in NDP end request NDP ids copied from NDP instance id array for NDP end request does not use nla_data to copy the ids resulting in incorrect data getting copied. Fix is to use nla_data for NDP instance id array to copy the ids. Change-Id: I74795367a5c5a57f42cb1a67ece9cebfeb259b71 CRs-Fixed: 2328245 --- src/os_if_nan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/os_if_nan.c b/src/os_if_nan.c index 0dd33424d19b..9b444111e5c3 100644 --- a/src/os_if_nan.c +++ b/src/os_if_nan.c @@ -672,7 +672,7 @@ static int os_if_nan_process_ndp_end_req(struct wlan_objmgr_psoc *psoc, return -EINVAL; } qdf_mem_copy(req.ndp_ids, - tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY], + nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID_ARRAY]), req.num_ndp_instances * sizeof(uint32_t)); cfg80211_debug("sending ndp_end_req to SME, transaction_id: %d", From 0820ac29eb1dc9f3c1bee0b8ac3f1d90e8d52e50 Mon Sep 17 00:00:00 2001 From: Manikandan Mohan Date: Tue, 30 Oct 2018 12:37:04 -0700 Subject: [PATCH 89/92] qcacmn: Fix mem leaks in nan msg posting to scheduler Fix possible mem leaks in NAN module when msg posting to scheduler fails. Also setup schduler flush callback for NAN module to purge messages during driver unload. Change-Id: I8d034d9bc9a58af95f2c4330a6fc7423885bdae6 CRs-fixed: 2341213 --- dispatcher/src/nan_ucfg_api.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/dispatcher/src/nan_ucfg_api.c b/dispatcher/src/nan_ucfg_api.c index 78dca19ce228..b196ae30bfba 100644 --- a/dispatcher/src/nan_ucfg_api.c +++ b/dispatcher/src/nan_ucfg_api.c @@ -302,6 +302,38 @@ inline QDF_STATUS ucfg_nan_get_callbacks(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_SUCCESS; } +static QDF_STATUS ucfg_nan_sch_msg_flush_cb(struct scheduler_msg *msg) +{ + struct wlan_objmgr_vdev *vdev = NULL; + + if (!msg || !msg->bodyptr) + return QDF_STATUS_E_NULL_VALUE; + + switch (msg->type) { + case NDP_INITIATOR_REQ: + vdev = ((struct nan_datapath_initiator_req *) + msg->bodyptr)->vdev; + break; + case NDP_RESPONDER_REQ: + vdev = ((struct nan_datapath_responder_req *) + msg->bodyptr)->vdev; + break; + case NDP_END_REQ: + vdev = ((struct nan_datapath_end_req *)msg->bodyptr)->vdev; + break; + default: + nan_err("Invalid NAN msg type during sch flush"); + return QDF_STATUS_E_INVAL; + } + + if (vdev) { + wlan_objmgr_vdev_release_ref(vdev, WLAN_NAN_ID); + qdf_mem_free(msg->bodyptr); + } + + return QDF_STATUS_SUCCESS; +} + QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, void *in_req, uint32_t req_type) { @@ -337,12 +369,14 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev, qdf_mem_copy(msg.bodyptr, in_req, len); msg.type = req_type; msg.callback = nan_scheduled_msg_handler; + msg.flush_callback = ucfg_nan_sch_msg_flush_cb; status = scheduler_post_message(QDF_MODULE_ID_HDD, QDF_MODULE_ID_NAN, QDF_MODULE_ID_OS_IF, &msg); if (QDF_IS_STATUS_ERROR(status)) { nan_err("failed to post msg to NAN component, status: %d", status); + qdf_mem_free(msg.bodyptr); } return status; 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 90/92] 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 2563efae7d0e..45109e3869f3 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 From bc04268a27cc0d58ecad0c75e6f2e983a8aadbf1 Mon Sep 17 00:00:00 2001 From: Linux Build Service Account Date: Tue, 13 Nov 2018 16:07:49 +0530 Subject: [PATCH 91/92] qcacld-3.0: Merge NAN related OS IF files into CLD NAN component is not needed in the CMN repo. To reduce the unnecessary lines of code, merge the NAN related OS IF files from CMN into CLD. Subsequently remove these files from the CMN repo. Merge NAN related OS IF files from CMN into CLD. Change-Id: Iba5c367549f135800c6f36a7066829393d62e92b --- {inc => os_if/nan/inc}/os_if_nan.h | 0 {src => os_if/nan/src}/os_if_nan.c | 67 +++++++++++++++++------------- 2 files changed, 37 insertions(+), 30 deletions(-) rename {inc => os_if/nan/inc}/os_if_nan.h (100%) rename {src => os_if/nan/src}/os_if_nan.c (97%) diff --git a/inc/os_if_nan.h b/os_if/nan/inc/os_if_nan.h similarity index 100% rename from inc/os_if_nan.h rename to os_if/nan/inc/os_if_nan.h diff --git a/src/os_if_nan.c b/os_if/nan/src/os_if_nan.c similarity index 97% rename from src/os_if_nan.c rename to os_if/nan/src/os_if_nan.c index 9b444111e5c3..6f98e93dd2b2 100644 --- a/src/os_if_nan.c +++ b/os_if/nan/src/os_if_nan.c @@ -306,20 +306,22 @@ static int os_if_nan_parse_security_params(struct nlattr **tb, passphrase->passphrase_len); cfg80211_err("passphrase len: %d", passphrase->passphrase_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, - passphrase->passphrase, passphrase->passphrase_len); + passphrase->passphrase, + passphrase->passphrase_len); } if (tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]) { service_name->service_name_len = nla_len(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]); qdf_mem_copy(service_name->service_name, - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]), - service_name->service_name_len); + nla_data( + tb[QCA_WLAN_VENDOR_ATTR_NDP_SERVICE_NAME]), + service_name->service_name_len); cfg80211_err("service_name len: %d", service_name->service_name_len); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_ERROR, - service_name->service_name, - service_name->service_name_len); + service_name->service_name, + service_name->service_name_len); } return 0; @@ -379,7 +381,7 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, state == NAN_DATA_NDI_DELETING_STATE || state == NAN_DATA_NDI_CREATING_STATE) { cfg80211_err("Data request not allowed in NDI current state: %d", - state); + state); ret = -EINVAL; goto initiator_req_failed; } @@ -422,8 +424,9 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, goto initiator_req_failed; } qdf_mem_copy(req.peer_discovery_mac_addr.bytes, - nla_data(tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]), - QDF_MAC_ADDR_SIZE); + nla_data( + tb[QCA_WLAN_VENDOR_ATTR_NDP_PEER_DISCOVERY_MAC_ADDR]), + QDF_MAC_ADDR_SIZE); if (tb[QCA_WLAN_VENDOR_ATTR_NDP_APP_INFO]) { req.ndp_info.ndp_app_info_len = @@ -450,16 +453,18 @@ static int os_if_nan_process_ndp_initiator_req(struct wlan_objmgr_psoc *psoc, req.is_ipv6_addr_present, req.ipv6_addr); if (os_if_nan_parse_security_params(tb, &req.ncs_sk_type, &req.pmk, - &req.passphrase, &req.service_name)) { + &req.passphrase, + &req.service_name)) { cfg80211_err("inconsistent security params in request."); ret = -EINVAL; goto initiator_req_failed; } cfg80211_debug("vdev_id: %d, transaction_id: %d, channel: %d, service_instance_id: %d, ndp_app_info_len: %d, csid: %d, peer_discovery_mac_addr: %pM", - wlan_vdev_get_id(nan_vdev), req.transaction_id, req.channel, - req.service_instance_id, req.ndp_info.ndp_app_info_len, - req.ncs_sk_type, req.peer_discovery_mac_addr.bytes); + wlan_vdev_get_id(nan_vdev), req.transaction_id, + req.channel, req.service_instance_id, + req.ndp_info.ndp_app_info_len, req.ncs_sk_type, + req.peer_discovery_mac_addr.bytes); req.vdev = nan_vdev; status = ucfg_nan_req_processor(nan_vdev, &req, NDP_INITIATOR_REQ); @@ -1728,15 +1733,17 @@ static void os_if_ndp_iface_create_rsp_handler(struct wlan_objmgr_psoc *psoc, } cfg80211_debug("sub command: %d, value: %d", - QCA_NL80211_VENDOR_SUBCMD_NDP, - QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE); + QCA_NL80211_VENDOR_SUBCMD_NDP, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_CREATE); cfg80211_debug("create transaction id: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, create_transaction_id); + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + create_transaction_id); cfg80211_debug("status code: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, - create_status); + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + create_status); cfg80211_debug("Return value: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, create_reason); + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + create_reason); cfg80211_vendor_event(vendor_event, GFP_KERNEL); @@ -1790,7 +1797,7 @@ static void os_if_ndp_iface_delete_rsp_handler(struct wlan_objmgr_psoc *psoc, cfg80211_debug("NDI BSS successfully stopped"); else cfg80211_debug("NDI BSS stop failed with reason %d", - ndi_rsp->reason); + ndi_rsp->reason); ucfg_nan_set_ndi_delete_rsp_reason(vdev, ndi_rsp->reason); ucfg_nan_set_ndi_delete_rsp_status(vdev, ndi_rsp->status); @@ -1845,9 +1852,9 @@ static QDF_STATUS os_if_ndp_sch_update_pack_ch_info(struct sk_buff *event, for (idx = 0; idx < sch_update->num_channels; idx++) { cfg80211_debug("ch[%d]: freq: %d, width: %d, nss: %d", - idx, sch_update->ch[idx].channel, - sch_update->ch[idx].ch_width, - sch_update->ch[idx].nss); + idx, sch_update->ch[idx].channel, + sch_update->ch[idx].ch_width, + sch_update->ch[idx].nss); ch_element = nla_nest_start(event, idx); if (!ch_element) return QDF_STATUS_E_FAULT; @@ -2141,17 +2148,17 @@ void os_if_nan_ndi_session_end(struct wlan_objmgr_vdev *vdev) } cfg80211_debug("sub command: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, - QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE); + QCA_WLAN_VENDOR_ATTR_NDP_SUBCMD, + QCA_WLAN_VENDOR_ATTR_NDP_INTERFACE_DELETE); cfg80211_debug("delete transaction id: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, - ucfg_nan_get_ndp_delete_transaction_id(vdev)); + QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID, + ucfg_nan_get_ndp_delete_transaction_id(vdev)); cfg80211_debug("status code: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, - ucfg_nan_get_ndi_delete_rsp_status(vdev)); + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE, + ucfg_nan_get_ndi_delete_rsp_status(vdev)); cfg80211_debug("Return value: %d, value: %d", - QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, - ucfg_nan_get_ndi_delete_rsp_reason(vdev)); + QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE, + ucfg_nan_get_ndi_delete_rsp_reason(vdev)); ucfg_nan_set_ndp_delete_transaction_id(vdev, 0); ucfg_nan_set_ndi_state(vdev, NAN_DATA_NDI_DELETED_STATE); From 4e044cf9f51de30693f22705651c52941d6e799e Mon Sep 17 00:00:00 2001 From: Linux Build Service Account Date: Tue, 13 Nov 2018 16:39:50 +0530 Subject: [PATCH 92/92] qcacld-3.0: Merge NAN component files from CMN into CLD NAN component is not needed in the CMN repo. To reduce the unnecessary lines of code, merge the NAN component files from CMN into CLD with updated copyrights. Subsequently remove these files from the CMN repo. Merge NAN component files from CMN into CLD. Change-Id: I63c2fb90ea517496946ea45a66bdf290af9d5a7c --- .../nan/core}/inc/nan_public_structs.h | 10 ++++----- .../nan/core}/inc/wlan_nan_api.h | 2 +- {core => components/nan/core}/src/nan_api.c | 20 ++++++++--------- {core => components/nan/core}/src/nan_main.c | 19 +++++++++++----- .../nan/core}/src/nan_main_i.h | 0 .../nan/dispatcher}/inc/cfg_nan.h | 0 .../nan/dispatcher}/inc/cfg_nan_api.h | 0 .../nan/dispatcher}/inc/nan_ucfg_api.h | 12 +++++----- .../nan/dispatcher}/src/cfg_nan.c | 0 .../nan/dispatcher}/src/nan_ucfg_api.c | 0 core/src/nan_utils.c | 22 ------------------- 11 files changed, 35 insertions(+), 50 deletions(-) rename {core => components/nan/core}/inc/nan_public_structs.h (99%) rename {core => components/nan/core}/inc/wlan_nan_api.h (95%) rename {core => components/nan/core}/src/nan_api.c (95%) rename {core => components/nan/core}/src/nan_main.c (97%) rename {core => components/nan/core}/src/nan_main_i.h (100%) rename {dispatcher => components/nan/dispatcher}/inc/cfg_nan.h (100%) rename {dispatcher => components/nan/dispatcher}/inc/cfg_nan_api.h (100%) rename {dispatcher => components/nan/dispatcher}/inc/nan_ucfg_api.h (96%) rename {dispatcher => components/nan/dispatcher}/src/cfg_nan.c (100%) rename {dispatcher => components/nan/dispatcher}/src/nan_ucfg_api.c (100%) delete mode 100644 core/src/nan_utils.c diff --git a/core/inc/nan_public_structs.h b/components/nan/core/inc/nan_public_structs.h similarity index 99% rename from core/inc/nan_public_structs.h rename to components/nan/core/inc/nan_public_structs.h index 7f65d9ee33e9..2a32ffd49dd1 100644 --- a/core/inc/nan_public_structs.h +++ b/components/nan/core/inc/nan_public_structs.h @@ -616,21 +616,19 @@ struct nan_datapath_sch_update_event { struct nan_callbacks { /* callback to os_if layer from umac */ void (*os_if_event_handler)(struct wlan_objmgr_psoc *psoc, - struct wlan_objmgr_vdev *vdev, - uint32_t type, void *msg); + struct wlan_objmgr_vdev *vdev, + uint32_t type, void *msg); int (*ndi_open)(char *iface_name); int (*ndi_start)(char *iface_name, uint16_t); void (*ndi_close)(uint8_t); int (*ndi_delete)(uint8_t, char *iface_name, uint16_t transaction_id); - void (*drv_ndi_create_rsp_handler)(uint8_t, - struct nan_datapath_inf_create_rsp *); + void (*drv_ndi_create_rsp_handler) + (uint8_t, struct nan_datapath_inf_create_rsp *); void (*drv_ndi_delete_rsp_handler)(uint8_t); - int (*new_peer_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, bool); int (*get_peer_idx)(uint8_t, struct qdf_mac_addr *); QDF_STATUS (*add_ndi_peer)(uint32_t, struct qdf_mac_addr); - void (*peer_departed_ind)(uint8_t, uint16_t, struct qdf_mac_addr *, bool); void (*ndp_delete_peers)(struct peer_nan_datapath_map*, uint8_t); diff --git a/core/inc/wlan_nan_api.h b/components/nan/core/inc/wlan_nan_api.h similarity index 95% rename from core/inc/wlan_nan_api.h rename to components/nan/core/inc/wlan_nan_api.h index 1498f23c37e1..e2bc40f3fcde 100644 --- a/core/inc/wlan_nan_api.h +++ b/components/nan/core/inc/wlan_nan_api.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/core/src/nan_api.c b/components/nan/core/src/nan_api.c similarity index 95% rename from core/src/nan_api.c rename to components/nan/core/src/nan_api.c index d23b3e548232..4e03a12dbf86 100644 --- a/core/src/nan_api.c +++ b/components/nan/core/src/nan_api.c @@ -95,9 +95,9 @@ static QDF_STATUS nan_psoc_obj_created_notification( } qdf_spinlock_create(&nan_obj->lock); - status = wlan_objmgr_psoc_component_obj_attach(psoc, - WLAN_UMAC_COMP_NAN, nan_obj, - QDF_STATUS_SUCCESS); + status = wlan_objmgr_psoc_component_obj_attach(psoc, WLAN_UMAC_COMP_NAN, + nan_obj, + QDF_STATUS_SUCCESS); if (QDF_IS_STATUS_ERROR(status)) { nan_alert("obj attach with psoc failed"); goto nan_psoc_notif_failed; @@ -172,8 +172,8 @@ static QDF_STATUS nan_psoc_obj_destroyed_notification( nan_psoc_delete_vdev, NULL, 1, WLAN_NAN_ID); - status = wlan_objmgr_psoc_component_obj_detach(psoc, - WLAN_UMAC_COMP_NAN, nan_obj); + status = wlan_objmgr_psoc_component_obj_detach(psoc, WLAN_UMAC_COMP_NAN, + nan_obj); if (QDF_IS_STATUS_ERROR(status)) nan_err("nan_obj detach failed"); @@ -203,9 +203,9 @@ static QDF_STATUS nan_vdev_obj_created_notification( } qdf_spinlock_create(&nan_obj->lock); - status = wlan_objmgr_vdev_component_obj_attach(vdev, - WLAN_UMAC_COMP_NAN, (void *)nan_obj, - QDF_STATUS_SUCCESS); + status = wlan_objmgr_vdev_component_obj_attach(vdev, WLAN_UMAC_COMP_NAN, + (void *)nan_obj, + QDF_STATUS_SUCCESS); if (QDF_IS_STATUS_ERROR(status)) { nan_alert("obj attach with vdev failed"); goto nan_vdev_notif_failed; @@ -238,8 +238,8 @@ static QDF_STATUS nan_vdev_obj_destroyed_notification( return QDF_STATUS_E_FAULT; } - status = wlan_objmgr_vdev_component_obj_detach(vdev, - WLAN_UMAC_COMP_NAN, nan_obj); + status = wlan_objmgr_vdev_component_obj_detach(vdev, WLAN_UMAC_COMP_NAN, + nan_obj); if (QDF_IS_STATUS_ERROR(status)) nan_err("nan_obj detach failed"); diff --git a/core/src/nan_main.c b/components/nan/core/src/nan_main.c similarity index 97% rename from core/src/nan_main.c rename to components/nan/core/src/nan_main.c index 8d1d78a8e757..eef744fd80f5 100644 --- a/core/src/nan_main.c +++ b/components/nan/core/src/nan_main.c @@ -70,16 +70,19 @@ void nan_release_cmd(void *in_req, uint32_t cmdtype) switch (cmdtype) { case WLAN_SER_CMD_NDP_INIT_REQ: { struct nan_datapath_initiator_req *req = in_req; + vdev = req->vdev; break; } case WLAN_SER_CMD_NDP_RESP_REQ: { struct nan_datapath_responder_req *req = in_req; + vdev = req->vdev; break; } case WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: { struct nan_datapath_end_req *req = in_req; + vdev = req->vdev; break; } @@ -111,18 +114,21 @@ static void nan_req_activated(void *in_req, uint32_t cmdtype) switch (cmdtype) { case WLAN_SER_CMD_NDP_INIT_REQ: { struct nan_datapath_initiator_req *req = in_req; + vdev = req->vdev; req_type = NDP_INITIATOR_REQ; break; } case WLAN_SER_CMD_NDP_RESP_REQ: { struct nan_datapath_responder_req *req = in_req; + vdev = req->vdev; req_type = NDP_RESPONDER_REQ; break; } case WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: { struct nan_datapath_end_req *req = in_req; + vdev = req->vdev; req_type = NDP_END_REQ; break; @@ -154,7 +160,7 @@ static void nan_req_activated(void *in_req, uint32_t cmdtype) } static QDF_STATUS nan_serialized_cb(void *cmd, - enum wlan_serialization_cb_reason reason) + enum wlan_serialization_cb_reason reason) { void *req; struct wlan_serialization_command *ser_cmd = cmd; @@ -197,18 +203,21 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg) switch (msg->type) { case NDP_INITIATOR_REQ: { struct nan_datapath_initiator_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_INIT_REQ; cmd.vdev = req->vdev; break; } case NDP_RESPONDER_REQ: { struct nan_datapath_responder_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_RESP_REQ; cmd.vdev = req->vdev; break; } case NDP_END_REQ: { struct nan_datapath_end_req *req = msg->bodyptr; + cmd.cmd_type = WLAN_SER_CMD_NDP_DATA_END_INIT_REQ; cmd.vdev = req->vdev; break; @@ -259,7 +268,7 @@ static QDF_STATUS nan_handle_confirm( } if (confirm->rsp_code != NAN_DATAPATH_RESPONSE_ACCEPT && - confirm->num_active_ndps_on_peer == 0) { + confirm->num_active_ndps_on_peer == 0) { /* * This peer was created at ndp_indication but * confirm failed, so it needs to be deleted @@ -329,8 +338,8 @@ static QDF_STATUS nan_handle_ndp_ind( QDF_MAC_ADDR_ARRAY(ndp_ind->peer_mac_addr.bytes)); if ((ndp_ind->role == NAN_DATAPATH_ROLE_INITIATOR) || - ((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) && - (NAN_DATAPATH_ACCEPT_POLICY_ALL == ndp_ind->policy))) { + ((NAN_DATAPATH_ROLE_RESPONDER == ndp_ind->role) && + (NAN_DATAPATH_ACCEPT_POLICY_ALL == ndp_ind->policy))) { status = psoc_nan_obj->cb_obj.add_ndi_peer(vdev_id, ndp_ind->peer_mac_addr); if (QDF_IS_STATUS_ERROR(status)) { @@ -367,7 +376,7 @@ static QDF_STATUS nan_handle_responder_rsp( return QDF_STATUS_E_NULL_VALUE; } - if (QDF_IS_STATUS_SUCCESS(rsp->status) && rsp->create_peer == true) { + if (QDF_IS_STATUS_SUCCESS(rsp->status) && rsp->create_peer) { status = psoc_nan_obj->cb_obj.add_ndi_peer( wlan_vdev_get_id(rsp->vdev), rsp->peer_mac_addr); diff --git a/core/src/nan_main_i.h b/components/nan/core/src/nan_main_i.h similarity index 100% rename from core/src/nan_main_i.h rename to components/nan/core/src/nan_main_i.h diff --git a/dispatcher/inc/cfg_nan.h b/components/nan/dispatcher/inc/cfg_nan.h similarity index 100% rename from dispatcher/inc/cfg_nan.h rename to components/nan/dispatcher/inc/cfg_nan.h diff --git a/dispatcher/inc/cfg_nan_api.h b/components/nan/dispatcher/inc/cfg_nan_api.h similarity index 100% rename from dispatcher/inc/cfg_nan_api.h rename to components/nan/dispatcher/inc/cfg_nan_api.h diff --git a/dispatcher/inc/nan_ucfg_api.h b/components/nan/dispatcher/inc/nan_ucfg_api.h similarity index 96% rename from dispatcher/inc/nan_ucfg_api.h rename to components/nan/dispatcher/inc/nan_ucfg_api.h index 2c24a483760c..4462eca50f5f 100644 --- a/dispatcher/inc/nan_ucfg_api.h +++ b/components/nan/dispatcher/inc/nan_ucfg_api.h @@ -208,12 +208,12 @@ void ucfg_nan_event_handler(struct wlan_objmgr_psoc *psoc, * * Return: status of operation */ -int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, - struct nan_callbacks *cb_obj, - void (os_if_event_handler)( - struct wlan_objmgr_psoc *, - struct wlan_objmgr_vdev *, - uint32_t, void *)); +int ucfg_nan_register_hdd_callbacks(struct wlan_objmgr_psoc *, + struct nan_callbacks *, + void (os_if_event_handler) + (struct wlan_objmgr_psoc *, + struct wlan_objmgr_vdev *, + uint32_t, void *)); /* * ucfg_nan_register_lim_callbacks: ucfg API to set lim callbacks diff --git a/dispatcher/src/cfg_nan.c b/components/nan/dispatcher/src/cfg_nan.c similarity index 100% rename from dispatcher/src/cfg_nan.c rename to components/nan/dispatcher/src/cfg_nan.c diff --git a/dispatcher/src/nan_ucfg_api.c b/components/nan/dispatcher/src/nan_ucfg_api.c similarity index 100% rename from dispatcher/src/nan_ucfg_api.c rename to components/nan/dispatcher/src/nan_ucfg_api.c diff --git a/core/src/nan_utils.c b/core/src/nan_utils.c deleted file mode 100644 index 69b8daf1875e..000000000000 --- a/core/src/nan_utils.c +++ /dev/null @@ -1,22 +0,0 @@ -/* - * 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 utility functions - */ -