Ravi Joshi | a063dd9 | 2016-05-25 16:43:13 -0700 | [diff] [blame] | 1 | /* |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 2 | * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. |
Ravi Joshi | a063dd9 | 2016-05-25 16:43:13 -0700 | [diff] [blame] | 3 | * |
Ravi Joshi | a063dd9 | 2016-05-25 16:43:13 -0700 | [diff] [blame] | 4 | * Permission to use, copy, modify, and/or distribute this software for |
| 5 | * any purpose with or without fee is hereby granted, provided that the |
| 6 | * above copyright notice and this permission notice appear in all |
| 7 | * copies. |
| 8 | * |
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| 10 | * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| 11 | * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| 12 | * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| 13 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| 14 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 15 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 16 | * PERFORMANCE OF THIS SOFTWARE. |
| 17 | */ |
| 18 | |
| 19 | /** |
| 20 | * DOC: wlan_hdd_nan_datapath.c |
| 21 | * |
| 22 | * WLAN Host Device Driver nan datapath API implementation |
| 23 | */ |
Deepak Dhamdhere | 13983f2 | 2016-05-31 19:06:09 -0700 | [diff] [blame] | 24 | #include <wlan_hdd_includes.h> |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 25 | #include <linux/if.h> |
| 26 | #include <linux/netdevice.h> |
| 27 | #include <linux/skbuff.h> |
| 28 | #include <linux/etherdevice.h> |
| 29 | #include "wlan_hdd_includes.h" |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 30 | #include "wlan_hdd_p2p.h" |
Dustin Brown | 6412d1f | 2019-02-05 14:52:29 -0800 | [diff] [blame] | 31 | #include "osif_sync.h" |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 32 | #include "wma_api.h" |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 33 | #include "wlan_hdd_assoc.h" |
| 34 | #include "sme_nan_datapath.h" |
Rajeev Kumar | 699debf | 2017-01-06 14:17:00 -0800 | [diff] [blame] | 35 | #include "wlan_hdd_object_manager.h" |
Sandeep Puligilla | fdd201e | 2017-02-02 18:43:46 -0800 | [diff] [blame] | 36 | #include <qca_vendor.h> |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 37 | #include "os_if_nan.h" |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 38 | #include "wlan_nan_api.h" |
| 39 | #include "nan_public_structs.h" |
Manikandan Mohan | dcd0fdf | 2018-08-02 18:13:37 -0700 | [diff] [blame] | 40 | #include "cfg_nan_api.h" |
Abhinav Kumar | b074f2f | 2018-09-15 15:32:11 +0530 | [diff] [blame] | 41 | #include "wlan_mlme_ucfg_api.h" |
Jeff Johnson | 51a8052 | 2018-12-11 20:19:44 -0800 | [diff] [blame] | 42 | #include "qdf_util.h" |
Sravan Kumar Kairam | 777a7dd | 2019-08-01 21:46:30 +0530 | [diff] [blame] | 43 | #include <cdp_txrx_misc.h> |
Qun Zhang | 1b3c85c | 2019-08-27 16:31:49 +0800 | [diff] [blame] | 44 | #include "wlan_fwol_ucfg_api.h" |
Deepak Dhamdhere | 13230d3 | 2016-05-26 00:46:53 -0700 | [diff] [blame] | 45 | |
| 46 | /** |
| 47 | * hdd_nan_datapath_target_config() - Configure NAN datapath features |
| 48 | * @hdd_ctx: Pointer to HDD context |
| 49 | * @cfg: Pointer to target device capability information |
| 50 | * |
Deepak Dhamdhere | 13983f2 | 2016-05-31 19:06:09 -0700 | [diff] [blame] | 51 | * NAN datapath functionality is enabled if it is enabled in |
| 52 | * .ini file and also supported on target device. |
Deepak Dhamdhere | 13230d3 | 2016-05-26 00:46:53 -0700 | [diff] [blame] | 53 | * |
| 54 | * Return: None |
| 55 | */ |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 56 | void hdd_nan_datapath_target_config(struct hdd_context *hdd_ctx, |
Manikandan Mohan | dcd0fdf | 2018-08-02 18:13:37 -0700 | [diff] [blame] | 57 | struct wma_tgt_cfg *tgt_cfg) |
Deepak Dhamdhere | 13230d3 | 2016-05-26 00:46:53 -0700 | [diff] [blame] | 58 | { |
Deepak Dhamdhere | 7e6016f | 2016-06-01 09:37:37 -0700 | [diff] [blame] | 59 | hdd_ctx->nan_datapath_enabled = |
Dustin Brown | 05d8130 | 2018-09-11 16:49:22 -0700 | [diff] [blame] | 60 | cfg_nan_get_datapath_enable(hdd_ctx->psoc) && |
Manikandan Mohan | dcd0fdf | 2018-08-02 18:13:37 -0700 | [diff] [blame] | 61 | tgt_cfg->nan_datapath_enabled; |
| 62 | hdd_debug("NAN Datapath Enable: %d (Host: %d FW: %d)", |
Dustin Brown | 7e761c7 | 2018-07-31 13:50:17 -0700 | [diff] [blame] | 63 | hdd_ctx->nan_datapath_enabled, |
Dustin Brown | 05d8130 | 2018-09-11 16:49:22 -0700 | [diff] [blame] | 64 | cfg_nan_get_datapath_enable(hdd_ctx->psoc), |
Manikandan Mohan | dcd0fdf | 2018-08-02 18:13:37 -0700 | [diff] [blame] | 65 | tgt_cfg->nan_datapath_enabled); |
Deepak Dhamdhere | 13230d3 | 2016-05-26 00:46:53 -0700 | [diff] [blame] | 66 | } |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 67 | |
| 68 | /** |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 69 | * hdd_close_ndi() - close NAN Data interface |
| 70 | * @adapter: adapter context |
| 71 | * |
| 72 | * Close the adapter if start BSS fails |
| 73 | * |
| 74 | * Returns: 0 on success, negative error code otherwise |
| 75 | */ |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 76 | static int hdd_close_ndi(struct hdd_adapter *adapter) |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 77 | { |
Dustin Brown | 0d2eeae | 2017-03-24 15:21:32 -0700 | [diff] [blame] | 78 | int errno; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 79 | struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 80 | |
Dustin Brown | 491d54b | 2018-03-14 12:39:11 -0700 | [diff] [blame] | 81 | hdd_enter(); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 82 | |
| 83 | /* check if the adapter is in NAN Data mode */ |
| 84 | if (QDF_NDI_MODE != adapter->device_mode) { |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 85 | hdd_err("Interface is not in NDI mode"); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 86 | return -EINVAL; |
| 87 | } |
Deepak Dhamdhere | 5872c8c | 2016-06-02 15:51:47 -0700 | [diff] [blame] | 88 | wlan_hdd_netif_queue_control(adapter, |
Himanshu Agarwal | 865201d | 2017-04-12 15:45:31 +0530 | [diff] [blame] | 89 | WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, |
Deepak Dhamdhere | 5872c8c | 2016-06-02 15:51:47 -0700 | [diff] [blame] | 90 | WLAN_CONTROL_PATH); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 91 | |
| 92 | #ifdef WLAN_OPEN_SOURCE |
Jeff Johnson | b527ebe | 2017-10-28 13:14:03 -0700 | [diff] [blame] | 93 | cancel_work_sync(&adapter->ipv4_notifier_work); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 94 | #endif |
Visweswara Tanuku | b5a6124 | 2019-03-26 12:24:13 +0530 | [diff] [blame] | 95 | hdd_deregister_hl_netdev_fc_timer(adapter); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 96 | hdd_deregister_tx_flow_control(adapter); |
| 97 | |
| 98 | #ifdef WLAN_NS_OFFLOAD |
| 99 | #ifdef WLAN_OPEN_SOURCE |
Jeff Johnson | b527ebe | 2017-10-28 13:14:03 -0700 | [diff] [blame] | 100 | cancel_work_sync(&adapter->ipv6_notifier_work); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 101 | #endif |
| 102 | #endif |
Dustin Brown | 0d2eeae | 2017-03-24 15:21:32 -0700 | [diff] [blame] | 103 | errno = hdd_vdev_destroy(adapter); |
| 104 | if (errno) |
| 105 | hdd_err("failed to destroy vdev: %d", errno); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 106 | |
| 107 | /* We are good to close the adapter */ |
| 108 | hdd_close_adapter(hdd_ctx, adapter, true); |
| 109 | |
Dustin Brown | e74003f | 2018-03-14 12:51:58 -0700 | [diff] [blame] | 110 | hdd_exit(); |
Deepak Dhamdhere | 616d9c5 | 2016-06-01 12:39:51 -0700 | [diff] [blame] | 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | /** |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 115 | * hdd_is_ndp_allowed() - Indicates if NDP is allowed |
| 116 | * @hdd_ctx: hdd context |
| 117 | * |
| 118 | * NDP is not allowed with any other role active except STA. |
| 119 | * |
| 120 | * Return: true if allowed, false otherwise |
| 121 | */ |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 122 | #ifdef NDP_SAP_CONCURRENCY_ENABLE |
| 123 | static bool hdd_is_ndp_allowed(struct hdd_context *hdd_ctx) |
| 124 | { |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 125 | struct hdd_adapter *adapter, *next_adapter = NULL; |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 126 | struct hdd_station_ctx *sta_ctx; |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 127 | wlan_net_dev_ref_dbgid dbgid = NET_DEV_HOLD_IS_NDP_ALLOWED; |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 128 | |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 129 | hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter, |
| 130 | dbgid) { |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 131 | switch (adapter->device_mode) { |
| 132 | case QDF_P2P_GO_MODE: |
| 133 | if (test_bit(SOFTAP_BSS_STARTED, |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 134 | &adapter->event_flags)) { |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 135 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 136 | if (next_adapter) |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 137 | hdd_adapter_dev_put_debug(next_adapter, |
| 138 | dbgid); |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 139 | return false; |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 140 | } |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 141 | break; |
| 142 | case QDF_P2P_CLIENT_MODE: |
| 143 | case QDF_IBSS_MODE: |
| 144 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 145 | if (hdd_conn_is_connected(sta_ctx) || |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 146 | hdd_is_connecting(sta_ctx)) { |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 147 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 148 | if (next_adapter) |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 149 | hdd_adapter_dev_put_debug(next_adapter, |
| 150 | dbgid); |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 151 | return false; |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 152 | } |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 153 | break; |
| 154 | default: |
| 155 | break; |
| 156 | } |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 157 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | return true; |
| 161 | } |
| 162 | #else |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 163 | static bool hdd_is_ndp_allowed(struct hdd_context *hdd_ctx) |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 164 | { |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 165 | struct hdd_adapter *adapter, *next_adapter = NULL; |
Jeff Johnson | 40dae4e | 2017-08-29 14:00:25 -0700 | [diff] [blame] | 166 | struct hdd_station_ctx *sta_ctx; |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 167 | wlan_net_dev_ref_dbgid dbgid = NET_DEV_HOLD_IS_NDP_ALLOWED; |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 168 | |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 169 | hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter, |
| 170 | dbgid) { |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 171 | switch (adapter->device_mode) { |
| 172 | case QDF_P2P_GO_MODE: |
| 173 | case QDF_SAP_MODE: |
| 174 | if (test_bit(SOFTAP_BSS_STARTED, |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 175 | &adapter->event_flags)) { |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 176 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 177 | if (next_adapter) |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 178 | hdd_adapter_dev_put_debug(next_adapter, |
| 179 | dbgid); |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 180 | return false; |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 181 | } |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 182 | break; |
| 183 | case QDF_P2P_CLIENT_MODE: |
| 184 | case QDF_IBSS_MODE: |
| 185 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 186 | if (hdd_conn_is_connected(sta_ctx) || |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 187 | hdd_is_connecting(sta_ctx)) { |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 188 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 189 | if (next_adapter) |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 190 | hdd_adapter_dev_put_debug(next_adapter, |
| 191 | dbgid); |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 192 | return false; |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 193 | } |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 194 | break; |
| 195 | default: |
| 196 | break; |
| 197 | } |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 198 | hdd_adapter_dev_put_debug(adapter, dbgid); |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | return true; |
| 202 | } |
Wu Gao | 18596ae | 2019-08-13 17:33:14 +0800 | [diff] [blame] | 203 | #endif /* NDP_SAP_CONCURRENCY_ENABLE */ |
Deepak Dhamdhere | 0f076bd | 2016-06-02 11:29:21 -0700 | [diff] [blame] | 204 | |
| 205 | /** |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 206 | * hdd_ndi_start_bss() - Start BSS on NAN data interface |
| 207 | * @adapter: adapter context |
| 208 | * @operating_channel: channel on which the BSS to be started |
| 209 | * |
| 210 | * Return: 0 on success, error value on failure |
| 211 | */ |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 212 | static int hdd_ndi_start_bss(struct hdd_adapter *adapter, |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 213 | uint8_t operating_channel) |
| 214 | { |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 215 | QDF_STATUS status; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 216 | uint32_t roam_id; |
Jeff Johnson | 641839e | 2018-03-18 14:50:39 -0700 | [diff] [blame] | 217 | struct csr_roam_profile *roam_profile; |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 218 | mac_handle_t mac_handle; |
Abhinav Kumar | 7d6f1ac | 2018-09-01 18:33:56 +0530 | [diff] [blame] | 219 | uint8_t wmm_mode = 0; |
| 220 | struct hdd_context *hdd_ctx; |
| 221 | uint8_t value = 0; |
wadesong | 24c869a | 2019-07-19 17:38:59 +0800 | [diff] [blame] | 222 | uint32_t oper_freq; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 223 | |
Dustin Brown | 491d54b | 2018-03-14 12:39:11 -0700 | [diff] [blame] | 224 | hdd_enter(); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 225 | |
Jeff Johnson | 641839e | 2018-03-18 14:50:39 -0700 | [diff] [blame] | 226 | roam_profile = hdd_roam_profile(adapter); |
Abhinav Kumar | 7d6f1ac | 2018-09-01 18:33:56 +0530 | [diff] [blame] | 227 | hdd_ctx = WLAN_HDD_GET_CTX(adapter); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 228 | |
Abhinav Kumar | 7d6f1ac | 2018-09-01 18:33:56 +0530 | [diff] [blame] | 229 | status = ucfg_mlme_get_wmm_mode(hdd_ctx->psoc, &wmm_mode); |
| 230 | if (!QDF_IS_STATUS_SUCCESS(status)) { |
| 231 | hdd_err("Get wmm_mode failed"); |
| 232 | return -EINVAL; |
| 233 | } |
| 234 | |
| 235 | if (HDD_WMM_USER_MODE_NO_QOS == wmm_mode) { |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 236 | /* QoS not enabled in cfg file*/ |
| 237 | roam_profile->uapsd_mask = 0; |
| 238 | } else { |
| 239 | /* QoS enabled, update uapsd mask from cfg file*/ |
Abhinav Kumar | 7d6f1ac | 2018-09-01 18:33:56 +0530 | [diff] [blame] | 240 | status = ucfg_mlme_get_wmm_uapsd_mask(hdd_ctx->psoc, &value); |
| 241 | if (!QDF_IS_STATUS_SUCCESS(status)) { |
| 242 | hdd_err("Get uapsd_mask failed"); |
| 243 | return -EINVAL; |
| 244 | } |
| 245 | roam_profile->uapsd_mask = value; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | roam_profile->csrPersona = adapter->device_mode; |
| 249 | |
Naveen Rawat | 709c0cb | 2018-03-14 17:04:15 -0700 | [diff] [blame] | 250 | if (!operating_channel) |
| 251 | operating_channel = NAN_SOCIAL_CHANNEL_2_4GHZ; |
wadesong | 24c869a | 2019-07-19 17:38:59 +0800 | [diff] [blame] | 252 | oper_freq = wlan_reg_chan_to_freq(hdd_ctx->pdev, operating_channel); |
Naveen Rawat | 709c0cb | 2018-03-14 17:04:15 -0700 | [diff] [blame] | 253 | |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 254 | roam_profile->ChannelInfo.numOfChannels = 1; |
wadesong | 24c869a | 2019-07-19 17:38:59 +0800 | [diff] [blame] | 255 | roam_profile->ChannelInfo.freq_list = &oper_freq; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 256 | |
| 257 | roam_profile->SSIDs.numOfSSIDs = 1; |
| 258 | roam_profile->SSIDs.SSIDList->SSID.length = 0; |
| 259 | |
| 260 | roam_profile->phyMode = eCSR_DOT11_MODE_11ac; |
| 261 | roam_profile->BSSType = eCSR_BSS_TYPE_NDI; |
| 262 | roam_profile->BSSIDs.numOfBSSIDs = 1; |
| 263 | qdf_mem_copy((void *)(roam_profile->BSSIDs.bssid), |
Jeff Johnson | 1e851a1 | 2017-10-28 14:36:12 -0700 | [diff] [blame] | 264 | &adapter->mac_addr.bytes[0], |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 265 | QDF_MAC_ADDR_SIZE); |
| 266 | |
| 267 | roam_profile->AuthType.numEntries = 1; |
| 268 | roam_profile->AuthType.authType[0] = eCSR_AUTH_TYPE_OPEN_SYSTEM; |
| 269 | roam_profile->EncryptionType.numEntries = 1; |
| 270 | roam_profile->EncryptionType.encryptionType[0] = eCSR_ENCRYPT_TYPE_NONE; |
| 271 | |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 272 | mac_handle = hdd_adapter_get_mac_handle(adapter); |
Jeff Johnson | 9597f3b | 2019-02-04 14:27:56 -0800 | [diff] [blame] | 273 | status = sme_roam_connect(mac_handle, adapter->vdev_id, |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 274 | roam_profile, &roam_id); |
| 275 | if (QDF_IS_STATUS_ERROR(status)) { |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 276 | hdd_err("NDI sme_RoamConnect session %d failed with status %d -> NotConnected", |
Jeff Johnson | 9597f3b | 2019-02-04 14:27:56 -0800 | [diff] [blame] | 277 | adapter->vdev_id, status); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 278 | /* change back to NotConnected */ |
| 279 | hdd_conn_set_connection_state(adapter, |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 280 | eConnectionState_NotConnected); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 281 | } else { |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 282 | hdd_info("sme_RoamConnect issued successfully for NDI"); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 283 | } |
| 284 | |
wadesong | 24c869a | 2019-07-19 17:38:59 +0800 | [diff] [blame] | 285 | roam_profile->ChannelInfo.freq_list = NULL; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 286 | roam_profile->ChannelInfo.numOfChannels = 0; |
| 287 | |
Dustin Brown | e74003f | 2018-03-14 12:51:58 -0700 | [diff] [blame] | 288 | hdd_exit(); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 289 | |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 290 | return 0; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 291 | } |
| 292 | |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 293 | /** |
| 294 | * hdd_get_random_nan_mac_addr() - generate random non pre-existent mac address |
| 295 | * @hdd_ctx: hdd context pointer |
| 296 | * @mac_addr: mac address buffer to populate |
| 297 | * |
| 298 | * Return: status of operation |
| 299 | */ |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 300 | static int hdd_get_random_nan_mac_addr(struct hdd_context *hdd_ctx, |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 301 | struct qdf_mac_addr *mac_addr) |
| 302 | { |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 303 | struct hdd_adapter *adapter; |
Naveen Rawat | ea1ece8 | 2018-02-09 14:22:52 -0800 | [diff] [blame] | 304 | uint8_t pos, bit_pos, byte_pos, mask; |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 305 | uint8_t i, attempts, max_attempt = 16; |
Ashish Kumar Dhanotiya | 7a11e27 | 2018-11-28 13:16:55 +0530 | [diff] [blame] | 306 | bool found; |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 307 | |
| 308 | for (attempts = 0; attempts < max_attempt; attempts++) { |
Ashish Kumar Dhanotiya | 7a11e27 | 2018-11-28 13:16:55 +0530 | [diff] [blame] | 309 | found = false; |
Naveen Rawat | ea1ece8 | 2018-02-09 14:22:52 -0800 | [diff] [blame] | 310 | /* if NDI is present next addr is required to be 1 bit apart */ |
| 311 | adapter = hdd_get_adapter(hdd_ctx, QDF_NDI_MODE); |
| 312 | if (adapter) { |
| 313 | hdd_debug("NDI already exists, deriving next mac"); |
| 314 | qdf_mem_copy(mac_addr, &adapter->mac_addr, |
| 315 | sizeof(*mac_addr)); |
Jeff Johnson | 51a8052 | 2018-12-11 20:19:44 -0800 | [diff] [blame] | 316 | qdf_get_random_bytes(&pos, sizeof(pos)); |
Naveen Rawat | ea1ece8 | 2018-02-09 14:22:52 -0800 | [diff] [blame] | 317 | /* skipping byte 0, 5 leaves 8*4=32 positions */ |
| 318 | pos = pos % 32; |
| 319 | bit_pos = pos % 8; |
| 320 | byte_pos = pos / 8; |
| 321 | mask = 1 << bit_pos; |
| 322 | /* flip the required bit */ |
| 323 | mac_addr->bytes[byte_pos + 1] ^= mask; |
| 324 | } else { |
Jeff Johnson | 51a8052 | 2018-12-11 20:19:44 -0800 | [diff] [blame] | 325 | qdf_get_random_bytes(mac_addr, sizeof(*mac_addr)); |
Naveen Rawat | ea1ece8 | 2018-02-09 14:22:52 -0800 | [diff] [blame] | 326 | /* |
| 327 | * Reset multicast bit (bit-0) and set |
| 328 | * locally-administered bit |
| 329 | */ |
| 330 | mac_addr->bytes[0] = 0x2; |
Ravi Joshi | 04a1c99 | 2017-06-11 19:47:54 -0700 | [diff] [blame] | 331 | |
Naveen Rawat | ea1ece8 | 2018-02-09 14:22:52 -0800 | [diff] [blame] | 332 | /* |
| 333 | * to avoid potential conflict with FW's generated NMI |
| 334 | * mac addr, host sets LSB if 6th byte to 0 |
| 335 | */ |
| 336 | mac_addr->bytes[5] &= 0xFE; |
| 337 | } |
Ashish Kumar Dhanotiya | 7a11e27 | 2018-11-28 13:16:55 +0530 | [diff] [blame] | 338 | for (i = 0; i < hdd_ctx->num_provisioned_addr; i++) { |
| 339 | if ((!qdf_mem_cmp(hdd_ctx-> |
| 340 | provisioned_mac_addr[i].bytes, |
| 341 | mac_addr, sizeof(*mac_addr)))) { |
| 342 | found = true; |
| 343 | break; |
| 344 | } |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 345 | } |
| 346 | |
Ashish Kumar Dhanotiya | 7a11e27 | 2018-11-28 13:16:55 +0530 | [diff] [blame] | 347 | if (found) |
| 348 | continue; |
| 349 | |
| 350 | for (i = 0; i < hdd_ctx->num_derived_addr; i++) { |
| 351 | if ((!qdf_mem_cmp(hdd_ctx-> |
| 352 | derived_mac_addr[i].bytes, |
| 353 | mac_addr, sizeof(*mac_addr)))) { |
| 354 | found = true; |
| 355 | break; |
| 356 | } |
| 357 | } |
| 358 | if (found) |
| 359 | continue; |
| 360 | |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 361 | adapter = hdd_get_adapter_by_macaddr(hdd_ctx, mac_addr->bytes); |
| 362 | if (!adapter) |
| 363 | return 0; |
| 364 | } |
| 365 | |
| 366 | hdd_err("unable to get non-pre-existing mac address in %d attempts", |
| 367 | max_attempt); |
| 368 | |
| 369 | return -EINVAL; |
| 370 | } |
| 371 | |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 372 | void hdd_ndp_event_handler(struct hdd_adapter *adapter, |
Jeff Johnson | 172237b | 2017-11-07 15:32:59 -0800 | [diff] [blame] | 373 | struct csr_roam_info *roam_info, |
| 374 | uint32_t roam_id, eRoamCmdStatus roam_status, |
| 375 | eCsrRoamResult roam_result) |
Naveen Rawat | 9750035 | 2017-03-22 10:07:58 -0700 | [diff] [blame] | 376 | { |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 377 | bool success; |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 378 | struct wlan_objmgr_psoc *psoc = wlan_vdev_get_psoc(adapter->vdev); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 379 | |
| 380 | if (roam_status == eCSR_ROAM_NDP_STATUS_UPDATE) { |
| 381 | switch (roam_result) { |
| 382 | case eCSR_ROAM_RESULT_NDI_CREATE_RSP: |
| 383 | success = (roam_info->ndp.ndi_create_params.status == |
| 384 | NAN_DATAPATH_RSP_STATUS_SUCCESS); |
Srinivas Dasari | e189846 | 2020-03-16 18:33:29 +0530 | [diff] [blame] | 385 | hdd_debug("posting ndi create status: %d (%s) to umac", |
| 386 | success, success ? "Success" : "Failure"); |
Jeff Johnson | 9597f3b | 2019-02-04 14:27:56 -0800 | [diff] [blame] | 387 | os_if_nan_post_ndi_create_rsp(psoc, adapter->vdev_id, |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 388 | success); |
| 389 | return; |
| 390 | case eCSR_ROAM_RESULT_NDI_DELETE_RSP: |
| 391 | success = (roam_info->ndp.ndi_create_params.status == |
| 392 | NAN_DATAPATH_RSP_STATUS_SUCCESS); |
Srinivas Dasari | e189846 | 2020-03-16 18:33:29 +0530 | [diff] [blame] | 393 | hdd_debug("posting ndi delete status: %d (%s) to umac", |
| 394 | success, success ? "Success" : "Failure"); |
Jeff Johnson | 9597f3b | 2019-02-04 14:27:56 -0800 | [diff] [blame] | 395 | os_if_nan_post_ndi_delete_rsp(psoc, adapter->vdev_id, |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 396 | success); |
| 397 | return; |
| 398 | default: |
| 399 | hdd_err("in correct roam_result: %d", roam_result); |
| 400 | return; |
| 401 | } |
| 402 | } else { |
| 403 | hdd_err("in correct roam_status: %d", roam_status); |
| 404 | return; |
| 405 | } |
Naveen Rawat | 9750035 | 2017-03-22 10:07:58 -0700 | [diff] [blame] | 406 | } |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 407 | |
| 408 | /** |
| 409 | * __wlan_hdd_cfg80211_process_ndp_cmds() - handle NDP request |
| 410 | * @wiphy: pointer to wireless wiphy structure. |
| 411 | * @wdev: pointer to wireless_dev structure. |
| 412 | * @data: Pointer to the data to be passed via vendor interface |
| 413 | * @data_len:Length of the data to be passed |
| 414 | * |
| 415 | * This function is invoked to handle vendor command |
| 416 | * |
| 417 | * Return: 0 on success, negative errno on failure |
| 418 | */ |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 419 | static int __wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy, |
| 420 | struct wireless_dev *wdev, const void *data, int data_len) |
| 421 | { |
| 422 | int ret_val; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 423 | struct hdd_context *hdd_ctx = wiphy_priv(wiphy); |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 424 | |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 425 | ret_val = wlan_hdd_validate_context(hdd_ctx); |
| 426 | if (ret_val) |
| 427 | return ret_val; |
| 428 | |
| 429 | if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) { |
Rajeev Kumar | 3872a5b | 2018-10-02 11:47:38 -0700 | [diff] [blame] | 430 | hdd_err_rl("Command not allowed in FTM mode"); |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 431 | return -EPERM; |
| 432 | } |
| 433 | |
| 434 | if (!WLAN_HDD_IS_NDP_ENABLED(hdd_ctx)) { |
Srinivas Dasari | 20bc5c6 | 2020-01-27 16:16:42 +0530 | [diff] [blame] | 435 | hdd_debug("NAN datapath is not enabled"); |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 436 | return -EPERM; |
| 437 | } |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 438 | |
Srinivas Dasari | 0610cc4 | 2019-10-29 18:23:54 +0530 | [diff] [blame] | 439 | return os_if_nan_process_ndp_cmd(hdd_ctx->psoc, data, data_len, |
| 440 | hdd_is_ndp_allowed(hdd_ctx)); |
Naveen Rawat | 63de542 | 2017-03-22 11:03:56 -0700 | [diff] [blame] | 441 | } |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 442 | |
| 443 | /** |
| 444 | * wlan_hdd_cfg80211_process_ndp_cmd() - handle NDP request |
| 445 | * @wiphy: pointer to wireless wiphy structure. |
| 446 | * @wdev: pointer to wireless_dev structure. |
| 447 | * @data: Pointer to the data to be passed via vendor interface |
| 448 | * @data_len:Length of the data to be passed |
| 449 | * |
| 450 | * This function is called to send a NAN request to |
| 451 | * firmware. This is an SSR-protected wrapper function. |
| 452 | * |
| 453 | * Return: 0 on success, negative errno on failure |
| 454 | */ |
| 455 | int wlan_hdd_cfg80211_process_ndp_cmd(struct wiphy *wiphy, |
Dustin Brown | 0d17e01 | 2019-02-20 10:21:17 -0800 | [diff] [blame] | 456 | struct wireless_dev *wdev, |
| 457 | const void *data, int data_len) |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 458 | { |
Dustin Brown | 0d17e01 | 2019-02-20 10:21:17 -0800 | [diff] [blame] | 459 | /* This call is intentionally not protected by op_start/op_stop, due to |
| 460 | * the various protection needs of the callbacks dispatched within. |
| 461 | */ |
| 462 | return __wlan_hdd_cfg80211_process_ndp_cmd(wiphy, wdev, |
| 463 | data, data_len); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 464 | } |
| 465 | |
Jeff Johnson | 85b5c11 | 2017-08-11 15:15:23 -0700 | [diff] [blame] | 466 | static int update_ndi_state(struct hdd_adapter *adapter, uint32_t state) |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 467 | { |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 468 | return os_if_nan_set_ndi_state(adapter->vdev, state); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 469 | } |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 470 | |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 471 | /** |
| 472 | * hdd_init_nan_data_mode() - initialize nan data mode |
| 473 | * @adapter: adapter context |
| 474 | * |
| 475 | * Returns: 0 on success negative error code on error |
| 476 | */ |
Jeff Johnson | 85b5c11 | 2017-08-11 15:15:23 -0700 | [diff] [blame] | 477 | int hdd_init_nan_data_mode(struct hdd_adapter *adapter) |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 478 | { |
| 479 | struct net_device *wlan_dev = adapter->dev; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 480 | struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 481 | QDF_STATUS status; |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 482 | int32_t ret_val; |
| 483 | mac_handle_t mac_handle; |
Abhinav Kumar | b074f2f | 2018-09-15 15:32:11 +0530 | [diff] [blame] | 484 | bool bval = false; |
Qun Zhang | 1b3c85c | 2019-08-27 16:31:49 +0800 | [diff] [blame] | 485 | uint8_t enable_sifs_burst = 0; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 486 | |
Arun Kumar Khandavalli | 42b4487 | 2019-10-21 19:02:04 +0530 | [diff] [blame] | 487 | ret_val = hdd_vdev_create(adapter); |
Dustin Brown | d28772b | 2017-03-17 14:16:07 -0700 | [diff] [blame] | 488 | if (ret_val) { |
| 489 | hdd_err("failed to create vdev: %d", ret_val); |
| 490 | return ret_val; |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 491 | } |
| 492 | |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 493 | mac_handle = hdd_ctx->mac_handle; |
| 494 | |
Ravi Joshi | 8eb65f9 | 2017-07-20 16:30:19 -0700 | [diff] [blame] | 495 | /* Configure self HT/VHT capabilities */ |
Jeff Johnson | 32833f1 | 2018-06-13 20:26:34 -0700 | [diff] [blame] | 496 | sme_set_curr_device_mode(mac_handle, adapter->device_mode); |
Abhinav Kumar | b074f2f | 2018-09-15 15:32:11 +0530 | [diff] [blame] | 497 | |
| 498 | status = ucfg_mlme_get_vht_enable2x2(hdd_ctx->psoc, &bval); |
| 499 | if (!QDF_IS_STATUS_SUCCESS(status)) |
| 500 | hdd_err("unable to get vht_enable2x2"); |
| 501 | |
| 502 | sme_set_pdev_ht_vht_ies(mac_handle, bval); |
Kiran Kumar Lokere | 46ca7d7 | 2020-08-20 19:36:39 -0700 | [diff] [blame] | 503 | sme_set_vdev_ies_per_band(mac_handle, adapter->vdev_id, |
| 504 | adapter->device_mode); |
Ravi Joshi | 8eb65f9 | 2017-07-20 16:30:19 -0700 | [diff] [blame] | 505 | |
Jeff Johnson | 7f2c591 | 2018-03-23 11:42:28 -0700 | [diff] [blame] | 506 | hdd_roam_profile_init(adapter); |
| 507 | hdd_register_wext(wlan_dev); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 508 | |
| 509 | status = hdd_init_tx_rx(adapter); |
| 510 | if (QDF_STATUS_SUCCESS != status) { |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 511 | hdd_err("hdd_init_tx_rx() init failed, status %d", status); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 512 | ret_val = -EAGAIN; |
| 513 | goto error_init_txrx; |
| 514 | } |
| 515 | |
| 516 | set_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags); |
| 517 | |
| 518 | status = hdd_wmm_adapter_init(adapter); |
| 519 | if (QDF_STATUS_SUCCESS != status) { |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 520 | hdd_err("hdd_wmm_adapter_init() failed, status %d", status); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 521 | ret_val = -EAGAIN; |
| 522 | goto error_wmm_init; |
| 523 | } |
| 524 | |
| 525 | set_bit(WMM_INIT_DONE, &adapter->event_flags); |
| 526 | |
Qun Zhang | 1b3c85c | 2019-08-27 16:31:49 +0800 | [diff] [blame] | 527 | status = ucfg_get_enable_sifs_burst(hdd_ctx->psoc, &enable_sifs_burst); |
| 528 | if (!QDF_IS_STATUS_SUCCESS(status)) |
| 529 | hdd_err("Failed to get sifs burst value, use default"); |
| 530 | |
Jeff Johnson | 9597f3b | 2019-02-04 14:27:56 -0800 | [diff] [blame] | 531 | ret_val = wma_cli_set_command((int)adapter->vdev_id, |
Qun Zhang | 1b3c85c | 2019-08-27 16:31:49 +0800 | [diff] [blame] | 532 | (int)WMI_PDEV_PARAM_BURST_ENABLE, |
| 533 | enable_sifs_burst, |
| 534 | PDEV_CMD); |
Arunk Khandavalli | 15664e4 | 2017-06-29 15:56:14 +0530 | [diff] [blame] | 535 | if (0 != ret_val) |
Naveen Rawat | ba4f661 | 2016-07-05 12:03:16 -0700 | [diff] [blame] | 536 | hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed %d", ret_val); |
Arunk Khandavalli | 15664e4 | 2017-06-29 15:56:14 +0530 | [diff] [blame] | 537 | |
Mohit Khanna | d42aad8 | 2020-05-21 17:03:46 -0700 | [diff] [blame] | 538 | hdd_set_netdev_flags(adapter); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 539 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 540 | update_ndi_state(adapter, NAN_DATA_NDI_CREATING_STATE); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 541 | return ret_val; |
| 542 | |
| 543 | error_wmm_init: |
| 544 | clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags); |
| 545 | hdd_deinit_tx_rx(adapter); |
| 546 | |
| 547 | error_init_txrx: |
| 548 | hdd_unregister_wext(wlan_dev); |
| 549 | |
Dustin Brown | d28772b | 2017-03-17 14:16:07 -0700 | [diff] [blame] | 550 | QDF_BUG(!hdd_vdev_destroy(adapter)); |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 551 | |
Deepak Dhamdhere | 5cdce84 | 2016-05-31 10:39:12 -0700 | [diff] [blame] | 552 | return ret_val; |
| 553 | } |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 554 | |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 555 | int hdd_ndi_open(char *iface_name) |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 556 | { |
Abdul Muqtadeer Ahmed | 6a082c6 | 2021-01-07 17:19:48 +0530 | [diff] [blame] | 557 | struct hdd_adapter *adapter, *next_adapter = NULL; |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 558 | struct qdf_mac_addr random_ndi_mac; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 559 | struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
Nachiket Kukade | 413c5fa | 2019-02-19 17:57:19 +0530 | [diff] [blame] | 560 | uint8_t ndi_adapter_count = 0; |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 561 | uint8_t *ndi_mac_addr; |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 562 | |
Dustin Brown | 491d54b | 2018-03-14 12:39:11 -0700 | [diff] [blame] | 563 | hdd_enter(); |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 564 | if (!hdd_ctx) { |
| 565 | hdd_err("hdd_ctx null"); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 566 | return -EINVAL; |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 567 | } |
| 568 | |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 569 | hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter, |
| 570 | NET_DEV_HOLD_NDI_OPEN) { |
Nachiket Kukade | 413c5fa | 2019-02-19 17:57:19 +0530 | [diff] [blame] | 571 | if (WLAN_HDD_IS_NDI(adapter)) |
| 572 | ndi_adapter_count++; |
Bapiraju Alla | 797b21b | 2020-11-23 13:44:21 +0530 | [diff] [blame^] | 573 | hdd_adapter_dev_put_debug(adapter, NET_DEV_HOLD_NDI_OPEN); |
Nachiket Kukade | 413c5fa | 2019-02-19 17:57:19 +0530 | [diff] [blame] | 574 | } |
| 575 | if (ndi_adapter_count >= MAX_NDI_ADAPTERS) { |
| 576 | hdd_err("Can't allow more than %d NDI adapters", |
| 577 | MAX_NDI_ADAPTERS); |
| 578 | return -EINVAL; |
| 579 | } |
| 580 | |
Dustin Brown | 05d8130 | 2018-09-11 16:49:22 -0700 | [diff] [blame] | 581 | if (cfg_nan_get_ndi_mac_randomize(hdd_ctx->psoc)) { |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 582 | if (hdd_get_random_nan_mac_addr(hdd_ctx, &random_ndi_mac)) { |
| 583 | hdd_err("get random mac address failed"); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 584 | return -EFAULT; |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 585 | } |
| 586 | ndi_mac_addr = &random_ndi_mac.bytes[0]; |
| 587 | } else { |
Ashish Kumar Dhanotiya | 7a11e27 | 2018-11-28 13:16:55 +0530 | [diff] [blame] | 588 | ndi_mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_NDI_MODE); |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 589 | if (!ndi_mac_addr) { |
| 590 | hdd_err("get intf address failed"); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 591 | return -EFAULT; |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 592 | } |
Naveen Rawat | 5a6f840 | 2017-07-03 16:00:11 -0700 | [diff] [blame] | 593 | } |
| 594 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 595 | adapter = hdd_open_adapter(hdd_ctx, QDF_NDI_MODE, iface_name, |
Ravi Joshi | 9771d43 | 2017-06-26 13:58:12 -0700 | [diff] [blame] | 596 | ndi_mac_addr, NET_NAME_UNKNOWN, true); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 597 | if (!adapter) { |
Li Feng | ad3d742 | 2020-04-12 21:35:42 +0800 | [diff] [blame] | 598 | if (!cfg_nan_get_ndi_mac_randomize(hdd_ctx->psoc)) |
| 599 | wlan_hdd_release_intf_addr(hdd_ctx, ndi_mac_addr); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 600 | hdd_err("hdd_open_adapter failed"); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 601 | return -EINVAL; |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 602 | } |
| 603 | |
Dustin Brown | e74003f | 2018-03-14 12:51:58 -0700 | [diff] [blame] | 604 | hdd_exit(); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 605 | return 0; |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 606 | } |
| 607 | |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 608 | int hdd_ndi_start(char *iface_name, uint16_t transaction_id) |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 609 | { |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 610 | int ret; |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 611 | QDF_STATUS status; |
Nachiket Kukade | c1bba2f | 2018-12-11 12:07:09 +0530 | [diff] [blame] | 612 | uint8_t op_channel; |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 613 | struct hdd_adapter *adapter; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 614 | struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 615 | |
Dustin Brown | 491d54b | 2018-03-14 12:39:11 -0700 | [diff] [blame] | 616 | hdd_enter(); |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 617 | if (!hdd_ctx) { |
| 618 | hdd_err("hdd_ctx is null"); |
| 619 | return -EINVAL; |
| 620 | } |
| 621 | |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 622 | adapter = hdd_get_adapter_by_iface_name(hdd_ctx, iface_name); |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 623 | if (!adapter) { |
| 624 | hdd_err("adapter is null"); |
| 625 | return -EINVAL; |
| 626 | } |
| 627 | |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 628 | /* create nan vdev */ |
| 629 | status = hdd_init_nan_data_mode(adapter); |
| 630 | if (QDF_STATUS_SUCCESS != status) { |
| 631 | hdd_err("failed to init nan data intf, status :%d", status); |
| 632 | ret = -EFAULT; |
| 633 | goto err_handler; |
| 634 | } |
| 635 | |
| 636 | /* |
| 637 | * Create transaction id is required to be saved since the firmware |
| 638 | * does not honor the transaction id for create request |
| 639 | */ |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 640 | ucfg_nan_set_ndp_create_transaction_id(adapter->vdev, |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 641 | transaction_id); |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 642 | ucfg_nan_set_ndi_state(adapter->vdev, |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 643 | NAN_DATA_NDI_CREATING_STATE); |
| 644 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 645 | /* |
| 646 | * The NAN data interface has been created at this point. |
| 647 | * Unlike traditional device modes, where the higher application |
| 648 | * layer initiates connect / join / start, the NAN data |
| 649 | * interface does not have any such formal requests. The NDI |
| 650 | * create request is responsible for starting the BSS as well. |
Nachiket Kukade | c1bba2f | 2018-12-11 12:07:09 +0530 | [diff] [blame] | 651 | * Use the 5GHz Band NAN Social channel for BSS start if target |
| 652 | * supports it, since a 2.4GHz channel will require a DBS HW mode change |
| 653 | * first on a DBS 2x2 MAC target. Use a 2.4 GHz Band NAN Social channel |
| 654 | * if the target is not 5GHz capable. |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 655 | */ |
Nachiket Kukade | c1bba2f | 2018-12-11 12:07:09 +0530 | [diff] [blame] | 656 | |
| 657 | if (hdd_is_5g_supported(hdd_ctx)) |
| 658 | op_channel = NAN_SOCIAL_CHANNEL_5GHZ_LOWER_BAND; |
| 659 | else |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 660 | op_channel = NAN_SOCIAL_CHANNEL_2_4GHZ; |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 661 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 662 | if (hdd_ndi_start_bss(adapter, op_channel)) { |
| 663 | hdd_err("NDI start bss failed"); |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 664 | ret = -EFAULT; |
| 665 | goto err_handler; |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 666 | } |
| 667 | |
Dustin Brown | e74003f | 2018-03-14 12:51:58 -0700 | [diff] [blame] | 668 | hdd_exit(); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 669 | return 0; |
Naveen Rawat | 23a3b91 | 2018-05-30 17:45:52 -0700 | [diff] [blame] | 670 | |
| 671 | err_handler: |
| 672 | |
| 673 | /* Start BSS failed, delete the interface */ |
| 674 | hdd_close_ndi(adapter); |
| 675 | return ret; |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | int hdd_ndi_delete(uint8_t vdev_id, char *iface_name, uint16_t transaction_id) |
| 679 | { |
| 680 | int ret; |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 681 | struct hdd_adapter *adapter; |
Jeff Johnson | 40dae4e | 2017-08-29 14:00:25 -0700 | [diff] [blame] | 682 | struct hdd_station_ctx *sta_ctx; |
Jeff Johnson | 88dc4f9 | 2017-08-28 11:51:34 -0700 | [diff] [blame] | 683 | struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 684 | |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 685 | if (!hdd_ctx) { |
| 686 | hdd_err("hdd_ctx is null"); |
| 687 | return -EINVAL; |
| 688 | } |
| 689 | |
Naveen Rawat | c4b045c | 2017-06-30 16:11:42 -0700 | [diff] [blame] | 690 | /* check if adapter by vdev_id is valid NDI */ |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 691 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 692 | if (!adapter || !WLAN_HDD_IS_NDI(adapter)) { |
| 693 | hdd_err("NAN data interface %s is not available", iface_name); |
| 694 | return -EINVAL; |
| 695 | } |
| 696 | |
| 697 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 698 | if (!sta_ctx) { |
| 699 | hdd_err("sta_ctx is NULL"); |
| 700 | return -EINVAL; |
| 701 | } |
| 702 | |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 703 | os_if_nan_set_ndp_delete_transaction_id(adapter->vdev, |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 704 | transaction_id); |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 705 | os_if_nan_set_ndi_state(adapter->vdev, NAN_DATA_NDI_DELETING_STATE); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 706 | |
| 707 | /* Delete the interface */ |
| 708 | ret = __wlan_hdd_del_virtual_intf(hdd_ctx->wiphy, &adapter->wdev); |
| 709 | if (ret) |
| 710 | hdd_err("NDI delete request failed"); |
| 711 | else |
| 712 | hdd_err("NDI delete request successfully issued"); |
| 713 | |
| 714 | return ret; |
| 715 | } |
| 716 | |
| 717 | void hdd_ndi_drv_ndi_create_rsp_handler(uint8_t vdev_id, |
| 718 | struct nan_datapath_inf_create_rsp *ndi_rsp) |
| 719 | { |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 720 | struct hdd_context *hdd_ctx; |
| 721 | struct hdd_adapter *adapter; |
| 722 | struct hdd_station_ctx *sta_ctx; |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 723 | struct csr_roam_info *roam_info; |
Jeff Johnson | 4ba73cb | 2017-10-06 11:12:33 -0700 | [diff] [blame] | 724 | struct bss_description tmp_bss_descp = {0}; |
Sourav Mohapatra | 3f02b6a | 2019-09-06 14:38:53 +0530 | [diff] [blame] | 725 | uint16_t ndp_inactivity_timeout = 0; |
Ashish Kumar Dhanotiya | b3ae646 | 2020-02-06 14:41:21 +0530 | [diff] [blame] | 726 | uint16_t ndp_keep_alive_period; |
Dustin Brown | ce5b3d3 | 2018-01-17 15:07:38 -0800 | [diff] [blame] | 727 | struct qdf_mac_addr bc_mac_addr = QDF_MAC_ADDR_BCAST_INIT; |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 728 | |
| 729 | hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
| 730 | if (!hdd_ctx) { |
| 731 | hdd_err("hdd_ctx is null"); |
| 732 | return; |
| 733 | } |
| 734 | |
| 735 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 736 | if (!adapter) { |
| 737 | hdd_err("adapter is null"); |
| 738 | return; |
| 739 | } |
| 740 | |
| 741 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 742 | if (!sta_ctx) { |
| 743 | hdd_err("sta_ctx is null"); |
| 744 | return; |
| 745 | } |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 746 | |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 747 | roam_info = qdf_mem_malloc(sizeof(*roam_info)); |
| 748 | if (!roam_info) |
| 749 | return; |
| 750 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 751 | if (ndi_rsp->status == QDF_STATUS_SUCCESS) { |
| 752 | hdd_alert("NDI interface successfully created"); |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 753 | os_if_nan_set_ndp_create_transaction_id(adapter->vdev, 0); |
| 754 | os_if_nan_set_ndi_state(adapter->vdev, |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 755 | NAN_DATA_NDI_CREATED_STATE); |
| 756 | wlan_hdd_netif_queue_control(adapter, |
| 757 | WLAN_START_ALL_NETIF_QUEUE_N_CARRIER, |
| 758 | WLAN_CONTROL_PATH); |
Sourav Mohapatra | 3f02b6a | 2019-09-06 14:38:53 +0530 | [diff] [blame] | 759 | |
| 760 | if (QDF_IS_STATUS_ERROR(cfg_nan_get_ndp_inactivity_timeout( |
| 761 | hdd_ctx->psoc, &ndp_inactivity_timeout))) |
| 762 | hdd_err("Failed to fetch inactivity timeout value"); |
| 763 | |
| 764 | sme_cli_set_command(adapter->vdev_id, |
| 765 | WMI_VDEV_PARAM_NDP_INACTIVITY_TIMEOUT, |
| 766 | ndp_inactivity_timeout, VDEV_CMD); |
Ashish Kumar Dhanotiya | b3ae646 | 2020-02-06 14:41:21 +0530 | [diff] [blame] | 767 | |
| 768 | if (QDF_IS_STATUS_SUCCESS(cfg_nan_get_ndp_keepalive_period( |
| 769 | hdd_ctx->psoc, |
| 770 | &ndp_keep_alive_period))) |
| 771 | sme_cli_set_command( |
| 772 | adapter->vdev_id, |
| 773 | WMI_VDEV_PARAM_NDP_KEEPALIVE_TIMEOUT, |
| 774 | ndp_keep_alive_period, VDEV_CMD); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 775 | } else { |
| 776 | hdd_alert("NDI interface creation failed with reason %d", |
| 777 | ndi_rsp->reason /* create_reason */); |
| 778 | } |
| 779 | |
Sourav Mohapatra | a3cf12a | 2019-08-19 15:40:49 +0530 | [diff] [blame] | 780 | hdd_save_peer(sta_ctx, &bc_mac_addr); |
Bala Venkatesh | b184b77 | 2019-08-21 19:54:04 +0530 | [diff] [blame] | 781 | qdf_copy_macaddr(&roam_info->bssid, &bc_mac_addr); |
Sourav Mohapatra | a3cf12a | 2019-08-19 15:40:49 +0530 | [diff] [blame] | 782 | hdd_roam_register_sta(adapter, roam_info, &tmp_bss_descp); |
Rajeev Kumar Sirasanagandla | 7172b49 | 2019-06-10 19:42:28 +0530 | [diff] [blame] | 783 | |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 784 | qdf_mem_free(roam_info); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 785 | } |
| 786 | |
| 787 | void hdd_ndi_close(uint8_t vdev_id) |
| 788 | { |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 789 | struct hdd_context *hdd_ctx; |
| 790 | struct hdd_adapter *adapter; |
| 791 | |
| 792 | hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
| 793 | if (!hdd_ctx) { |
| 794 | hdd_err("hdd_ctx is null"); |
| 795 | return; |
| 796 | } |
| 797 | |
| 798 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 799 | if (!adapter) { |
| 800 | hdd_err("adapter is null"); |
| 801 | return; |
| 802 | } |
Jeff Johnson | 4f7f7c6 | 2017-10-05 08:53:41 -0700 | [diff] [blame] | 803 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 804 | hdd_close_ndi(adapter); |
| 805 | } |
| 806 | |
| 807 | void hdd_ndi_drv_ndi_delete_rsp_handler(uint8_t vdev_id) |
| 808 | { |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 809 | struct hdd_context *hdd_ctx; |
| 810 | struct hdd_adapter *adapter; |
| 811 | struct hdd_station_ctx *sta_ctx; |
Rajeev Kumar Sirasanagandla | d320ac4 | 2019-11-11 10:49:18 -0800 | [diff] [blame] | 812 | struct qdf_mac_addr bc_mac_addr = QDF_MAC_ADDR_BCAST_INIT; |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 813 | |
| 814 | hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
| 815 | if (!hdd_ctx) { |
| 816 | hdd_err("hdd_ctx is null"); |
| 817 | return; |
| 818 | } |
| 819 | |
| 820 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 821 | if (!adapter) { |
| 822 | hdd_err("adapter is null"); |
| 823 | return; |
| 824 | } |
| 825 | |
| 826 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 827 | if (!sta_ctx) { |
| 828 | hdd_err("sta_ctx is null"); |
| 829 | return; |
| 830 | } |
Naveen Rawat | b7be1ed | 2017-11-16 16:52:08 -0800 | [diff] [blame] | 831 | |
Rajeev Kumar Sirasanagandla | d320ac4 | 2019-11-11 10:49:18 -0800 | [diff] [blame] | 832 | hdd_delete_peer(sta_ctx, &bc_mac_addr); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 833 | |
| 834 | wlan_hdd_netif_queue_control(adapter, |
| 835 | WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, |
| 836 | WLAN_CONTROL_PATH); |
| 837 | |
Abhishek Ambure | 650f992 | 2020-01-10 12:05:49 +0530 | [diff] [blame] | 838 | /* |
| 839 | * For NAN Data interface, the close session results in the final |
| 840 | * indication to the userspace |
| 841 | */ |
| 842 | if (adapter->device_mode == QDF_NDI_MODE) |
| 843 | hdd_ndp_session_end_handler(adapter); |
| 844 | |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 845 | complete(&adapter->disconnect_comp_var); |
| 846 | } |
| 847 | |
Jeff Johnson | 8cb9df1 | 2017-08-29 14:28:45 -0700 | [diff] [blame] | 848 | void hdd_ndp_session_end_handler(struct hdd_adapter *adapter) |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 849 | { |
Dustin Brown | 89fa06e | 2018-09-07 10:47:27 -0700 | [diff] [blame] | 850 | os_if_nan_ndi_session_end(adapter->vdev); |
Naveen Rawat | cb5c540 | 2017-03-22 10:12:19 -0700 | [diff] [blame] | 851 | } |
| 852 | |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 853 | /** |
| 854 | * hdd_ndp_new_peer_handler() - NDP new peer indication handler |
| 855 | * @adapter: pointer to adapter context |
| 856 | * @ind_params: indication parameters |
| 857 | * |
| 858 | * Return: none |
| 859 | */ |
| 860 | int hdd_ndp_new_peer_handler(uint8_t vdev_id, uint16_t sta_id, |
| 861 | struct qdf_mac_addr *peer_mac_addr, bool fist_peer) |
| 862 | { |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 863 | struct hdd_context *hdd_ctx; |
| 864 | struct hdd_adapter *adapter; |
| 865 | struct hdd_station_ctx *sta_ctx; |
Jeff Johnson | 4ba73cb | 2017-10-06 11:12:33 -0700 | [diff] [blame] | 866 | struct bss_description tmp_bss_descp = {0}; |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 867 | struct csr_roam_info *roam_info; |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 868 | |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 869 | hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
| 870 | if (!hdd_ctx) { |
| 871 | hdd_err("hdd_ctx is null"); |
| 872 | return -EINVAL; |
| 873 | } |
| 874 | |
| 875 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 876 | if (!adapter) { |
| 877 | hdd_err("adapter is null"); |
| 878 | return -EINVAL; |
| 879 | } |
| 880 | |
| 881 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 882 | if (!sta_ctx) { |
| 883 | hdd_err("sta_ctx is null"); |
| 884 | return -EINVAL; |
| 885 | } |
| 886 | |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 887 | /* save peer in ndp ctx */ |
Sourav Mohapatra | a3cf12a | 2019-08-19 15:40:49 +0530 | [diff] [blame] | 888 | if (!hdd_save_peer(sta_ctx, peer_mac_addr)) { |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 889 | hdd_err("Ndp peer table full. cannot save new peer"); |
| 890 | return -EPERM; |
| 891 | } |
| 892 | |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 893 | roam_info = qdf_mem_malloc(sizeof(*roam_info)); |
| 894 | if (!roam_info) |
| 895 | return -ENOMEM; |
Wu Gao | cef8a74 | 2019-10-16 20:51:02 +0800 | [diff] [blame] | 896 | qdf_copy_macaddr(&roam_info->bssid, peer_mac_addr); |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 897 | |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 898 | /* this function is called for each new peer */ |
Sourav Mohapatra | a3cf12a | 2019-08-19 15:40:49 +0530 | [diff] [blame] | 899 | hdd_roam_register_sta(adapter, roam_info, &tmp_bss_descp); |
| 900 | |
| 901 | qdf_copy_macaddr(&roam_info->bssid, peer_mac_addr); |
| 902 | |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 903 | /* perform following steps for first new peer ind */ |
| 904 | if (fist_peer) { |
Srinivas Dasari | e189846 | 2020-03-16 18:33:29 +0530 | [diff] [blame] | 905 | hdd_debug("Set ctx connection state to connected"); |
Karthik Kantamneni | 3d1f2a8 | 2020-12-02 20:30:08 +0530 | [diff] [blame] | 906 | /* Disable LRO/GRO for NDI Mode */ |
| 907 | if (hdd_ctx->ol_enable && |
| 908 | !ucfg_is_nan_dbs_supported(hdd_ctx->psoc)) { |
| 909 | hdd_debug("Disable LRO/GRO in NDI Mode"); |
| 910 | hdd_disable_rx_ol_in_concurrency(true); |
| 911 | } |
| 912 | |
Sravan Kumar Kairam | 777a7dd | 2019-08-01 21:46:30 +0530 | [diff] [blame] | 913 | hdd_bus_bw_compute_prev_txrx_stats(adapter); |
| 914 | hdd_bus_bw_compute_timer_start(hdd_ctx); |
Jeff Johnson | e795151 | 2019-02-27 10:02:51 -0800 | [diff] [blame] | 915 | sta_ctx->conn_info.conn_state = eConnectionState_NdiConnected; |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 916 | hdd_wmm_connect(adapter, roam_info, eCSR_BSS_TYPE_NDI); |
Jinwei Chen | 08260c6 | 2020-09-01 10:52:48 +0800 | [diff] [blame] | 917 | wlan_hdd_netif_queue_control( |
| 918 | adapter, |
| 919 | WLAN_START_ALL_NETIF_QUEUE_N_CARRIER, |
| 920 | WLAN_CONTROL_PATH); |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 921 | } |
Min Liu | 3621ede | 2018-11-07 18:36:00 +0800 | [diff] [blame] | 922 | qdf_mem_free(roam_info); |
Naveen Rawat | 37f62c8 | 2017-03-26 22:24:43 -0700 | [diff] [blame] | 923 | return 0; |
| 924 | } |
| 925 | |
Srinivas Dasari | 2b42461 | 2020-03-04 17:55:16 +0530 | [diff] [blame] | 926 | void hdd_cleanup_ndi(struct hdd_context *hdd_ctx, |
| 927 | struct hdd_adapter *adapter) |
| 928 | { |
| 929 | struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 930 | |
| 931 | if (sta_ctx->conn_info.conn_state != eConnectionState_NdiConnected) { |
| 932 | hdd_debug("NDI has no NDPs"); |
| 933 | return; |
| 934 | } |
| 935 | sta_ctx->conn_info.conn_state = eConnectionState_NdiDisconnected; |
| 936 | hdd_conn_set_connection_state(adapter, |
| 937 | eConnectionState_NdiDisconnected); |
Srinivas Dasari | e189846 | 2020-03-16 18:33:29 +0530 | [diff] [blame] | 938 | hdd_debug("Stop netif tx queues."); |
Jinwei Chen | 08260c6 | 2020-09-01 10:52:48 +0800 | [diff] [blame] | 939 | wlan_hdd_netif_queue_control(adapter, |
| 940 | WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, |
Srinivas Dasari | 2b42461 | 2020-03-04 17:55:16 +0530 | [diff] [blame] | 941 | WLAN_CONTROL_PATH); |
| 942 | hdd_bus_bw_compute_reset_prev_txrx_stats(adapter); |
| 943 | hdd_bus_bw_compute_timer_try_stop(hdd_ctx); |
Karthik Kantamneni | 3d1f2a8 | 2020-12-02 20:30:08 +0530 | [diff] [blame] | 944 | if ((hdd_ctx->ol_enable && |
| 945 | !ucfg_is_nan_dbs_supported(hdd_ctx->psoc)) && |
| 946 | ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 0) || |
| 947 | ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 1) && |
| 948 | (policy_mgr_mode_specific_connection_count( |
| 949 | hdd_ctx->psoc, |
| 950 | PM_STA_MODE, |
| 951 | NULL) == 1)))) { |
| 952 | hdd_debug("Enable LRO/GRO"); |
| 953 | hdd_disable_rx_ol_in_concurrency(false); |
| 954 | } |
Srinivas Dasari | 2b42461 | 2020-03-04 17:55:16 +0530 | [diff] [blame] | 955 | } |
| 956 | |
Naveen Rawat | b3143ea | 2017-03-26 22:25:46 -0700 | [diff] [blame] | 957 | /** |
| 958 | * hdd_ndp_peer_departed_handler() - Handle NDP peer departed indication |
| 959 | * @adapter: pointer to adapter context |
| 960 | * @ind_params: indication parameters |
| 961 | * |
| 962 | * Return: none |
| 963 | */ |
| 964 | void hdd_ndp_peer_departed_handler(uint8_t vdev_id, uint16_t sta_id, |
| 965 | struct qdf_mac_addr *peer_mac_addr, bool last_peer) |
| 966 | { |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 967 | struct hdd_context *hdd_ctx; |
| 968 | struct hdd_adapter *adapter; |
| 969 | struct hdd_station_ctx *sta_ctx; |
Naveen Rawat | b3143ea | 2017-03-26 22:25:46 -0700 | [diff] [blame] | 970 | |
Naveen Rawat | f939162 | 2017-12-20 17:06:01 -0800 | [diff] [blame] | 971 | hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD); |
| 972 | if (!hdd_ctx) { |
| 973 | hdd_err("hdd_ctx is null"); |
| 974 | return; |
| 975 | } |
| 976 | |
| 977 | adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id); |
| 978 | if (!adapter) { |
| 979 | hdd_err("adapter is null"); |
| 980 | return; |
| 981 | } |
| 982 | |
| 983 | sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); |
| 984 | if (!sta_ctx) { |
| 985 | hdd_err("sta_ctx is null"); |
| 986 | return; |
| 987 | } |
| 988 | |
Rajeev Kumar Sirasanagandla | d320ac4 | 2019-11-11 10:49:18 -0800 | [diff] [blame] | 989 | hdd_delete_peer(sta_ctx, peer_mac_addr); |
Naveen Rawat | b3143ea | 2017-03-26 22:25:46 -0700 | [diff] [blame] | 990 | |
| 991 | if (last_peer) { |
Srinivas Dasari | e189846 | 2020-03-16 18:33:29 +0530 | [diff] [blame] | 992 | hdd_debug("No more ndp peers."); |
Srinivas Dasari | 2b42461 | 2020-03-04 17:55:16 +0530 | [diff] [blame] | 993 | hdd_cleanup_ndi(hdd_ctx, adapter); |
Srinivas Dasari | 766d202 | 2020-04-21 20:06:14 +0530 | [diff] [blame] | 994 | qdf_event_set(&adapter->peer_cleanup_done); |
Naveen Rawat | b3143ea | 2017-03-26 22:25:46 -0700 | [diff] [blame] | 995 | } |
Naveen Rawat | b3143ea | 2017-03-26 22:25:46 -0700 | [diff] [blame] | 996 | } |