1 /* 2 * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /** 21 * DOC: wlan_tdls_ucfg_api.c 22 * 23 * TDLS north bound interface definitions 24 */ 25 26 #include <wlan_tdls_ucfg_api.h> 27 #include <wlan_tdls_tgt_api.h> 28 #include "../../core/src/wlan_tdls_main.h" 29 #include "../../core/src/wlan_tdls_cmds_process.h" 30 #include "../../core/src/wlan_tdls_ct.h" 31 #include "../../core/src/wlan_tdls_mgmt.h" 32 #include <wlan_objmgr_global_obj.h> 33 #include <wlan_objmgr_cmn.h> 34 #include "wlan_policy_mgr_api.h" 35 #include "wlan_scan_ucfg_api.h" 36 #include "cfg_tdls.h" 37 #include "wlan_mlo_mgr_sta.h" 38 #include "cfg_ucfg_api.h" 39 #include "wlan_tdls_api.h" 40 ucfg_tdls_init(void)41 QDF_STATUS ucfg_tdls_init(void) 42 { 43 QDF_STATUS status; 44 45 tdls_notice("tdls module dispatcher init"); 46 status = wlan_objmgr_register_psoc_create_handler(WLAN_UMAC_COMP_TDLS, 47 tdls_psoc_obj_create_notification, NULL); 48 49 if (QDF_IS_STATUS_ERROR(status)) { 50 tdls_err("Failed to register psoc create handler for tdls"); 51 return status; 52 } 53 54 status = wlan_objmgr_register_psoc_destroy_handler(WLAN_UMAC_COMP_TDLS, 55 tdls_psoc_obj_destroy_notification, NULL); 56 57 if (QDF_IS_STATUS_ERROR(status)) { 58 tdls_err("Failed to register psoc delete handler for tdls"); 59 goto fail_delete_psoc; 60 } 61 62 status = wlan_objmgr_register_vdev_create_handler(WLAN_UMAC_COMP_TDLS, 63 tdls_vdev_obj_create_notification, NULL); 64 65 if (QDF_IS_STATUS_ERROR(status)) { 66 tdls_err("Failed to register vdev create handler for tdls"); 67 goto fail_create_vdev; 68 } 69 70 status = wlan_objmgr_register_vdev_destroy_handler(WLAN_UMAC_COMP_TDLS, 71 tdls_vdev_obj_destroy_notification, NULL); 72 73 if (QDF_IS_STATUS_ERROR(status)) { 74 tdls_err("Failed to register vdev create handler for tdls"); 75 goto fail_delete_vdev; 76 } 77 tdls_notice("tdls module dispatcher init done"); 78 79 return status; 80 fail_delete_vdev: 81 wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_TDLS, 82 tdls_vdev_obj_create_notification, NULL); 83 84 fail_create_vdev: 85 wlan_objmgr_unregister_psoc_destroy_handler(WLAN_UMAC_COMP_TDLS, 86 tdls_psoc_obj_destroy_notification, NULL); 87 88 fail_delete_psoc: 89 wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_TDLS, 90 tdls_psoc_obj_create_notification, NULL); 91 92 return status; 93 } 94 ucfg_tdls_deinit(void)95 QDF_STATUS ucfg_tdls_deinit(void) 96 { 97 QDF_STATUS ret; 98 99 tdls_notice("tdls module dispatcher deinit"); 100 ret = wlan_objmgr_unregister_psoc_create_handler(WLAN_UMAC_COMP_TDLS, 101 tdls_psoc_obj_create_notification, NULL); 102 if (QDF_IS_STATUS_ERROR(ret)) 103 tdls_err("Failed to unregister psoc create handler"); 104 105 ret = wlan_objmgr_unregister_psoc_destroy_handler(WLAN_UMAC_COMP_TDLS, 106 tdls_psoc_obj_destroy_notification, NULL); 107 if (QDF_IS_STATUS_ERROR(ret)) 108 tdls_err("Failed to unregister psoc delete handler"); 109 110 ret = wlan_objmgr_unregister_vdev_create_handler(WLAN_UMAC_COMP_TDLS, 111 tdls_vdev_obj_create_notification, NULL); 112 if (QDF_IS_STATUS_ERROR(ret)) 113 tdls_err("Failed to unregister vdev create handler"); 114 115 ret = wlan_objmgr_unregister_vdev_destroy_handler(WLAN_UMAC_COMP_TDLS, 116 tdls_vdev_obj_destroy_notification, NULL); 117 118 if (QDF_IS_STATUS_ERROR(ret)) 119 tdls_err("Failed to unregister vdev delete handler"); 120 121 return ret; 122 } 123 124 /** 125 * tdls_update_feature_flag() - update tdls feature flag 126 * @tdls_soc_obj: pointer to tdls psoc object 127 * 128 * This function updates tdls feature flag 129 */ 130 static void tdls_update_feature_flag(struct tdls_soc_priv_obj * tdls_soc_obj)131 tdls_update_feature_flag(struct tdls_soc_priv_obj *tdls_soc_obj) 132 { 133 tdls_soc_obj->tdls_configs.tdls_feature_flags = 134 ((tdls_soc_obj->tdls_configs.tdls_off_chan_enable ? 135 1 << TDLS_FEATURE_OFF_CHANNEL : 0) | 136 (tdls_soc_obj->tdls_configs.tdls_wmm_mode_enable ? 137 1 << TDLS_FEATURE_WMM : 0) | 138 (tdls_soc_obj->tdls_configs.tdls_buffer_sta_enable ? 139 1 << TDLS_FEATURE_BUFFER_STA : 0) | 140 (tdls_soc_obj->tdls_configs.tdls_sleep_sta_enable ? 141 1 << TDLS_FEATURE_SLEEP_STA : 0) | 142 (tdls_soc_obj->tdls_configs.tdls_scan_enable ? 143 1 << TDLS_FEATURE_SCAN : 0) | 144 (tdls_soc_obj->tdls_configs.tdls_support_enable ? 145 1 << TDLS_FEATURE_ENABLE : 0) | 146 (tdls_soc_obj->tdls_configs.tdls_implicit_trigger_enable ? 147 1 << TDLS_FEAUTRE_IMPLICIT_TRIGGER : 0) | 148 (tdls_soc_obj->tdls_configs.tdls_external_control & 149 TDLS_STRICT_EXTERNAL_CONTROL ? 150 1 << TDLS_FEATURE_EXTERNAL_CONTROL : 0) | 151 (tdls_soc_obj->tdls_configs.tdls_external_control & 152 TDLS_LIBERAL_EXTERNAL_CONTROL ? 153 1 << TDLS_FEATURE_LIBERAL_EXTERNAL_CONTROL : 0)); 154 } 155 156 /** 157 * tdls_object_init_params() - init parameters for tdls object 158 * @tdls_soc_obj: pointer to tdls psoc object 159 * 160 * This function init parameters for tdls object 161 */ tdls_object_init_params(struct tdls_soc_priv_obj * tdls_soc_obj)162 static QDF_STATUS tdls_object_init_params( 163 struct tdls_soc_priv_obj *tdls_soc_obj) 164 { 165 struct wlan_objmgr_psoc *psoc; 166 167 if (!tdls_soc_obj) { 168 tdls_err("invalid param"); 169 return QDF_STATUS_E_INVAL; 170 } 171 172 psoc = tdls_soc_obj->soc; 173 if (!psoc) { 174 tdls_err("invalid psoc object"); 175 return QDF_STATUS_E_INVAL; 176 } 177 178 tdls_soc_obj->tdls_configs.tdls_tx_states_period = 179 cfg_get(psoc, CFG_TDLS_TX_STATS_PERIOD); 180 tdls_soc_obj->tdls_configs.tdls_tx_pkt_threshold = 181 cfg_get(psoc, CFG_TDLS_TX_PACKET_THRESHOLD); 182 tdls_soc_obj->tdls_configs.tdls_rx_pkt_threshold = 183 cfg_get(psoc, CFG_TDLS_RX_FRAME_THRESHOLD); 184 tdls_soc_obj->tdls_configs.tdls_max_discovery_attempt = 185 cfg_get(psoc, CFG_TDLS_MAX_DISCOVERY_ATTEMPT); 186 tdls_soc_obj->tdls_configs.tdls_idle_timeout = 187 cfg_get(psoc, CFG_TDLS_IDLE_TIMEOUT); 188 tdls_soc_obj->tdls_configs.tdls_idle_pkt_threshold = 189 cfg_get(psoc, CFG_TDLS_IDLE_PACKET_THRESHOLD); 190 tdls_soc_obj->tdls_configs.tdls_rssi_trigger_threshold = 191 cfg_get(psoc, CFG_TDLS_RSSI_TRIGGER_THRESHOLD); 192 tdls_soc_obj->tdls_configs.tdls_rssi_teardown_threshold = 193 cfg_get(psoc, CFG_TDLS_RSSI_TEARDOWN_THRESHOLD); 194 tdls_soc_obj->tdls_configs.tdls_rssi_delta = 195 cfg_get(psoc, CFG_TDLS_RSSI_DELTA); 196 tdls_soc_obj->tdls_configs.tdls_uapsd_mask = 197 cfg_get(psoc, CFG_TDLS_QOS_WMM_UAPSD_MASK); 198 tdls_soc_obj->tdls_configs.tdls_uapsd_inactivity_time = 199 cfg_get(psoc, CFG_TDLS_PUAPSD_INACT_TIME); 200 tdls_soc_obj->tdls_configs.tdls_uapsd_pti_window = 201 cfg_get(psoc, CFG_TDLS_PUAPSD_PEER_TRAFFIC_IND_WINDOW); 202 tdls_soc_obj->tdls_configs.tdls_uapsd_ptr_timeout = 203 cfg_get(psoc, CFG_TDLS_PUAPSD_PEER_TRAFFIC_RSP_TIMEOUT); 204 tdls_soc_obj->tdls_configs.tdls_pre_off_chan_num = 205 cfg_get(psoc, CFG_TDLS_PREFERRED_OFF_CHANNEL_NUM); 206 tdls_soc_obj->tdls_configs.tdls_pre_off_chan_freq_6g = 207 cfg_get(psoc, CFG_TDLS_PREFERRED_OFF_CHANNEL_FREQ_6G); 208 tdls_soc_obj->tdls_configs.tdls_pre_off_chan_bw = 209 cfg_get(psoc, CFG_TDLS_PREFERRED_OFF_CHANNEL_BW); 210 tdls_soc_obj->tdls_configs.tdls_peer_kickout_threshold = 211 cfg_get(psoc, CFG_TDLS_PEER_KICKOUT_THRESHOLD); 212 tdls_soc_obj->tdls_configs.tdls_discovery_wake_timeout = 213 cfg_get(psoc, CFG_TDLS_DISCOVERY_WAKE_TIMEOUT); 214 tdls_soc_obj->tdls_configs.delayed_trig_framint = 215 cfg_get(psoc, CFG_TL_DELAYED_TRGR_FRM_INTERVAL); 216 tdls_soc_obj->tdls_configs.tdls_wmm_mode_enable = 217 cfg_get(psoc, CFG_TDLS_WMM_MODE_ENABLE); 218 tdls_soc_obj->tdls_configs.tdls_off_chan_enable = 219 cfg_get(psoc, CFG_TDLS_OFF_CHANNEL_ENABLED); 220 tdls_soc_obj->tdls_configs.tdls_buffer_sta_enable = 221 cfg_get(psoc, CFG_TDLS_BUF_STA_ENABLED); 222 tdls_soc_obj->tdls_configs.tdls_scan_enable = 223 cfg_get(psoc, CFG_TDLS_SCAN_ENABLE); 224 tdls_soc_obj->tdls_configs.tdls_support_enable = 225 cfg_get(psoc, CFG_TDLS_SUPPORT_ENABLE); 226 tdls_soc_obj->tdls_configs.tdls_implicit_trigger_enable = 227 cfg_get(psoc, CFG_TDLS_IMPLICIT_TRIGGER); 228 tdls_soc_obj->tdls_configs.tdls_external_control = 229 cfg_get(psoc, CFG_TDLS_EXTERNAL_CONTROL); 230 tdls_soc_obj->max_num_tdls_sta = 231 cfg_get(psoc, CFG_TDLS_MAX_PEER_COUNT); 232 233 tdls_update_feature_flag(tdls_soc_obj); 234 235 return QDF_STATUS_SUCCESS; 236 } 237 238 #ifdef TDLS_WOW_ENABLED 239 /** 240 * tdls_wow_init() - Create/init wake lock for TDLS 241 * @soc_obj: TDLS private soc object 242 * 243 * Create/init wake lock for TDLS if DVR isn't supported 244 * 245 * Return None 246 */ tdls_wow_init(struct tdls_soc_priv_obj * soc_obj)247 static void tdls_wow_init(struct tdls_soc_priv_obj *soc_obj) 248 { 249 soc_obj->is_prevent_suspend = false; 250 soc_obj->is_drv_supported = qdf_is_drv_supported(); 251 if (!soc_obj->is_drv_supported) { 252 qdf_wake_lock_create(&soc_obj->wake_lock, "wlan_tdls"); 253 qdf_runtime_lock_init(&soc_obj->runtime_lock); 254 } 255 } 256 257 /** 258 * tdls_wow_deinit() - Destroy/deinit wake lock for TDLS 259 * @soc_obj: TDLS private soc object 260 * 261 * Destroy/deinit wake lock for TDLS if DVR isn't supported 262 * 263 * Return None 264 */ tdls_wow_deinit(struct tdls_soc_priv_obj * soc_obj)265 static void tdls_wow_deinit(struct tdls_soc_priv_obj *soc_obj) 266 { 267 if (!soc_obj->is_drv_supported) { 268 qdf_runtime_lock_deinit(&soc_obj->runtime_lock); 269 qdf_wake_lock_destroy(&soc_obj->wake_lock); 270 } 271 } 272 #else tdls_wow_init(struct tdls_soc_priv_obj * soc_obj)273 static void tdls_wow_init(struct tdls_soc_priv_obj *soc_obj) 274 { 275 } 276 tdls_wow_deinit(struct tdls_soc_priv_obj * soc_obj)277 static void tdls_wow_deinit(struct tdls_soc_priv_obj *soc_obj) 278 { 279 } 280 #endif 281 tdls_global_init(struct tdls_soc_priv_obj * soc_obj)282 static QDF_STATUS tdls_global_init(struct tdls_soc_priv_obj *soc_obj) 283 { 284 tdls_object_init_params(soc_obj); 285 soc_obj->connected_peer_count = 0; 286 soc_obj->tdls_nss_switch_in_progress = false; 287 soc_obj->tdls_teardown_peers_cnt = 0; 288 soc_obj->tdls_nss_teardown_complete = false; 289 soc_obj->tdls_nss_transition_mode = TDLS_NSS_TRANSITION_S_UNKNOWN; 290 soc_obj->enable_tdls_connection_tracker = false; 291 soc_obj->tdls_external_peer_count = 0; 292 soc_obj->is_user_tdls_enable = true; 293 294 qdf_spinlock_create(&soc_obj->tdls_ct_spinlock); 295 tdls_wow_init(soc_obj); 296 297 return QDF_STATUS_SUCCESS; 298 } 299 tdls_global_deinit(struct tdls_soc_priv_obj * soc_obj)300 static QDF_STATUS tdls_global_deinit(struct tdls_soc_priv_obj *soc_obj) 301 { 302 tdls_wow_deinit(soc_obj); 303 qdf_spinlock_destroy(&soc_obj->tdls_ct_spinlock); 304 305 return QDF_STATUS_SUCCESS; 306 } 307 ucfg_tdls_psoc_open(struct wlan_objmgr_psoc * psoc)308 QDF_STATUS ucfg_tdls_psoc_open(struct wlan_objmgr_psoc *psoc) 309 { 310 QDF_STATUS status; 311 struct tdls_soc_priv_obj *soc_obj; 312 313 tdls_debug("tdls psoc open"); 314 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 315 WLAN_UMAC_COMP_TDLS); 316 if (!soc_obj) { 317 tdls_err("Failed to get tdls psoc component"); 318 return QDF_STATUS_E_FAILURE; 319 } 320 321 status = tdls_global_init(soc_obj); 322 323 return status; 324 } 325 ucfg_tdls_update_fw_wideband_capability(struct wlan_objmgr_psoc * psoc,bool is_fw_tdls_wideband_capable)326 void ucfg_tdls_update_fw_wideband_capability(struct wlan_objmgr_psoc *psoc, 327 bool is_fw_tdls_wideband_capable) 328 { 329 struct tdls_soc_priv_obj *soc_obj; 330 331 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 332 WLAN_UMAC_COMP_TDLS); 333 if (!soc_obj) { 334 tdls_err("Failed to get tdls psoc component"); 335 return; 336 } 337 338 soc_obj->fw_tdls_wideband_capability = is_fw_tdls_wideband_capable; 339 } 340 ucfg_tdls_is_fw_wideband_capable(struct wlan_objmgr_psoc * psoc)341 bool ucfg_tdls_is_fw_wideband_capable(struct wlan_objmgr_psoc *psoc) 342 { 343 struct tdls_soc_priv_obj *soc_obj; 344 345 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 346 WLAN_UMAC_COMP_TDLS); 347 if (!soc_obj) { 348 tdls_err("Failed to get tdls psoc component"); 349 return false; 350 } 351 352 tdls_debug("FW wideband capability %d", 353 soc_obj->fw_tdls_wideband_capability); 354 355 return soc_obj->fw_tdls_wideband_capability; 356 } 357 358 #ifdef WLAN_FEATURE_11BE ucfg_tdls_update_fw_mlo_capability(struct wlan_objmgr_psoc * psoc,bool is_fw_tdls_mlo_capable)359 void ucfg_tdls_update_fw_mlo_capability(struct wlan_objmgr_psoc *psoc, 360 bool is_fw_tdls_mlo_capable) 361 { 362 struct tdls_soc_priv_obj *soc_obj; 363 364 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 365 WLAN_UMAC_COMP_TDLS); 366 if (!soc_obj) { 367 tdls_err("Failed to get tdls psoc component"); 368 return; 369 } 370 371 soc_obj->fw_tdls_mlo_capable = is_fw_tdls_mlo_capable; 372 } 373 #endif 374 375 #ifdef WLAN_FEATURE_11AX ucfg_tdls_update_fw_11ax_capability(struct wlan_objmgr_psoc * psoc,bool is_fw_tdls_11ax_capable)376 void ucfg_tdls_update_fw_11ax_capability(struct wlan_objmgr_psoc *psoc, 377 bool is_fw_tdls_11ax_capable) 378 { 379 struct tdls_soc_priv_obj *soc_obj; 380 381 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 382 WLAN_UMAC_COMP_TDLS); 383 if (!soc_obj) { 384 tdls_err("Failed to get tdls psoc component"); 385 return; 386 } 387 388 soc_obj->fw_tdls_11ax_capability = is_fw_tdls_11ax_capable; 389 } 390 ucfg_update_fw_tdls_6g_capability(struct wlan_objmgr_psoc * psoc,bool is_fw_tdls_6g_capable)391 void ucfg_update_fw_tdls_6g_capability(struct wlan_objmgr_psoc *psoc, 392 bool is_fw_tdls_6g_capable) 393 { 394 struct tdls_soc_priv_obj *soc_obj; 395 396 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 397 WLAN_UMAC_COMP_TDLS); 398 if (!soc_obj) { 399 tdls_err("Failed to get tdls psoc component"); 400 return; 401 } 402 403 soc_obj->fw_tdls_6g_capability = is_fw_tdls_6g_capable; 404 } 405 ucfg_tdls_is_fw_11ax_capable(struct wlan_objmgr_psoc * psoc)406 bool ucfg_tdls_is_fw_11ax_capable(struct wlan_objmgr_psoc *psoc) 407 { 408 struct tdls_soc_priv_obj *soc_obj; 409 410 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 411 WLAN_UMAC_COMP_TDLS); 412 if (!soc_obj) { 413 tdls_err("Failed to get tdls psoc component"); 414 return false; 415 } 416 tdls_debug("FW 11AX capability %d", soc_obj->fw_tdls_11ax_capability); 417 418 return soc_obj->fw_tdls_11ax_capability; 419 } 420 ucfg_tdls_is_fw_6g_capable(struct wlan_objmgr_psoc * psoc)421 bool ucfg_tdls_is_fw_6g_capable(struct wlan_objmgr_psoc *psoc) 422 { 423 struct tdls_soc_priv_obj *soc_obj; 424 425 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 426 WLAN_UMAC_COMP_TDLS); 427 if (!soc_obj) { 428 tdls_err("Failed to get tdls psoc component"); 429 return false; 430 } 431 tdls_debug("FW 6g capability %d", soc_obj->fw_tdls_6g_capability); 432 433 return soc_obj->fw_tdls_6g_capability; 434 } 435 #endif 436 ucfg_tdls_update_config(struct wlan_objmgr_psoc * psoc,struct tdls_start_params * req)437 QDF_STATUS ucfg_tdls_update_config(struct wlan_objmgr_psoc *psoc, 438 struct tdls_start_params *req) 439 { 440 struct tdls_soc_priv_obj *soc_obj; 441 uint32_t tdls_feature_flags; 442 struct policy_mgr_tdls_cbacks tdls_pm_call_backs; 443 uint8_t sta_idx; 444 445 tdls_debug("tdls update config "); 446 if (!psoc || !req) { 447 tdls_err("psoc: 0x%pK, req: 0x%pK", psoc, req); 448 return QDF_STATUS_E_FAILURE; 449 } 450 451 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 452 WLAN_UMAC_COMP_TDLS); 453 if (!soc_obj) { 454 tdls_err("Failed to get tdls psoc component"); 455 return QDF_STATUS_E_FAILURE; 456 } 457 458 soc_obj->tdls_rx_cb = req->tdls_rx_cb; 459 soc_obj->tdls_rx_cb_data = req->tdls_rx_cb_data; 460 461 soc_obj->tdls_wmm_cb = req->tdls_wmm_cb; 462 soc_obj->tdls_wmm_cb_data = req->tdls_wmm_cb_data; 463 464 soc_obj->tdls_event_cb = req->tdls_event_cb; 465 soc_obj->tdls_evt_cb_data = req->tdls_evt_cb_data; 466 467 /* Save callbacks to register/deregister TDLS sta with datapath */ 468 soc_obj->tdls_reg_peer = req->tdls_reg_peer; 469 soc_obj->tdls_peer_context = req->tdls_peer_context; 470 471 /* Save legacy PE/WMA commands in TDLS soc object */ 472 soc_obj->tdls_send_mgmt_req = req->tdls_send_mgmt_req; 473 soc_obj->tdls_add_sta_req = req->tdls_add_sta_req; 474 soc_obj->tdls_del_sta_req = req->tdls_del_sta_req; 475 soc_obj->tdls_update_peer_state = req->tdls_update_peer_state; 476 soc_obj->tdls_del_all_peers = req->tdls_del_all_peers; 477 soc_obj->tdls_update_dp_vdev_flags = req->tdls_update_dp_vdev_flags; 478 soc_obj->tdls_dp_vdev_update = req->tdls_dp_vdev_update; 479 soc_obj->tdls_osif_init_cb = req->tdls_osif_init_cb; 480 soc_obj->tdls_osif_deinit_cb = req->tdls_osif_deinit_cb; 481 soc_obj->tdls_osif_update_cb.tdls_osif_conn_update = 482 req->tdls_osif_update_cb.tdls_osif_conn_update; 483 soc_obj->tdls_osif_update_cb.tdls_osif_disconn_update = 484 req->tdls_osif_update_cb.tdls_osif_disconn_update; 485 tdls_pm_call_backs.tdls_notify_increment_session = 486 tdls_notify_increment_session; 487 488 tdls_pm_call_backs.tdls_notify_decrement_session = 489 tdls_notify_decrement_session; 490 if (QDF_STATUS_SUCCESS != policy_mgr_register_tdls_cb( 491 psoc, &tdls_pm_call_backs)) { 492 tdls_err("policy manager callback registration failed "); 493 return QDF_STATUS_E_FAILURE; 494 } 495 496 tdls_update_feature_flag(soc_obj); 497 tdls_feature_flags = soc_obj->tdls_configs.tdls_feature_flags; 498 499 if (!TDLS_IS_IMPLICIT_TRIG_ENABLED(tdls_feature_flags)) 500 soc_obj->tdls_current_mode = TDLS_SUPPORT_EXP_TRIG_ONLY; 501 else if (TDLS_IS_EXTERNAL_CONTROL_ENABLED(tdls_feature_flags)) 502 soc_obj->tdls_current_mode = TDLS_SUPPORT_EXT_CONTROL; 503 else 504 soc_obj->tdls_current_mode = TDLS_SUPPORT_IMP_MODE; 505 506 soc_obj->tdls_last_mode = soc_obj->tdls_current_mode; 507 if (TDLS_IS_BUFFER_STA_ENABLED(tdls_feature_flags) || 508 TDLS_IS_SLEEP_STA_ENABLED(tdls_feature_flags)) 509 soc_obj->max_num_tdls_sta = 510 WLAN_TDLS_STA_P_UAPSD_OFFCHAN_MAX_NUM; 511 512 for (sta_idx = 0; sta_idx < soc_obj->max_num_tdls_sta; sta_idx++) { 513 soc_obj->tdls_conn_info[sta_idx].valid_entry = false; 514 soc_obj->tdls_conn_info[sta_idx].index = 515 INVALID_TDLS_PEER_INDEX; 516 soc_obj->tdls_conn_info[sta_idx].session_id = 255; 517 qdf_mem_zero(&soc_obj->tdls_conn_info[sta_idx].peer_mac, 518 QDF_MAC_ADDR_SIZE); 519 } 520 return QDF_STATUS_SUCCESS; 521 } 522 ucfg_tdls_link_vdev_is_matching(struct wlan_objmgr_vdev * vdev)523 bool ucfg_tdls_link_vdev_is_matching(struct wlan_objmgr_vdev *vdev) 524 { 525 struct wlan_objmgr_vdev *tdls_link_vdev; 526 527 tdls_link_vdev = tdls_mlo_get_tdls_link_vdev(vdev); 528 if (!tdls_link_vdev) { 529 wlan_vdev_mlme_feat_ext2_cap_set(vdev, 530 WLAN_VDEV_FEXT2_MLO_STA_TDLS); 531 tdls_set_remain_links_unforce(vdev); 532 return true; 533 } 534 535 if (tdls_link_vdev && tdls_link_vdev != vdev) { 536 tdls_debug("tdls vdev has been created on vdev %d", 537 wlan_vdev_get_id(tdls_link_vdev)); 538 return false; 539 } 540 541 return true; 542 } 543 544 struct wlan_objmgr_vdev * ucfg_tdls_get_tdls_link_vdev(struct wlan_objmgr_vdev * vdev,wlan_objmgr_ref_dbgid dbg_id)545 ucfg_tdls_get_tdls_link_vdev(struct wlan_objmgr_vdev *vdev, 546 wlan_objmgr_ref_dbgid dbg_id) 547 { 548 struct wlan_objmgr_vdev *link_vdev; 549 550 link_vdev = tdls_mlo_get_tdls_link_vdev(vdev); 551 if (!link_vdev) 552 return NULL; 553 554 if (wlan_objmgr_vdev_try_get_ref(link_vdev, dbg_id) != 555 QDF_STATUS_SUCCESS) 556 return NULL; 557 558 return link_vdev; 559 } 560 ucfg_tdls_put_tdls_link_vdev(struct wlan_objmgr_vdev * vdev,wlan_objmgr_ref_dbgid dbg_id)561 void ucfg_tdls_put_tdls_link_vdev(struct wlan_objmgr_vdev *vdev, 562 wlan_objmgr_ref_dbgid dbg_id) 563 { 564 wlan_objmgr_vdev_release_ref(vdev, dbg_id); 565 } 566 ucfg_tdls_psoc_enable(struct wlan_objmgr_psoc * psoc)567 QDF_STATUS ucfg_tdls_psoc_enable(struct wlan_objmgr_psoc *psoc) 568 { 569 QDF_STATUS status; 570 571 tdls_debug("psoc tdls enable: 0x%pK", psoc); 572 if (!psoc) { 573 tdls_err("NULL psoc"); 574 return QDF_STATUS_E_FAILURE; 575 } 576 577 status = tgt_tdls_register_ev_handler(psoc); 578 579 if (status != QDF_STATUS_SUCCESS) 580 return status; 581 582 status = wlan_serialization_register_comp_info_cb(psoc, 583 WLAN_UMAC_COMP_TDLS, 584 WLAN_SER_CMD_SCAN, 585 tdls_scan_serialization_comp_info_cb); 586 if (QDF_STATUS_SUCCESS != status) { 587 tdls_err("Serialize scan cmd register failed "); 588 return status; 589 } 590 591 /* register callbacks with tx/rx mgmt */ 592 status = tdls_mgmt_rx_ops(psoc, true); 593 if (status != QDF_STATUS_SUCCESS) 594 tdls_err("Failed to register mgmt rx callback, status:%d", 595 status); 596 return status; 597 } 598 ucfg_tdls_psoc_disable(struct wlan_objmgr_psoc * psoc)599 QDF_STATUS ucfg_tdls_psoc_disable(struct wlan_objmgr_psoc *psoc) 600 { 601 QDF_STATUS status; 602 struct tdls_soc_priv_obj *soc_obj = NULL; 603 604 tdls_debug("psoc tdls disable: 0x%pK", psoc); 605 if (!psoc) { 606 tdls_err("NULL psoc"); 607 return QDF_STATUS_E_FAILURE; 608 } 609 610 status = tgt_tdls_unregister_ev_handler(psoc); 611 if (QDF_IS_STATUS_ERROR(status)) 612 tdls_err("Failed to unregister tdls event handler"); 613 614 status = tdls_mgmt_rx_ops(psoc, false); 615 if (QDF_IS_STATUS_ERROR(status)) 616 tdls_err("Failed to unregister mgmt rx callback"); 617 618 soc_obj = wlan_objmgr_psoc_get_comp_private_obj(psoc, 619 WLAN_UMAC_COMP_TDLS); 620 if (!soc_obj) { 621 tdls_err("Failed to get tdls psoc component"); 622 return QDF_STATUS_E_FAILURE; 623 } 624 625 soc_obj->tdls_event_cb = NULL; 626 soc_obj->tdls_evt_cb_data = NULL; 627 628 return status; 629 } 630 ucfg_tdls_psoc_close(struct wlan_objmgr_psoc * psoc)631 QDF_STATUS ucfg_tdls_psoc_close(struct wlan_objmgr_psoc *psoc) 632 { 633 QDF_STATUS status = QDF_STATUS_SUCCESS; 634 struct tdls_soc_priv_obj *tdls_soc; 635 636 tdls_debug("tdls psoc close"); 637 tdls_soc = wlan_objmgr_psoc_get_comp_private_obj(psoc, 638 WLAN_UMAC_COMP_TDLS); 639 if (!tdls_soc) { 640 tdls_err("Failed to get tdls psoc component"); 641 return QDF_STATUS_E_FAILURE; 642 } 643 644 status = tdls_global_deinit(tdls_soc); 645 646 return status; 647 } 648 ucfg_tdls_post_msg_flush_cb(struct scheduler_msg * msg)649 static QDF_STATUS ucfg_tdls_post_msg_flush_cb(struct scheduler_msg *msg) 650 { 651 void *ptr = msg->bodyptr; 652 struct wlan_objmgr_vdev *vdev = NULL; 653 654 switch (msg->type) { 655 case TDLS_NOTIFY_RESET_ADAPTERS: 656 ptr = NULL; 657 break; 658 case TDLS_CMD_SET_TDLS_MODE: 659 vdev = ((struct tdls_set_mode_params *)ptr)->vdev; 660 break; 661 case TDLS_CMD_TX_ACTION: 662 case TDLS_CMD_SET_RESPONDER: 663 break; 664 case TDLS_CMD_ADD_STA: 665 vdev = ((struct tdls_add_peer_request *)ptr)->vdev; 666 break; 667 case TDLS_CMD_CHANGE_STA: 668 vdev = ((struct tdls_update_peer_request *)ptr)->vdev; 669 break; 670 case TDLS_CMD_ENABLE_LINK: 671 case TDLS_CMD_DISABLE_LINK: 672 case TDLS_CMD_REMOVE_FORCE_PEER: 673 case TDLS_CMD_CONFIG_FORCE_PEER: 674 vdev = ((struct tdls_oper_request *)ptr)->vdev; 675 break; 676 case TDLS_CMD_SET_OFFCHANNEL: 677 vdev = ((struct tdls_set_offchannel *)ptr)->vdev; 678 break; 679 case TDLS_CMD_SET_OFFCHANMODE: 680 vdev = ((struct tdls_set_offchanmode *)ptr)->vdev; 681 break; 682 case TDLS_CMD_SET_SECOFFCHANOFFSET: 683 vdev = ((struct tdls_set_secoffchanneloffset *)ptr)->vdev; 684 break; 685 } 686 687 if (vdev) 688 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 689 690 if (ptr) 691 qdf_mem_free(ptr); 692 693 msg->bodyptr = NULL; 694 695 return QDF_STATUS_SUCCESS; 696 } 697 ucfg_tdls_add_peer(struct wlan_objmgr_vdev * vdev,struct tdls_add_peer_params * add_peer_req)698 QDF_STATUS ucfg_tdls_add_peer(struct wlan_objmgr_vdev *vdev, 699 struct tdls_add_peer_params *add_peer_req) 700 { 701 struct scheduler_msg msg = {0, }; 702 struct tdls_add_peer_request *req; 703 QDF_STATUS status; 704 705 if (!vdev || !add_peer_req) { 706 tdls_err("vdev: %pK, req %pK", vdev, add_peer_req); 707 return QDF_STATUS_E_NULL_VALUE; 708 } 709 tdls_debug("vdevid: %d, peertype: %d", 710 add_peer_req->vdev_id, add_peer_req->peer_type); 711 712 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 713 if (QDF_IS_STATUS_ERROR(status)) { 714 tdls_err("can't get vdev"); 715 return status; 716 } 717 718 req = qdf_mem_malloc(sizeof(*req)); 719 if (!req) { 720 status = QDF_STATUS_E_NOMEM; 721 goto dec_ref; 722 } 723 724 qdf_mem_copy(&req->add_peer_req, add_peer_req, sizeof(*add_peer_req)); 725 req->vdev = vdev; 726 727 msg.bodyptr = req; 728 msg.callback = tdls_process_cmd; 729 msg.type = TDLS_CMD_ADD_STA; 730 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 731 status = scheduler_post_message(QDF_MODULE_ID_HDD, 732 QDF_MODULE_ID_TDLS, 733 QDF_MODULE_ID_OS_IF, &msg); 734 if (QDF_IS_STATUS_ERROR(status)) { 735 tdls_err("post add peer msg fail"); 736 qdf_mem_free(req); 737 goto dec_ref; 738 } 739 740 return status; 741 dec_ref: 742 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 743 return status; 744 } 745 ucfg_tdls_update_peer(struct wlan_objmgr_vdev * vdev,struct tdls_update_peer_params * update_peer)746 QDF_STATUS ucfg_tdls_update_peer(struct wlan_objmgr_vdev *vdev, 747 struct tdls_update_peer_params *update_peer) 748 { 749 struct scheduler_msg msg = {0,}; 750 struct tdls_update_peer_request *req; 751 QDF_STATUS status; 752 753 if (!vdev || !update_peer) { 754 tdls_err("vdev: %pK, update_peer: %pK", vdev, update_peer); 755 return QDF_STATUS_E_NULL_VALUE; 756 } 757 758 tdls_debug("vdev_id: %d, peertype: %d", 759 update_peer->vdev_id, update_peer->peer_type); 760 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 761 if (QDF_IS_STATUS_ERROR(status)) { 762 tdls_err("can't get vdev"); 763 return status; 764 } 765 req = qdf_mem_malloc(sizeof(*req)); 766 if (!req) { 767 status = QDF_STATUS_E_NOMEM; 768 goto dec_ref; 769 } 770 qdf_mem_copy(&req->update_peer_req, update_peer, sizeof(*update_peer)); 771 req->vdev = vdev; 772 773 msg.bodyptr = req; 774 msg.callback = tdls_process_cmd; 775 msg.type = TDLS_CMD_CHANGE_STA; 776 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 777 status = scheduler_post_message(QDF_MODULE_ID_HDD, 778 QDF_MODULE_ID_TDLS, 779 QDF_MODULE_ID_OS_IF, &msg); 780 if (QDF_IS_STATUS_ERROR(status)) { 781 tdls_err("post update peer msg fail"); 782 qdf_mem_free(req); 783 goto dec_ref; 784 } 785 786 return status; 787 dec_ref: 788 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 789 return status; 790 } 791 tdls_get_oper_str(enum tdls_command_type cmd_type)792 static char *tdls_get_oper_str(enum tdls_command_type cmd_type) 793 { 794 switch (cmd_type) { 795 case TDLS_CMD_ENABLE_LINK: 796 return "Enable_TDLS_LINK"; 797 case TDLS_CMD_DISABLE_LINK: 798 return "DISABLE_TDLS_LINK"; 799 case TDLS_CMD_REMOVE_FORCE_PEER: 800 return "REMOVE_FORCE_PEER"; 801 case TDLS_CMD_CONFIG_FORCE_PEER: 802 return "CONFIG_FORCE_PEER"; 803 default: 804 return "ERR:UNKNOWN OPER"; 805 } 806 } 807 ucfg_tdls_oper(struct wlan_objmgr_vdev * vdev,const uint8_t * macaddr,enum tdls_command_type cmd)808 QDF_STATUS ucfg_tdls_oper(struct wlan_objmgr_vdev *vdev, 809 const uint8_t *macaddr, enum tdls_command_type cmd) 810 { 811 struct scheduler_msg msg = {0,}; 812 struct tdls_oper_request *req; 813 QDF_STATUS status; 814 815 if (!vdev || !macaddr) { 816 tdls_err("vdev: %pK, mac %pK", vdev, macaddr); 817 return QDF_STATUS_E_NULL_VALUE; 818 } 819 820 tdls_debug("%s for peer " QDF_MAC_ADDR_FMT, 821 tdls_get_oper_str(cmd), 822 QDF_MAC_ADDR_REF(macaddr)); 823 824 req = qdf_mem_malloc(sizeof(*req)); 825 if (!req) 826 return QDF_STATUS_E_NOMEM; 827 828 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 829 if (QDF_IS_STATUS_ERROR(status)) { 830 tdls_err("can't get vdev"); 831 goto error; 832 } 833 834 qdf_mem_copy(req->peer_addr, macaddr, QDF_MAC_ADDR_SIZE); 835 req->vdev = vdev; 836 837 msg.bodyptr = req; 838 msg.callback = tdls_process_cmd; 839 msg.type = cmd; 840 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 841 status = scheduler_post_message(QDF_MODULE_ID_HDD, 842 QDF_MODULE_ID_TDLS, 843 QDF_MODULE_ID_OS_IF, &msg); 844 if (QDF_IS_STATUS_ERROR(status)) { 845 tdls_err("post msg for %s fail", tdls_get_oper_str(cmd)); 846 goto dec_ref; 847 } 848 849 return status; 850 dec_ref: 851 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 852 error: 853 qdf_mem_free(req); 854 return status; 855 } 856 ucfg_tdls_get_all_peers(struct wlan_objmgr_vdev * vdev,char * buf,int buflen)857 QDF_STATUS ucfg_tdls_get_all_peers(struct wlan_objmgr_vdev *vdev, 858 char *buf, int buflen) 859 { 860 struct scheduler_msg msg = {0, }; 861 struct tdls_get_all_peers *tdls_peers; 862 QDF_STATUS status; 863 864 tdls_peers = qdf_mem_malloc(sizeof(*tdls_peers)); 865 if (!tdls_peers) 866 return QDF_STATUS_E_NOMEM; 867 868 tdls_peers->vdev = vdev; 869 tdls_peers->buf_len = buflen; 870 tdls_peers->buf = buf; 871 872 msg.bodyptr = tdls_peers; 873 msg.callback = tdls_process_cmd; 874 msg.type = TDLS_CMD_GET_ALL_PEERS; 875 status = scheduler_post_message(QDF_MODULE_ID_HDD, 876 QDF_MODULE_ID_TDLS, 877 QDF_MODULE_ID_OS_IF, &msg); 878 879 if (status != QDF_STATUS_SUCCESS) 880 qdf_mem_free(tdls_peers); 881 882 return QDF_STATUS_SUCCESS; 883 } 884 tdls_send_mgmt_frame_flush_callback(struct scheduler_msg * msg)885 static QDF_STATUS tdls_send_mgmt_frame_flush_callback(struct scheduler_msg *msg) 886 { 887 struct tdls_action_frame_request *req; 888 889 if (!msg || !msg->bodyptr) { 890 tdls_err("msg or msg->bodyptr is NULL"); 891 return QDF_STATUS_E_NULL_VALUE; 892 } 893 req = msg->bodyptr; 894 if (req->vdev) 895 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_TDLS_NB_ID); 896 897 qdf_mem_free(req); 898 return QDF_STATUS_SUCCESS; 899 } 900 ucfg_tdls_send_mgmt_frame(struct tdls_action_frame_request * req)901 QDF_STATUS ucfg_tdls_send_mgmt_frame( 902 struct tdls_action_frame_request *req) 903 { 904 struct scheduler_msg msg = {0, }; 905 struct tdls_action_frame_request *mgmt_req; 906 QDF_STATUS status; 907 908 if (!req || !req->vdev) { 909 tdls_err("Invalid mgmt req params %pK", req); 910 return QDF_STATUS_E_NULL_VALUE; 911 } 912 913 mgmt_req = qdf_mem_malloc(sizeof(*mgmt_req) + 914 req->len); 915 if (!mgmt_req) 916 return QDF_STATUS_E_NOMEM; 917 918 qdf_mem_copy(mgmt_req, req, sizeof(*req)); 919 920 /*populate the additional IE's */ 921 if ((0 != req->len) && (req->cmd_buf)) { 922 qdf_mem_copy(mgmt_req->tdls_mgmt.buf, req->cmd_buf, 923 req->len); 924 mgmt_req->tdls_mgmt.len = req->len; 925 } else { 926 mgmt_req->tdls_mgmt.len = 0; 927 } 928 929 tdls_debug("vdev id: %d, session id : %d, action %d", mgmt_req->vdev_id, 930 mgmt_req->session_id, req->chk_frame.action_code); 931 status = wlan_objmgr_vdev_try_get_ref(req->vdev, WLAN_TDLS_NB_ID); 932 933 if (QDF_IS_STATUS_ERROR(status)) { 934 tdls_err("Unable to get vdev reference for tdls module"); 935 goto mem_free; 936 } 937 938 msg.bodyptr = mgmt_req; 939 msg.callback = tdls_process_cmd; 940 msg.flush_callback = tdls_send_mgmt_frame_flush_callback; 941 msg.type = TDLS_CMD_TX_ACTION; 942 status = scheduler_post_message(QDF_MODULE_ID_HDD, 943 QDF_MODULE_ID_TDLS, 944 QDF_MODULE_ID_OS_IF, &msg); 945 if (QDF_IS_STATUS_ERROR(status)) 946 goto release_ref; 947 948 return status; 949 950 release_ref: 951 wlan_objmgr_vdev_release_ref(req->vdev, WLAN_TDLS_NB_ID); 952 mem_free: 953 qdf_mem_free(mgmt_req); 954 return status; 955 } 956 ucfg_tdls_responder(struct tdls_set_responder_req * req)957 QDF_STATUS ucfg_tdls_responder(struct tdls_set_responder_req *req) 958 { 959 struct scheduler_msg msg = {0, }; 960 struct tdls_set_responder_req *msg_req; 961 QDF_STATUS status; 962 963 if (!req || !req->vdev) { 964 tdls_err("invalid input %pK", req); 965 return QDF_STATUS_E_NULL_VALUE; 966 } 967 968 msg_req = qdf_mem_malloc(sizeof(*msg_req)); 969 if (!msg_req) 970 return QDF_STATUS_E_NULL_VALUE; 971 972 msg_req->responder = req->responder; 973 msg_req->vdev = req->vdev; 974 qdf_mem_copy(msg_req->peer_mac, req->peer_mac, QDF_MAC_ADDR_SIZE); 975 976 msg.bodyptr = msg_req; 977 msg.callback = tdls_process_cmd; 978 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 979 msg.type = TDLS_CMD_SET_RESPONDER; 980 status = scheduler_post_message(QDF_MODULE_ID_HDD, 981 QDF_MODULE_ID_TDLS, 982 QDF_MODULE_ID_OS_IF, &msg); 983 if (QDF_IS_STATUS_ERROR(status)) 984 qdf_mem_free(msg_req); 985 986 return status; 987 } 988 ucfg_tdls_teardown_links_sync(struct wlan_objmgr_psoc * psoc,struct wlan_objmgr_vdev * vdev)989 void ucfg_tdls_teardown_links_sync(struct wlan_objmgr_psoc *psoc, 990 struct wlan_objmgr_vdev *vdev) 991 { 992 return wlan_tdls_check_and_teardown_links_sync(psoc, vdev); 993 } 994 ucfg_tdls_teardown_links(struct wlan_objmgr_psoc * psoc)995 QDF_STATUS ucfg_tdls_teardown_links(struct wlan_objmgr_psoc *psoc) 996 { 997 return wlan_tdls_teardown_links(psoc); 998 } 999 ucfg_tdls_notify_reset_adapter(struct wlan_objmgr_vdev * vdev)1000 QDF_STATUS ucfg_tdls_notify_reset_adapter(struct wlan_objmgr_vdev *vdev) 1001 { 1002 QDF_STATUS status; 1003 struct scheduler_msg msg = {0, }; 1004 1005 if (!vdev) { 1006 tdls_err("vdev is NULL "); 1007 return QDF_STATUS_E_NULL_VALUE; 1008 } 1009 tdls_debug("Enter "); 1010 msg.bodyptr = vdev; 1011 msg.callback = tdls_process_cmd; 1012 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 1013 msg.type = TDLS_NOTIFY_RESET_ADAPTERS; 1014 status = scheduler_post_message(QDF_MODULE_ID_HDD, 1015 QDF_MODULE_ID_TDLS, 1016 QDF_MODULE_ID_OS_IF, &msg); 1017 return status; 1018 } 1019 ucfg_tdls_set_operating_mode(struct tdls_set_mode_params * set_mode_params)1020 QDF_STATUS ucfg_tdls_set_operating_mode( 1021 struct tdls_set_mode_params *set_mode_params) 1022 { 1023 struct scheduler_msg msg = {0, }; 1024 struct tdls_set_mode_params *set_mode; 1025 QDF_STATUS status; 1026 1027 if (!set_mode_params || !set_mode_params->vdev) { 1028 tdls_err("set_mode_params %pK", set_mode_params); 1029 return QDF_STATUS_E_NULL_VALUE; 1030 } 1031 1032 tdls_debug("Enter "); 1033 1034 set_mode = qdf_mem_malloc(sizeof(*set_mode)); 1035 if (!set_mode) 1036 return QDF_STATUS_E_NULL_VALUE; 1037 1038 status = wlan_objmgr_vdev_try_get_ref(set_mode->vdev, WLAN_TDLS_NB_ID); 1039 if (QDF_IS_STATUS_ERROR(status)) { 1040 tdls_err("failed to get vdev ref"); 1041 qdf_mem_free(set_mode); 1042 return status; 1043 } 1044 1045 set_mode->source = set_mode_params->source; 1046 set_mode->tdls_mode = set_mode_params->tdls_mode; 1047 set_mode->update_last = set_mode_params->update_last; 1048 set_mode->vdev = set_mode_params->vdev; 1049 1050 msg.bodyptr = set_mode; 1051 msg.callback = tdls_process_cmd; 1052 msg.type = TDLS_CMD_SET_TDLS_MODE; 1053 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 1054 status = scheduler_post_message(QDF_MODULE_ID_HDD, 1055 QDF_MODULE_ID_TDLS, 1056 QDF_MODULE_ID_OS_IF, &msg); 1057 if (QDF_IS_STATUS_ERROR(status)) { 1058 wlan_objmgr_vdev_release_ref(set_mode->vdev, WLAN_TDLS_NB_ID); 1059 qdf_mem_free(set_mode); 1060 } 1061 1062 tdls_debug("Exit "); 1063 1064 return QDF_STATUS_SUCCESS; 1065 } 1066 ucfg_tdls_update_rx_pkt_cnt(struct wlan_objmgr_vdev * vdev,struct qdf_mac_addr * mac_addr,struct qdf_mac_addr * dest_mac_addr)1067 void ucfg_tdls_update_rx_pkt_cnt(struct wlan_objmgr_vdev *vdev, 1068 struct qdf_mac_addr *mac_addr, 1069 struct qdf_mac_addr *dest_mac_addr) 1070 { 1071 tdls_update_rx_pkt_cnt(vdev, mac_addr, dest_mac_addr); 1072 1073 } 1074 ucfg_tdls_update_tx_pkt_cnt(struct wlan_objmgr_vdev * vdev,struct qdf_mac_addr * mac_addr)1075 void ucfg_tdls_update_tx_pkt_cnt(struct wlan_objmgr_vdev *vdev, 1076 struct qdf_mac_addr *mac_addr) 1077 { 1078 tdls_update_tx_pkt_cnt(vdev, mac_addr); 1079 } 1080 ucfg_tdls_antenna_switch(struct wlan_objmgr_vdev * vdev,uint32_t mode)1081 QDF_STATUS ucfg_tdls_antenna_switch(struct wlan_objmgr_vdev *vdev, 1082 uint32_t mode) 1083 { 1084 QDF_STATUS status; 1085 struct tdls_antenna_switch_request *req; 1086 struct scheduler_msg msg = {0, }; 1087 1088 req = qdf_mem_malloc(sizeof(*req)); 1089 if (!req) 1090 return QDF_STATUS_E_NOMEM; 1091 1092 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 1093 if (QDF_IS_STATUS_ERROR(status)) { 1094 tdls_err("can't get vdev"); 1095 goto error; 1096 } 1097 1098 req->vdev = vdev; 1099 req->mode = mode; 1100 1101 msg.bodyptr = req; 1102 msg.callback = tdls_process_cmd; 1103 msg.flush_callback = tdls_antenna_switch_flush_callback; 1104 msg.type = TDLS_CMD_ANTENNA_SWITCH; 1105 status = scheduler_post_message(QDF_MODULE_ID_HDD, 1106 QDF_MODULE_ID_TDLS, 1107 QDF_MODULE_ID_OS_IF, &msg); 1108 if (QDF_IS_STATUS_ERROR(status)) { 1109 tdls_err("post antenna switch msg fail"); 1110 goto dec_ref; 1111 } 1112 1113 return status; 1114 1115 dec_ref: 1116 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 1117 error: 1118 qdf_mem_free(req); 1119 return status; 1120 } 1121 ucfg_set_tdls_offchannel(struct wlan_objmgr_vdev * vdev,int offchannel)1122 QDF_STATUS ucfg_set_tdls_offchannel(struct wlan_objmgr_vdev *vdev, 1123 int offchannel) 1124 { 1125 QDF_STATUS status = QDF_STATUS_SUCCESS; 1126 struct scheduler_msg msg = {0, }; 1127 struct tdls_set_offchannel *req; 1128 1129 req = qdf_mem_malloc(sizeof(*req)); 1130 if (!req) 1131 return QDF_STATUS_E_NOMEM; 1132 1133 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 1134 if (QDF_IS_STATUS_ERROR(status)) { 1135 tdls_err("can't get vdev"); 1136 goto free; 1137 } 1138 1139 req->offchannel = offchannel; 1140 req->vdev = vdev; 1141 req->callback = wlan_tdls_offchan_parms_callback; 1142 msg.bodyptr = req; 1143 msg.callback = tdls_process_cmd; 1144 msg.type = TDLS_CMD_SET_OFFCHANNEL; 1145 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 1146 status = scheduler_post_message(QDF_MODULE_ID_HDD, QDF_MODULE_ID_TDLS, 1147 QDF_MODULE_ID_OS_IF, &msg); 1148 if (QDF_IS_STATUS_ERROR(status)) { 1149 tdls_err("post set tdls offchannel msg fail"); 1150 goto dec_ref; 1151 } 1152 1153 return status; 1154 1155 dec_ref: 1156 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 1157 1158 free: 1159 qdf_mem_free(req); 1160 return status; 1161 } 1162 ucfg_set_tdls_offchan_mode(struct wlan_objmgr_vdev * vdev,int offchanmode)1163 QDF_STATUS ucfg_set_tdls_offchan_mode(struct wlan_objmgr_vdev *vdev, 1164 int offchanmode) 1165 { 1166 QDF_STATUS status = QDF_STATUS_SUCCESS; 1167 struct scheduler_msg msg = {0, }; 1168 struct tdls_set_offchanmode *req; 1169 1170 req = qdf_mem_malloc(sizeof(*req)); 1171 if (!req) 1172 return QDF_STATUS_E_NOMEM; 1173 1174 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 1175 if (QDF_IS_STATUS_ERROR(status)) { 1176 tdls_err("can't get vdev"); 1177 goto free; 1178 } 1179 1180 req->offchan_mode = offchanmode; 1181 req->vdev = vdev; 1182 req->callback = wlan_tdls_offchan_parms_callback; 1183 msg.bodyptr = req; 1184 msg.callback = tdls_process_cmd; 1185 msg.type = TDLS_CMD_SET_OFFCHANMODE; 1186 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 1187 status = scheduler_post_message(QDF_MODULE_ID_HDD, QDF_MODULE_ID_TDLS, 1188 QDF_MODULE_ID_OS_IF, &msg); 1189 if (QDF_IS_STATUS_ERROR(status)) { 1190 tdls_err("post set offchanmode msg fail"); 1191 goto dec_ref; 1192 } 1193 1194 return status; 1195 1196 dec_ref: 1197 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 1198 1199 free: 1200 qdf_mem_free(req); 1201 return status; 1202 } 1203 ucfg_set_tdls_secoffchanneloffset(struct wlan_objmgr_vdev * vdev,int offchanoffset)1204 QDF_STATUS ucfg_set_tdls_secoffchanneloffset(struct wlan_objmgr_vdev *vdev, 1205 int offchanoffset) 1206 { 1207 int status = QDF_STATUS_SUCCESS; 1208 struct scheduler_msg msg = {0, }; 1209 struct tdls_set_secoffchanneloffset *req; 1210 1211 req = qdf_mem_malloc(sizeof(*req)); 1212 if (!req) 1213 return QDF_STATUS_E_NOMEM; 1214 1215 status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID); 1216 if (QDF_IS_STATUS_ERROR(status)) { 1217 tdls_err("can't get vdev"); 1218 goto free; 1219 } 1220 1221 req->offchan_offset = offchanoffset; 1222 req->vdev = vdev; 1223 req->callback = wlan_tdls_offchan_parms_callback; 1224 msg.bodyptr = req; 1225 msg.callback = tdls_process_cmd; 1226 msg.type = TDLS_CMD_SET_SECOFFCHANOFFSET; 1227 msg.flush_callback = ucfg_tdls_post_msg_flush_cb; 1228 status = scheduler_post_message(QDF_MODULE_ID_HDD, QDF_MODULE_ID_TDLS, 1229 QDF_MODULE_ID_OS_IF, &msg); 1230 if (QDF_IS_STATUS_ERROR(status)) { 1231 tdls_err("post set secoffchan offset msg fail"); 1232 goto dec_ref; 1233 } 1234 return status; 1235 1236 dec_ref: 1237 wlan_objmgr_vdev_release_ref(vdev, WLAN_TDLS_NB_ID); 1238 1239 free: 1240 qdf_mem_free(req); 1241 return status; 1242 } 1243 ucfg_tdls_get_mlo_vdev(struct wlan_objmgr_vdev * vdev,uint8_t index,wlan_objmgr_ref_dbgid dbg_id)1244 struct wlan_objmgr_vdev *ucfg_tdls_get_mlo_vdev(struct wlan_objmgr_vdev *vdev, 1245 uint8_t index, 1246 wlan_objmgr_ref_dbgid dbg_id) 1247 { 1248 return wlan_tdls_get_mlo_vdev(vdev, index, dbg_id); 1249 } 1250 ucfg_tdls_release_mlo_vdev(struct wlan_objmgr_vdev * vdev,wlan_objmgr_ref_dbgid dbg_id)1251 void ucfg_tdls_release_mlo_vdev(struct wlan_objmgr_vdev *vdev, 1252 wlan_objmgr_ref_dbgid dbg_id) 1253 { 1254 return wlan_tdls_release_mlo_vdev(vdev, dbg_id); 1255 } 1256 ucfg_tdls_discovery_on_going(struct wlan_objmgr_vdev * vdev)1257 bool ucfg_tdls_discovery_on_going(struct wlan_objmgr_vdev *vdev) 1258 { 1259 struct tdls_soc_priv_obj *tdls_soc; 1260 uint8_t count; 1261 1262 tdls_soc = wlan_vdev_get_tdls_soc_obj(vdev); 1263 if (!tdls_soc) 1264 return false; 1265 count = qdf_atomic_read(&tdls_soc->timer_cnt); 1266 tdls_debug("discovery req timer count %d", count); 1267 1268 return count ? true : false; 1269 } 1270 ucfg_tdls_set_rssi(struct wlan_objmgr_vdev * vdev,uint8_t * mac,int8_t rssi)1271 QDF_STATUS ucfg_tdls_set_rssi(struct wlan_objmgr_vdev *vdev, 1272 uint8_t *mac, int8_t rssi) 1273 { 1274 return tdls_set_rssi(vdev, mac, rssi); 1275 } 1276 ucfg_tdls_notify_connect_failure(struct wlan_objmgr_psoc * psoc)1277 void ucfg_tdls_notify_connect_failure(struct wlan_objmgr_psoc *psoc) 1278 { 1279 return tdls_notify_decrement_session(psoc); 1280 } 1281 ucfg_get_tdls_conn_peer_count(struct wlan_objmgr_vdev * vdev)1282 uint16_t ucfg_get_tdls_conn_peer_count(struct wlan_objmgr_vdev *vdev) 1283 { 1284 return tdls_get_connected_peer_count_from_vdev(vdev); 1285 } 1286 ucfg_get_tdls_vdev(struct wlan_objmgr_psoc * psoc,wlan_objmgr_ref_dbgid dbg_id)1287 struct wlan_objmgr_vdev *ucfg_get_tdls_vdev(struct wlan_objmgr_psoc *psoc, 1288 wlan_objmgr_ref_dbgid dbg_id) 1289 { 1290 return tdls_get_vdev(psoc, dbg_id); 1291 } 1292 ucfg_tdls_check_is_tdls_allowed(struct wlan_objmgr_vdev * vdev)1293 bool ucfg_tdls_check_is_tdls_allowed(struct wlan_objmgr_vdev *vdev) 1294 { 1295 return tdls_check_is_tdls_allowed(vdev); 1296 } 1297 ucfg_tdls_set_user_tdls_enable(struct wlan_objmgr_vdev * vdev,bool is_user_tdls_enable)1298 void ucfg_tdls_set_user_tdls_enable(struct wlan_objmgr_vdev *vdev, 1299 bool is_user_tdls_enable) 1300 { 1301 return tdls_set_user_tdls_enable(vdev, is_user_tdls_enable); 1302 } 1303