1 /* 2 * Copyright (c) 2018-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: init_event_handler.c 22 * 23 * WMI common event handler implementation source file 24 */ 25 26 #include <qdf_status.h> 27 #include <wlan_objmgr_psoc_obj.h> 28 #include <wlan_objmgr_pdev_obj.h> 29 #include <target_if.h> 30 #include <target_if_reg.h> 31 #include <init_event_handler.h> 32 #include <service_ready_util.h> 33 #include <service_ready_param.h> 34 #include <init_cmd_api.h> 35 #include <cdp_txrx_cmn.h> 36 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 37 #include <cdp_txrx_misc.h> 38 #endif 39 #include <wlan_reg_ucfg_api.h> 40 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 41 #include <wlan_mlo_mgr_cmn.h> 42 #include <wlan_mlo_mgr_ap.h> 43 #include <wlan_mlo_mgr_setup.h> 44 #endif 45 #include <target_if_twt.h> 46 #include <target_if_scan.h> 47 48 static void init_deinit_set_send_init_cmd(struct wlan_objmgr_psoc *psoc, 49 struct target_psoc_info *tgt_hdl) 50 { 51 tgt_hdl->info.wmi_service_ready = TRUE; 52 /* send init command */ 53 init_deinit_prepare_send_init_cmd(psoc, tgt_hdl); 54 } 55 56 #ifdef WLAN_FEATURE_P2P_P2P_STA 57 static void 58 init_deinit_update_p2p_p2p_conc_support(struct wmi_unified *wmi_handle, 59 struct wlan_objmgr_psoc *psoc) 60 { 61 if (wmi_service_enabled(wmi_handle, wmi_service_p2p_p2p_cc_support)) 62 wlan_psoc_nif_fw_ext_cap_set(psoc, 63 WLAN_SOC_EXT_P2P_P2P_CONC_SUPPORT); 64 else 65 target_if_debug("P2P + P2P conc disabled"); 66 } 67 #else 68 static inline void 69 init_deinit_update_p2p_p2p_conc_support(struct wmi_unified *wmi_handle, 70 struct wlan_objmgr_psoc *psoc) 71 {} 72 #endif 73 74 #ifdef QCA_RSSI_DB2DBM 75 static void 76 init_deinit_update_rssi_dbm_conv_support(struct wmi_unified *wmi_handle, 77 struct wlan_objmgr_psoc *psoc) 78 { 79 /* Send RSSI_DBM_CONV to DP layer */ 80 if (wmi_service_enabled(wmi_handle, 81 wmi_service_pdev_rssi_dbm_conv_event_support)) 82 cdp_soc_set_param(wlan_psoc_get_dp_handle(psoc), 83 DP_SOC_PARAM_RSSI_DBM_CONV_SUPPORT, 1); 84 } 85 #else 86 static inline void 87 init_deinit_update_rssi_dbm_conv_support(struct wmi_unified *wmi_handle, 88 struct wlan_objmgr_psoc *psoc) 89 {} 90 #endif 91 92 #ifdef WIFI_POS_CONVERGED 93 static inline void 94 init_deinit_update_wifi_pos_caps(struct wmi_unified *wmi_handle, 95 struct wlan_objmgr_psoc *psoc) 96 { 97 if (wmi_service_enabled(wmi_handle, wmi_service_rtt_11az_ntb_support)) 98 wlan_psoc_nif_fw_ext_cap_set(psoc, 99 WLAN_RTT_11AZ_NTB_SUPPORT); 100 101 if (wmi_service_enabled(wmi_handle, wmi_service_rtt_11az_tb_support)) 102 wlan_psoc_nif_fw_ext2_cap_set(psoc, 103 WLAN_RTT_11AZ_TB_SUPPORT); 104 105 if (wmi_service_enabled(wmi_handle, 106 wmi_service_rtt_11az_tb_rsta_support)) 107 wlan_psoc_nif_fw_ext2_cap_set(psoc, 108 WLAN_RTT_11AZ_TB_RSTA_SUPPORT); 109 110 if (wmi_service_enabled(wmi_handle, 111 wmi_service_rtt_11az_mac_sec_support)) 112 wlan_psoc_nif_fw_ext2_cap_set(psoc, 113 WLAN_RTT_11AZ_MAC_SEC_SUPPORT); 114 115 if (wmi_service_enabled(wmi_handle, 116 wmi_service_rtt_11az_mac_phy_sec_support)) 117 wlan_psoc_nif_fw_ext2_cap_set( 118 psoc, WLAN_RTT_11AZ_MAC_PHY_SEC_SUPPORT); 119 } 120 #else 121 static inline void 122 init_deinit_update_wifi_pos_caps(struct wmi_unified *wmi_handle, 123 struct wlan_objmgr_psoc *psoc) 124 {} 125 #endif 126 127 #ifdef WLAN_FEATURE_ROAM_OFFLOAD 128 static void 129 init_deinit_update_roam_stats_cap(struct wmi_unified *wmi_handle, 130 struct wlan_objmgr_psoc *psoc) 131 { 132 if (wmi_service_enabled(wmi_handle, 133 wmi_service_roam_stats_per_candidate_frame_info)) 134 wlan_psoc_nif_fw_ext2_cap_set( 135 psoc, WLAN_ROAM_STATS_FRAME_INFO_PER_CANDIDATE); 136 } 137 #else 138 static inline void 139 init_deinit_update_roam_stats_cap(struct wmi_unified *wmi_handle, 140 struct wlan_objmgr_psoc *psoc) 141 {} 142 #endif 143 144 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 145 static void 146 init_deinit_update_tx_ilp_cap(struct wlan_objmgr_psoc *psoc, 147 struct tgt_info *info) 148 { 149 ol_txrx_soc_handle soc; 150 151 soc = wlan_psoc_get_dp_handle(psoc); 152 info->wlan_res_cfg.tx_ilp_enable = 153 cdp_evaluate_update_tx_ilp_cfg( 154 soc, info->service_ext2_param.num_msdu_idx_qtype_map, 155 info->msdu_idx_qtype_map); 156 } 157 #else 158 static void 159 init_deinit_update_tx_ilp_cap(struct wlan_objmgr_psoc *psoc, 160 struct tgt_info *info) 161 { 162 } 163 #endif 164 165 #ifdef MULTI_CLIENT_LL_SUPPORT 166 /** 167 * init_deinit_update_multi_client_ll_caps() - Update multi client service 168 * capability bit 169 * @wmi_handle: wmi handle 170 * @psoc: psoc common object 171 * 172 * Return: none 173 */ 174 static void 175 init_deinit_update_multi_client_ll_caps(struct wmi_unified *wmi_handle, 176 struct wlan_objmgr_psoc *psoc) 177 { 178 if (wmi_service_enabled(wmi_handle, 179 wmi_service_configure_multi_client_ll_support)) 180 wlan_psoc_nif_fw_ext2_cap_set(psoc, 181 WLAN_SOC_WLM_MULTI_CLIENT_LL_SUPPORT); 182 } 183 #else 184 static inline void 185 init_deinit_update_multi_client_ll_caps(struct wmi_unified *wmi_handle, 186 struct wlan_objmgr_psoc *psoc) 187 {} 188 #endif 189 190 #ifdef WLAN_VENDOR_HANDOFF_CONTROL 191 /** 192 * init_deinit_update_vendor_handoff_control_caps() - Update vendor handoff 193 * control service capability bit 194 * @wmi_handle: wmi handle 195 * @psoc: psoc common object 196 * 197 * Return: none 198 */ 199 static void 200 init_deinit_update_vendor_handoff_control_caps(struct wmi_unified *wmi_handle, 201 struct wlan_objmgr_psoc *psoc) 202 { 203 if (wmi_service_enabled(wmi_handle, 204 wmi_service_configure_vendor_handoff_control_support)) 205 wlan_psoc_nif_fw_ext2_cap_set(psoc, 206 WLAN_SOC_VENDOR_HANDOFF_CONTROL); 207 } 208 #else 209 static inline void 210 init_deinit_update_vendor_handoff_control_caps(struct wmi_unified *wmi_handle, 211 struct wlan_objmgr_psoc *psoc) 212 {} 213 #endif 214 215 #ifdef FEATURE_WLAN_TDLS 216 static void init_deinit_update_tdls_caps(struct wmi_unified *wmi, 217 struct wlan_objmgr_psoc *psoc) 218 { 219 if (wmi_service_enabled(wmi, wmi_service_tdls_concurrency_support)) 220 wlan_psoc_nif_fw_ext2_cap_set(psoc, 221 WLAN_TDLS_CONCURRENCIES_SUPPORT); 222 } 223 #else 224 static inline void init_deinit_update_tdls_caps(struct wmi_unified *wmi_handle, 225 struct wlan_objmgr_psoc *psoc) 226 {} 227 #endif 228 static void 229 init_deinit_pdev_wsi_stats_info_support(struct wmi_unified *wmi_handle, 230 struct wlan_objmgr_psoc *psoc); 231 232 static void init_deinit_mlo_tsf_sync_support(struct wmi_unified *wmi_handle, 233 struct wlan_objmgr_psoc *psoc); 234 235 static int init_deinit_service_ready_event_handler(ol_scn_t scn_handle, 236 uint8_t *event, 237 uint32_t data_len) 238 { 239 int err_code; 240 struct wlan_objmgr_psoc *psoc; 241 struct target_psoc_info *tgt_hdl; 242 wmi_legacy_service_ready_callback legacy_callback; 243 struct wmi_unified *wmi_handle; 244 QDF_STATUS ret_val; 245 246 if (!scn_handle) { 247 target_if_err("scn handle NULL in service ready handler"); 248 return -EINVAL; 249 } 250 251 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 252 if (!psoc) { 253 target_if_err("psoc is null in service ready handler"); 254 return -EINVAL; 255 } 256 257 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 258 if (!tgt_hdl) { 259 target_if_err("target_psoc_info is null in service ready ev"); 260 return -EINVAL; 261 } 262 263 ret_val = target_if_sw_version_check(psoc, tgt_hdl, event); 264 265 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 266 267 err_code = init_deinit_populate_service_bitmap(wmi_handle, event, 268 tgt_hdl->info.service_bitmap); 269 if (err_code) 270 goto exit; 271 272 err_code = init_deinit_populate_fw_version_cmd(wmi_handle, event); 273 if (err_code) 274 goto exit; 275 276 err_code = init_deinit_populate_target_cap(wmi_handle, event, 277 &(tgt_hdl->info.target_caps)); 278 if (err_code) 279 goto exit; 280 281 err_code = init_deinit_populate_phy_reg_cap(psoc, wmi_handle, event, 282 &(tgt_hdl->info), true); 283 if (err_code) 284 goto exit; 285 286 if (init_deinit_validate_160_80p80_fw_caps(psoc, tgt_hdl) != 287 QDF_STATUS_SUCCESS) { 288 wlan_psoc_nif_op_flag_set(psoc, WLAN_SOC_OP_VHT_INVALID_CAP); 289 } 290 291 if (wmi_service_enabled(wmi_handle, wmi_service_tt) || 292 wmi_service_enabled(wmi_handle, wmi_service_thermal_mgmt)) 293 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_TT_SUPPORT); 294 295 if (wmi_service_enabled(wmi_handle, wmi_service_widebw_scan)) 296 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_WIDEBAND_SCAN); 297 298 if (wmi_service_enabled(wmi_handle, wmi_service_check_cal_version)) 299 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_SW_CAL); 300 301 if (wmi_service_enabled(wmi_handle, wmi_service_twt_requestor)) 302 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_TWT_REQUESTER); 303 304 if (wmi_service_enabled(wmi_handle, wmi_service_twt_responder)) 305 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_TWT_RESPONDER); 306 307 if (wmi_service_enabled(wmi_handle, wmi_service_bss_color_offload)) 308 target_if_debug(" BSS COLOR OFFLOAD supported"); 309 310 if (wmi_service_enabled(wmi_handle, wmi_service_ul_ru26_allowed)) 311 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_OBSS_NBW_RU); 312 313 if (wmi_service_enabled(wmi_handle, wmi_service_infra_mbssid)) 314 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_MBSS_IE); 315 316 if (wmi_service_enabled(wmi_handle, 317 wmi_service_mbss_param_in_vdev_start_support)) 318 wlan_psoc_nif_fw_ext_cap_set(psoc, 319 WLAN_SOC_CEXT_MBSS_PARAM_IN_START); 320 321 if (wmi_service_enabled(wmi_handle, wmi_service_dynamic_hw_mode)) 322 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_DYNAMIC_HW_MODE); 323 324 if (wmi_service_enabled(wmi_handle, 325 wmi_service_bw_restricted_80p80_support)) 326 wlan_psoc_nif_fw_ext_cap_set(psoc, 327 WLAN_SOC_RESTRICTED_80P80_SUPPORT); 328 329 if (wmi_service_enabled(wmi_handle, 330 wmi_service_nss_ratio_to_host_support)) 331 wlan_psoc_nif_fw_ext_cap_set( 332 psoc, WLAN_SOC_NSS_RATIO_TO_HOST_SUPPORT); 333 334 if (wmi_service_enabled(wmi_handle, 335 wmi_service_rtt_ap_initiator_staggered_mode_supported)) 336 wlan_psoc_nif_fw_ext_cap_set( 337 psoc, WLAN_SOC_RTT_AP_INITIATOR_STAGGERED_MODE_SUPPORTED); 338 339 if (wmi_service_enabled(wmi_handle, 340 wmi_service_rtt_ap_initiator_bursted_mode_supported)) 341 wlan_psoc_nif_fw_ext_cap_set( 342 psoc, WLAN_SOC_RTT_AP_INITIATOR_BURSTED_MODE_SUPPORTED); 343 344 target_if_debug(" TT support %d, Wide BW Scan %d, SW cal %d", 345 wlan_psoc_nif_fw_ext_cap_get(psoc, WLAN_SOC_CEXT_TT_SUPPORT), 346 wlan_psoc_nif_fw_ext_cap_get(psoc, WLAN_SOC_CEXT_WIDEBAND_SCAN), 347 wlan_psoc_nif_fw_ext_cap_get(psoc, WLAN_SOC_CEXT_SW_CAL)); 348 349 target_if_mesh_support_enable(psoc, tgt_hdl, event); 350 351 target_if_eapol_minrate_enable(psoc, tgt_hdl, event); 352 353 target_if_smart_antenna_enable(psoc, tgt_hdl, event); 354 355 target_if_cfr_support_enable(psoc, tgt_hdl, event); 356 357 target_if_peer_cfg_enable(psoc, tgt_hdl, event); 358 359 target_if_atf_cfg_enable(psoc, tgt_hdl, event); 360 361 if (wmi_service_enabled(wmi_handle, 362 wmi_service_mgmt_rx_reo_supported)) 363 wlan_psoc_nif_feat_cap_set(psoc, 364 WLAN_SOC_F_MGMT_RX_REO_CAPABLE); 365 366 target_if_lteu_cfg_enable(psoc, tgt_hdl, event); 367 368 if (wmi_service_enabled(wmi_handle, wmi_service_rx_fse_support)) 369 wlan_psoc_nif_fw_ext_cap_set(psoc, 370 WLAN_SOC_CEXT_RX_FSE_SUPPORT); 371 372 if (wmi_service_enabled(wmi_handle, 373 wmi_service_scan_conf_per_ch_support)) 374 wlan_psoc_nif_fw_ext_cap_set(psoc, 375 WLAN_SOC_CEXT_SCAN_PER_CH_CONFIG); 376 377 if (wmi_service_enabled(wmi_handle, 378 wmi_service_pno_scan_conf_per_ch_support)) 379 wlan_psoc_nif_fw_ext_cap_set(psoc, 380 WLAN_SOC_PNO_SCAN_CONFIG_PER_CHANNEL); 381 382 if (wmi_service_enabled(wmi_handle, wmi_service_csa_beacon_template)) 383 wlan_psoc_nif_fw_ext_cap_set(psoc, 384 WLAN_SOC_CEXT_CSA_TX_OFFLOAD); 385 386 init_deinit_update_roam_stats_cap(wmi_handle, psoc); 387 388 init_deinit_update_wifi_pos_caps(wmi_handle, psoc); 389 init_deinit_update_tdls_caps(wmi_handle, psoc); 390 391 init_deinit_pdev_wsi_stats_info_support(wmi_handle, psoc); 392 393 init_deinit_mlo_tsf_sync_support(wmi_handle, psoc); 394 395 /* override derived value, if it exceeds max peer count */ 396 if ((wlan_psoc_get_max_peer_count(psoc) > 397 tgt_hdl->info.wlan_res_cfg.num_active_peers) && 398 (wlan_psoc_get_max_peer_count(psoc) < 399 (tgt_hdl->info.wlan_res_cfg.num_peers - 400 tgt_hdl->info.wlan_res_cfg.num_vdevs))) { 401 tgt_hdl->info.wlan_res_cfg.num_peers = 402 wlan_psoc_get_max_peer_count(psoc) + 403 tgt_hdl->info.wlan_res_cfg.num_vdevs; 404 } 405 legacy_callback = target_if_get_psoc_legacy_service_ready_cb(); 406 if (!legacy_callback) { 407 err_code = -EINVAL; 408 goto exit; 409 } 410 411 err_code = legacy_callback(wmi_service_ready_event_id, 412 scn_handle, event, data_len); 413 init_deinit_chainmask_config(psoc, tgt_hdl); 414 415 if (wmi_service_enabled(wmi_handle, wmi_service_mgmt_tx_wmi)) { 416 wlan_psoc_nif_fw_ext_cap_set(psoc, WLAN_SOC_CEXT_WMI_MGMT_REF); 417 target_if_debug("WMI mgmt service enabled"); 418 } else { 419 wlan_psoc_nif_fw_ext_cap_clear(psoc, 420 WLAN_SOC_CEXT_WMI_MGMT_REF); 421 target_if_debug("WMI mgmt service disabled"); 422 } 423 init_deinit_update_p2p_p2p_conc_support(wmi_handle, psoc); 424 425 err_code = init_deinit_handle_host_mem_req(psoc, tgt_hdl, event); 426 if (err_code != QDF_STATUS_SUCCESS) 427 goto exit; 428 429 target_if_reg_set_offloaded_info(psoc); 430 target_if_reg_set_6ghz_info(psoc); 431 target_if_reg_set_5dot9_ghz_info(psoc); 432 target_if_twt_fill_tgt_caps(psoc, wmi_handle); 433 target_if_update_aux_support(psoc); 434 435 /* Send num_msdu_desc to DP layer */ 436 cdp_soc_set_param(wlan_psoc_get_dp_handle(psoc), 437 DP_SOC_PARAM_MSDU_EXCEPTION_DESC, 438 tgt_hdl->info.target_caps.num_msdu_desc); 439 440 /* Send multi_peer_group support to DP layer */ 441 if (wmi_service_enabled(wmi_handle, 442 wmi_service_multi_peer_group_cmd_support)) 443 cdp_soc_set_param(wlan_psoc_get_dp_handle(psoc), 444 DP_SOC_PARAM_MULTI_PEER_GRP_CMD_SUPPORT, 1); 445 446 /* Send UMAC HW reset support to DP layer */ 447 if (wmi_service_enabled(wmi_handle, 448 wmi_service_umac_hang_recovery_support)) 449 cdp_soc_set_param(wlan_psoc_get_dp_handle(psoc), 450 DP_SOC_PARAM_UMAC_HW_RESET_SUPPORT, 1); 451 452 if (wmi_service_enabled(wmi_handle, wmi_service_vdev_delete_all_peer)) 453 wlan_psoc_nif_fw_ext2_cap_set(psoc, 454 WLAN_VDEV_DELETE_ALL_PEER_SUPPORT); 455 456 init_deinit_update_rssi_dbm_conv_support(wmi_handle, psoc); 457 458 init_deinit_update_multi_client_ll_caps(wmi_handle, psoc); 459 460 init_deinit_update_vendor_handoff_control_caps(wmi_handle, psoc); 461 462 if (wmi_service_enabled(wmi_handle, 463 wmi_service_cca_busy_info_for_each_20mhz)) 464 wlan_psoc_nif_fw_ext2_cap_set(psoc, 465 WLAN_CCA_BUSY_INFO_FOREACH_20MHZ); 466 if (wmi_service_enabled(wmi_handle, 467 wmi_service_vdev_param_chwidth_with_notify_support)) 468 wlan_psoc_nif_fw_ext2_cap_set(psoc, 469 WLAN_VDEV_PARAM_CHWIDTH_WITH_NOTIFY_SUPPORT); 470 471 if (wmi_service_enabled(wmi_handle, wmi_service_ext_msg)) { 472 target_if_debug("Wait for EXT message"); 473 } else { 474 target_if_debug("No EXT message, send init command"); 475 target_psoc_set_num_radios(tgt_hdl, 1); 476 init_deinit_set_send_init_cmd(psoc, tgt_hdl); 477 } 478 479 if (wmi_service_enabled(wmi_handle, 480 wmi_service_multiple_reorder_queue_setup_support)) 481 cdp_soc_set_param(wlan_psoc_get_dp_handle(psoc), 482 DP_SOC_PARAM_MULTI_RX_REORDER_SETUP_SUPPORT, 1); 483 484 exit: 485 return err_code; 486 } 487 488 static int init_deinit_service_ext2_ready_event_handler(ol_scn_t scn_handle, 489 uint8_t *event, 490 uint32_t data_len) 491 { 492 int err_code = 0; 493 struct wlan_objmgr_psoc *psoc; 494 struct target_psoc_info *tgt_hdl; 495 struct wmi_unified *wmi_handle; 496 struct tgt_info *info; 497 wmi_legacy_service_ready_callback legacy_callback; 498 499 if (!scn_handle) { 500 target_if_err("scn handle NULL in service ready ext2 handler"); 501 return -EINVAL; 502 } 503 504 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 505 if (!psoc) { 506 target_if_err("psoc is null in service ready ext2 handler"); 507 return -EINVAL; 508 } 509 510 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 511 if (!tgt_hdl) { 512 target_if_err("target_psoc_info is null in service ready ext2 handler"); 513 return -EINVAL; 514 } 515 516 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 517 if (!wmi_handle) { 518 target_if_err("wmi_handle is null in service ready ext2 handler"); 519 return -EINVAL; 520 } 521 522 info = (&tgt_hdl->info); 523 if (info->wmi_service_status == 524 wmi_init_ext_processing_failed) 525 return -EINVAL; 526 527 err_code = init_deinit_populate_service_ready_ext2_param(wmi_handle, 528 event, info); 529 if (err_code) 530 goto exit; 531 532 if (wmi_service_enabled(wmi_handle, 533 wmi_service_reg_cc_ext_event_support)) { 534 target_if_set_reg_cc_ext_supp(tgt_hdl, psoc); 535 wlan_psoc_nif_fw_ext_cap_set(psoc, 536 WLAN_SOC_EXT_EVENT_SUPPORTED); 537 } 538 539 if (wmi_service_enabled(wmi_handle, 540 wmi_service_bang_radar_320_support)) { 541 info->wlan_res_cfg.is_host_dfs_320mhz_bangradar_supported = 542 true; 543 } 544 545 /* dbr_ring_caps could have already come as part of EXT event */ 546 if (info->service_ext2_param.num_dbr_ring_caps) { 547 err_code = init_deinit_populate_dbr_ring_cap_ext2(psoc, 548 wmi_handle, 549 event, info); 550 if (err_code) 551 goto exit; 552 } 553 554 err_code = init_deinit_populate_hal_reg_cap_ext2(wmi_handle, event, 555 info); 556 if (err_code) { 557 target_if_err("failed to populate hal reg cap ext2"); 558 goto exit; 559 } 560 561 err_code = init_deinit_populate_mac_phy_cap_ext2(wmi_handle, event, 562 info); 563 if (err_code) { 564 target_if_err("failed to populate mac phy cap ext2"); 565 goto exit; 566 } 567 568 target_if_add_11ax_modes(psoc, tgt_hdl); 569 570 err_code = init_deinit_populate_scan_radio_cap_ext2(wmi_handle, event, 571 info); 572 if (err_code) { 573 target_if_err("failed to populate scan radio cap ext2"); 574 goto exit; 575 } 576 577 err_code = init_deinit_populate_msdu_idx_qtype_map_ext2(wmi_handle, 578 event, info); 579 580 if (err_code) { 581 target_if_err("failed to populate msdu index qtype map ext2"); 582 goto exit; 583 } 584 585 init_deinit_update_tx_ilp_cap(psoc, info); 586 587 err_code = init_deinit_populate_twt_cap_ext2(psoc, wmi_handle, event, 588 info); 589 590 if (err_code) 591 target_if_debug("failed to populate twt cap ext2"); 592 593 err_code = init_deinit_populate_dbs_or_sbs_cap_ext2(psoc, wmi_handle, 594 event, info); 595 if (err_code) 596 target_if_debug("failed to populate dbs_or_sbs cap ext2"); 597 598 err_code = init_deinit_populate_sap_coex_capability(psoc, wmi_handle, 599 event); 600 if (err_code) 601 target_if_debug("failed to populate sap_coex_capability ext2"); 602 603 if (info->service_ext2_param.num_aux_dev_caps) { 604 err_code = init_deinit_populate_aux_dev_cap_ext2(psoc, 605 wmi_handle, 606 event, info); 607 if (err_code) 608 target_if_debug("failed to populate aux_dev cap ext2"); 609 } 610 611 if (wmi_service_enabled(wmi_handle, 612 wmi_service_aoa_for_rcc_supported)) { 613 err_code = init_deinit_populate_rcc_aoa_cap_ext2(psoc, 614 wmi_handle, 615 event, info); 616 if (err_code) 617 target_if_debug("failed to populate aoa cap ext2"); 618 } 619 620 legacy_callback = target_if_get_psoc_legacy_service_ready_cb(); 621 if (legacy_callback) 622 if (legacy_callback(wmi_service_ready_ext2_event_id, 623 scn_handle, event, data_len)) { 624 target_if_err("Legacy callback return error!"); 625 goto exit; 626 } 627 628 if (wmi_service_enabled(wmi_handle, wmi_service_radar_flags_support)) { 629 target_if_debug("Full bw nol supported"); 630 info->wlan_res_cfg.is_full_bw_nol_supported = true; 631 } 632 633 target_if_regulatory_set_ext_tpc(psoc); 634 635 target_if_reg_set_lower_6g_edge_ch_info(psoc); 636 637 target_if_reg_set_disable_upper_6g_edge_ch_info(psoc); 638 639 target_if_reg_set_afc_dev_type(psoc, tgt_hdl); 640 641 target_if_set_regulatory_eirp_preferred_support(psoc); 642 643 tgt_if_set_reg_afc_configure(tgt_hdl, psoc); 644 645 /* send init command */ 646 init_deinit_set_send_init_cmd(psoc, tgt_hdl); 647 648 return 0; 649 exit: 650 info->wmi_ready = false; 651 info->wmi_service_status = wmi_init_ext2_processing_failed; 652 return err_code; 653 } 654 655 static int init_deinit_service_ext_ready_event_handler(ol_scn_t scn_handle, 656 uint8_t *event, 657 uint32_t data_len) 658 { 659 int err_code; 660 uint8_t num_radios; 661 struct wlan_objmgr_psoc *psoc; 662 struct target_psoc_info *tgt_hdl; 663 struct wmi_unified *wmi_handle; 664 struct tgt_info *info; 665 wmi_legacy_service_ready_callback legacy_callback; 666 667 if (!scn_handle) { 668 target_if_err("scn handle NULL in service ready handler"); 669 return -EINVAL; 670 } 671 672 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 673 if (!psoc) { 674 target_if_err("psoc is null in service ready handler"); 675 return -EINVAL; 676 } 677 678 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 679 if (!tgt_hdl) { 680 target_if_err("target_psoc_info is null in service ready ev"); 681 return -EINVAL; 682 } 683 684 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 685 info = (&tgt_hdl->info); 686 687 err_code = init_deinit_populate_service_ready_ext_param(wmi_handle, 688 event, &(info->service_ext_param)); 689 if (err_code) 690 goto exit; 691 692 target_psoc_set_num_radios(tgt_hdl, 0); 693 err_code = init_deinit_populate_hw_mode_capability(wmi_handle, 694 event, tgt_hdl); 695 if (err_code) 696 goto exit; 697 698 if (init_deinit_is_preferred_hw_mode_supported(psoc, tgt_hdl) 699 == FALSE) { 700 target_if_err("Preferred mode %d not supported", 701 info->preferred_hw_mode); 702 goto exit; 703 } 704 705 num_radios = target_psoc_get_num_radios_for_mode(tgt_hdl, 706 info->preferred_hw_mode); 707 708 /* set number of radios based on current mode */ 709 target_psoc_set_num_radios(tgt_hdl, num_radios); 710 711 target_if_print_service_ready_ext_param(psoc, tgt_hdl); 712 713 err_code = init_deinit_populate_phy_reg_cap(psoc, wmi_handle, 714 event, info, false); 715 if (err_code) 716 goto exit; 717 718 /* Host receives 11AX wireless modes from target in service ext2 719 * message. Therefore, call target_if_add_11ax_modes() from service ext2 720 * event handler as well. 721 */ 722 if (!wmi_service_enabled(wmi_handle, wmi_service_ext2_msg)) 723 target_if_add_11ax_modes(psoc, tgt_hdl); 724 725 if (init_deinit_chainmask_table_alloc( 726 &(info->service_ext_param)) == 727 QDF_STATUS_SUCCESS) { 728 err_code = init_deinit_populate_chainmask_tables(wmi_handle, 729 event, 730 &(info->service_ext_param.chainmask_table[0])); 731 if (err_code) 732 goto exit; 733 } 734 735 /* dbr_ring_caps can be absent if enough space is not available */ 736 if (info->service_ext_param.num_dbr_ring_caps) { 737 err_code = init_deinit_populate_dbr_ring_cap(psoc, wmi_handle, 738 event, info); 739 if (err_code) 740 goto exit; 741 } 742 743 err_code = init_deinit_populate_spectral_bin_scale_params(psoc, 744 wmi_handle, 745 event, info); 746 if (err_code) 747 goto exit; 748 749 legacy_callback = target_if_get_psoc_legacy_service_ready_cb(); 750 if (legacy_callback) { 751 if (legacy_callback(wmi_service_ready_ext_event_id, 752 scn_handle, event, data_len)) { 753 target_if_err("Error Code %d", err_code); 754 goto exit; 755 } 756 } 757 758 target_if_set_twt_ap_pdev_count(info, tgt_hdl); 759 760 info->wlan_res_cfg.max_bssid_indicator = 761 info->service_ext_param.max_bssid_indicator; 762 763 if (wmi_service_enabled(wmi_handle, wmi_service_ext2_msg)) { 764 target_if_debug("Wait for EXT2 message"); 765 } else { 766 target_if_debug("No EXT2 message, send init command"); 767 init_deinit_set_send_init_cmd(psoc, tgt_hdl); 768 } 769 770 return 0; 771 exit: 772 info->wmi_ready = false; 773 info->wmi_service_status = wmi_init_ext_processing_failed; 774 init_deinit_wakeup_host_wait(psoc, tgt_hdl); 775 return err_code; 776 } 777 778 static int init_deinit_service_available_handler(ol_scn_t scn_handle, 779 uint8_t *event, 780 uint32_t data_len) 781 { 782 struct wlan_objmgr_psoc *psoc; 783 struct target_psoc_info *tgt_hdl; 784 struct wmi_unified *wmi_handle; 785 786 if (!scn_handle) { 787 target_if_err("scn handle NULL"); 788 return -EINVAL; 789 } 790 791 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 792 if (!psoc) { 793 target_if_err("psoc is null"); 794 return -EINVAL; 795 } 796 797 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 798 if (!tgt_hdl) { 799 target_if_err("target_psoc_info is null"); 800 return -EINVAL; 801 } 802 803 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 804 805 if (wmi_save_ext_service_bitmap(wmi_handle, event, NULL) != 806 QDF_STATUS_SUCCESS) { 807 target_if_err("Failed to save ext service bitmap"); 808 return -EINVAL; 809 } 810 811 return 0; 812 } 813 814 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 815 static bool init_deinit_mlo_capable(struct wlan_objmgr_psoc *psoc) 816 { 817 struct target_psoc_info *tgt_hdl; 818 819 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 820 if (!tgt_hdl) { 821 target_if_err("target_psoc_info is null"); 822 return false; 823 } 824 825 if ((tgt_hdl->tif_ops) && 826 (tgt_hdl->tif_ops->mlo_capable)) 827 return tgt_hdl->tif_ops->mlo_capable(psoc); 828 829 return false; 830 } 831 832 static bool init_deinit_mlo_get_group_id(struct wlan_objmgr_psoc *psoc, 833 uint8_t *grp_id) 834 { 835 struct target_psoc_info *tgt_hdl; 836 837 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 838 if (!tgt_hdl) { 839 target_if_err("target_psoc_info is null"); 840 return false; 841 } 842 843 if ((tgt_hdl->tif_ops) && 844 (tgt_hdl->tif_ops->mlo_get_group_id)) { 845 *grp_id = tgt_hdl->tif_ops->mlo_get_group_id(psoc); 846 return true; 847 } 848 849 return false; 850 } 851 852 static void init_deinit_mlo_update_soc_ready(struct wlan_objmgr_psoc *psoc) 853 { 854 uint8_t grp_id = 0; 855 856 if (init_deinit_mlo_capable(psoc)) { 857 if (!init_deinit_mlo_get_group_id(psoc, &grp_id)) { 858 target_if_err("Invalid MLD group id"); 859 return; 860 } 861 mlo_setup_update_soc_ready(psoc, grp_id); 862 } 863 } 864 865 static void init_deinit_send_ml_link_ready(struct wlan_objmgr_psoc *psoc, 866 void *object, void *arg) 867 { 868 struct wlan_objmgr_pdev *pdev = object; 869 uint8_t grp_id = 0; 870 871 if (!init_deinit_mlo_capable(psoc)) 872 return; 873 874 qdf_assert_always(psoc); 875 qdf_assert_always(pdev); 876 877 if (!init_deinit_mlo_get_group_id(psoc, &grp_id)) 878 qdf_assert_always(grp_id); 879 880 mlo_setup_link_ready(pdev, grp_id); 881 } 882 883 static void init_deinit_mlo_update_pdev_ready(struct wlan_objmgr_psoc *psoc, 884 uint8_t num_radios) 885 { 886 if (!init_deinit_mlo_capable(psoc)) 887 return; 888 889 wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP, 890 init_deinit_send_ml_link_ready, 891 NULL, 0, WLAN_INIT_DEINIT_ID); 892 } 893 894 static void 895 init_deinit_pdev_wsi_stats_info_support(struct wmi_unified *wmi_handle, 896 struct wlan_objmgr_psoc *psoc) 897 { 898 bool wsi_stats_info_support = false; 899 900 if (!init_deinit_mlo_capable(psoc)) 901 return; 902 903 if (wmi_service_enabled(wmi_handle, 904 wmi_service_pdev_wsi_stats_info_support)) 905 wsi_stats_info_support = true; 906 907 mlo_update_wsi_stats_info_support(psoc, wsi_stats_info_support); 908 } 909 910 static void init_deinit_mlo_tsf_sync_support(struct wmi_unified *wmi_handle, 911 struct wlan_objmgr_psoc *psoc) 912 { 913 bool mlo_tsf_sync_enab = false; 914 915 if (!init_deinit_mlo_capable(psoc)) 916 return; 917 918 if (wmi_service_enabled(wmi_handle, wmi_service_mlo_tsf_sync)) 919 mlo_tsf_sync_enab = true; 920 921 mlo_update_tsf_sync_support(psoc, mlo_tsf_sync_enab); 922 } 923 924 #else 925 static void init_deinit_mlo_update_soc_ready(struct wlan_objmgr_psoc *psoc) 926 {} 927 static void init_deinit_mlo_update_pdev_ready(struct wlan_objmgr_psoc *psoc, 928 uint8_t num_radios) 929 {} 930 static void 931 init_deinit_pdev_wsi_stats_info_support(struct wmi_unified *wmi_handle, 932 struct wlan_objmgr_psoc *psoc) 933 {} 934 static void init_deinit_mlo_tsf_sync_support(struct wmi_unified *wmi_handle, 935 struct wlan_objmgr_psoc *psoc) 936 {} 937 #endif /*WLAN_FEATURE_11BE_MLO && WLAN_MLO_MULTI_CHIP*/ 938 939 /* MAC address fourth byte index */ 940 #define MAC_BYTE_4 4 941 942 static int init_deinit_ready_event_handler(ol_scn_t scn_handle, 943 uint8_t *event, 944 uint32_t data_len) 945 { 946 struct wlan_objmgr_psoc *psoc; 947 struct wlan_objmgr_pdev *pdev; 948 struct target_psoc_info *tgt_hdl; 949 struct wmi_unified *wmi_handle; 950 struct wmi_host_fw_abi_ver fw_ver; 951 uint8_t myaddr[QDF_MAC_ADDR_SIZE]; 952 struct tgt_info *info; 953 struct wmi_host_ready_ev_param ready_ev; 954 wmi_legacy_service_ready_callback legacy_callback; 955 uint8_t num_radios, i; 956 uint32_t max_peers; 957 uint32_t max_ast_index; 958 target_resource_config *tgt_cfg; 959 960 if (!scn_handle) { 961 target_if_err("scn handle NULL"); 962 return -EINVAL; 963 } 964 965 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 966 if (!psoc) { 967 target_if_err("psoc is null"); 968 return -EINVAL; 969 } 970 971 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 972 if (!tgt_hdl) { 973 target_if_err("target_psoc_info is null"); 974 return -EINVAL; 975 } 976 977 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 978 info = (&tgt_hdl->info); 979 980 if (wmi_extract_fw_abi_version(wmi_handle, event, &fw_ver) == 981 QDF_STATUS_SUCCESS) { 982 info->version.wlan_ver = fw_ver.sw_version; 983 info->version.wlan_ver = fw_ver.abi_version; 984 } 985 986 if (wmi_check_and_update_fw_version(wmi_handle, event) < 0) { 987 target_if_err("Version mismatch with FW"); 988 return -EINVAL; 989 } 990 991 if (wmi_extract_ready_event_params(wmi_handle, event, &ready_ev) != 992 QDF_STATUS_SUCCESS) { 993 target_if_err("Failed to extract ready event"); 994 return -EINVAL; 995 } 996 997 if (!ready_ev.agile_capability) 998 target_if_err("agile capability disabled in HW"); 999 else 1000 info->wlan_res_cfg.agile_capability = ready_ev.agile_capability; 1001 1002 if (ready_ev.num_max_active_vdevs) { 1003 if (ready_ev.num_max_active_vdevs < 1004 info->wlan_res_cfg.num_max_active_vdevs) { 1005 target_if_err("unexpected num_max_active_vdevs fw %d host %d", 1006 ready_ev.num_max_active_vdevs, 1007 info->wlan_res_cfg.num_max_active_vdevs); 1008 info->wlan_res_cfg.num_max_active_vdevs = 1009 ready_ev.num_max_active_vdevs; 1010 } 1011 } 1012 1013 /* Indicate to the waiting thread that the ready 1014 * event was received 1015 */ 1016 info->wlan_init_status = wmi_ready_extract_init_status( 1017 wmi_handle, event); 1018 1019 legacy_callback = target_if_get_psoc_legacy_service_ready_cb(); 1020 if (legacy_callback) 1021 if (legacy_callback(wmi_ready_event_id, 1022 scn_handle, event, data_len)) { 1023 target_if_err("Legacy callback returned error!"); 1024 tgt_hdl->info.wmi_ready = false; 1025 goto exit; 1026 } 1027 1028 init_deinit_mlo_update_soc_ready(psoc); 1029 1030 num_radios = target_psoc_get_num_radios(tgt_hdl); 1031 1032 if ((ready_ev.num_total_peer != 0) && 1033 (info->wlan_res_cfg.num_peers != ready_ev.num_total_peer)) { 1034 uint16_t num_peers = 0; 1035 /* FW allocated number of peers is different than host 1036 * requested. Update host max with FW reported value. 1037 */ 1038 target_if_err("Host Requested %d peers. FW Supports %d peers", 1039 info->wlan_res_cfg.num_peers, 1040 ready_ev.num_total_peer); 1041 info->wlan_res_cfg.num_peers = ready_ev.num_total_peer; 1042 num_peers = info->wlan_res_cfg.num_peers / num_radios; 1043 1044 for (i = 0; i < num_radios; i++) { 1045 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, 1046 WLAN_INIT_DEINIT_ID); 1047 if (!pdev) { 1048 target_if_err(" PDEV %d is NULL", i); 1049 return -EINVAL; 1050 } 1051 1052 wlan_pdev_set_max_peer_count(pdev, num_peers); 1053 wlan_objmgr_pdev_release_ref(pdev, WLAN_INIT_DEINIT_ID); 1054 } 1055 1056 wlan_psoc_set_max_peer_count(psoc, 1057 info->wlan_res_cfg.num_peers); 1058 } 1059 1060 /* for non legacy num_total_peer will be non zero 1061 * allocate peer memory in this case 1062 */ 1063 if (ready_ev.num_total_peer != 0) { 1064 tgt_cfg = &info->wlan_res_cfg; 1065 max_peers = tgt_cfg->num_peers + ready_ev.num_extra_peer + 1; 1066 max_ast_index = ready_ev.max_ast_index + 1; 1067 1068 if (cdp_peer_map_attach(wlan_psoc_get_dp_handle(psoc), 1069 max_peers, max_ast_index, 1070 tgt_cfg->peer_map_unmap_version) != 1071 QDF_STATUS_SUCCESS) { 1072 target_if_err("DP peer map attach failed"); 1073 return -EINVAL; 1074 } 1075 } 1076 1077 1078 if (ready_ev.pktlog_defs_checksum) { 1079 for (i = 0; i < num_radios; i++) { 1080 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, 1081 WLAN_INIT_DEINIT_ID); 1082 if (!pdev) { 1083 target_if_err(" PDEV %d is NULL", i); 1084 return -EINVAL; 1085 } 1086 target_if_set_pktlog_checksum(pdev, tgt_hdl, 1087 ready_ev. 1088 pktlog_defs_checksum); 1089 wlan_objmgr_pdev_release_ref(pdev, WLAN_INIT_DEINIT_ID); 1090 } 1091 } 1092 1093 /* 1094 * For non-legacy HW, MAC addr list is extracted. 1095 */ 1096 if (num_radios > 1) { 1097 uint8_t num_mac_addr; 1098 wmi_host_mac_addr *addr_list; 1099 int i; 1100 1101 addr_list = wmi_ready_extract_mac_addr_list(wmi_handle, event, 1102 &num_mac_addr); 1103 if ((num_mac_addr >= num_radios) && (addr_list)) { 1104 for (i = 0; i < num_radios; i++) { 1105 WMI_HOST_MAC_ADDR_TO_CHAR_ARRAY(&addr_list[i], 1106 myaddr); 1107 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, 1108 WLAN_INIT_DEINIT_ID); 1109 if (!pdev) { 1110 target_if_err(" PDEV %d is NULL", i); 1111 return -EINVAL; 1112 } 1113 wlan_pdev_set_hw_macaddr(pdev, myaddr); 1114 wlan_objmgr_pdev_release_ref(pdev, 1115 WLAN_INIT_DEINIT_ID); 1116 1117 /* assign 1st radio addr to psoc */ 1118 if (i == 0) 1119 wlan_psoc_set_hw_macaddr(psoc, myaddr); 1120 } 1121 goto out; 1122 } else { 1123 target_if_err("Using default MAC addr for all radios.."); 1124 } 1125 } 1126 1127 /* 1128 * We extract single MAC address in two scenarios: 1129 * 1. In non-legacy case, if addr list is NULL or num_mac_addr < num_radios 1130 * 2. In all legacy cases 1131 */ 1132 for (i = 0; i < num_radios; i++) { 1133 wmi_ready_extract_mac_addr(wmi_handle, event, myaddr); 1134 myaddr[MAC_BYTE_4] += i; 1135 pdev = wlan_objmgr_get_pdev_by_id(psoc, i, WLAN_INIT_DEINIT_ID); 1136 if (!pdev) { 1137 target_if_err(" PDEV %d is NULL", i); 1138 return -EINVAL; 1139 } 1140 wlan_pdev_set_hw_macaddr(pdev, myaddr); 1141 wlan_objmgr_pdev_release_ref(pdev, WLAN_INIT_DEINIT_ID); 1142 /* assign 1st radio addr to psoc */ 1143 if (i == 0) 1144 wlan_psoc_set_hw_macaddr(psoc, myaddr); 1145 } 1146 1147 out: 1148 target_if_btcoex_cfg_enable(psoc, tgt_hdl, event); 1149 tgt_hdl->info.wmi_ready = true; 1150 init_deinit_mlo_update_pdev_ready(psoc, num_radios); 1151 exit: 1152 init_deinit_wakeup_host_wait(psoc, tgt_hdl); 1153 1154 return 0; 1155 } 1156 1157 #ifdef HEALTH_MON_SUPPORT 1158 static int init_deinit_health_mon_event_handler(ol_scn_t scn_handle, 1159 uint8_t *event, 1160 uint32_t data_len) 1161 { 1162 struct wlan_objmgr_psoc *psoc; 1163 struct target_psoc_info *tgt_hdl; 1164 struct wmi_unified *wmi_handle; 1165 struct tgt_info *info; 1166 struct wmi_health_mon_params *param; 1167 1168 if (!scn_handle) { 1169 target_if_err("scn handle NULL"); 1170 return -EINVAL; 1171 } 1172 1173 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 1174 if (!psoc) { 1175 target_if_err("psoc is null"); 1176 return -EINVAL; 1177 } 1178 1179 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1180 if (!tgt_hdl) { 1181 target_if_err("target_psoc_info is null"); 1182 return -EINVAL; 1183 } 1184 1185 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 1186 info = (&tgt_hdl->info); 1187 1188 param = (&info->health_mon_param); 1189 wmi_extract_health_mon_event(wmi_handle, event, param); 1190 1191 return 0; 1192 } 1193 #endif /* HEALTH_MON_SUPPORT */ 1194 1195 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 1196 static void init_deinit_mlo_setup_done_event(struct wlan_objmgr_psoc *psoc) 1197 { 1198 struct target_psoc_info *tgt_hdl; 1199 1200 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1201 if (!tgt_hdl) { 1202 target_if_err("target_psoc_info is null"); 1203 return; 1204 } 1205 1206 if ((tgt_hdl->tif_ops) && 1207 (tgt_hdl->tif_ops->mlo_setup_done_event)) 1208 tgt_hdl->tif_ops->mlo_setup_done_event(psoc); 1209 } 1210 1211 static int init_deinit_mlo_setup_comp_event_handler(ol_scn_t scn_handle, 1212 uint8_t *event, 1213 uint32_t data_len) 1214 { 1215 struct wlan_objmgr_psoc *psoc; 1216 struct wlan_objmgr_pdev *pdev; 1217 struct target_psoc_info *tgt_hdl; 1218 struct wmi_unified *wmi_handle; 1219 struct wmi_mlo_setup_complete_params params; 1220 uint8_t grp_id = 0; 1221 1222 if (!scn_handle) { 1223 target_if_err("scn handle NULL"); 1224 return -EINVAL; 1225 } 1226 1227 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 1228 1229 if (!psoc) { 1230 target_if_err("psoc is null"); 1231 return -EINVAL; 1232 } 1233 1234 if (!init_deinit_mlo_get_group_id(psoc, &grp_id)) { 1235 target_if_err("Invalid MLD group id"); 1236 return -EINVAL; 1237 } 1238 1239 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1240 1241 if (!tgt_hdl) { 1242 target_if_err("target_psoc_info is null"); 1243 return -EINVAL; 1244 } 1245 1246 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 1247 1248 if (wmi_extract_mlo_setup_cmpl_event(wmi_handle, event, ¶ms) != 1249 QDF_STATUS_SUCCESS) 1250 return -EINVAL; 1251 1252 pdev = wlan_objmgr_get_pdev_by_id(psoc, params.pdev_id, 1253 WLAN_INIT_DEINIT_ID); 1254 1255 if (mlo_ap_update_max_ml_peer_ids( 1256 params.pdev_id, params.max_ml_peer_ids) 1257 != QDF_STATUS_SUCCESS) { 1258 target_if_err("max_ml_peer_ids update failed for pdev_id: %d", 1259 params.pdev_id); 1260 } 1261 1262 if (pdev) { 1263 mlo_link_setup_complete(pdev, grp_id); 1264 wlan_objmgr_pdev_release_ref(pdev, WLAN_INIT_DEINIT_ID); 1265 } 1266 1267 init_deinit_mlo_setup_done_event(psoc); 1268 1269 return 0; 1270 } 1271 1272 static int init_deinit_mlo_teardown_comp_event_handler(ol_scn_t scn_handle, 1273 uint8_t *event, 1274 uint32_t data_len) 1275 { 1276 struct wlan_objmgr_psoc *psoc; 1277 struct wlan_objmgr_pdev *pdev; 1278 struct target_psoc_info *tgt_hdl; 1279 struct wmi_unified *wmi_handle; 1280 struct wmi_mlo_teardown_cmpl_params params; 1281 uint8_t grp_id = 0; 1282 1283 if (!scn_handle) { 1284 target_if_err("scn handle NULL"); 1285 return -EINVAL; 1286 } 1287 1288 psoc = target_if_get_psoc_from_scn_hdl(scn_handle); 1289 if (!psoc) { 1290 target_if_err("psoc is null"); 1291 return -EINVAL; 1292 } 1293 1294 if (!init_deinit_mlo_get_group_id(psoc, &grp_id)) { 1295 target_if_err("Invalid MLD group id"); 1296 return -EINVAL; 1297 } 1298 1299 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1300 if (!tgt_hdl) { 1301 target_if_err("target_psoc_info is null"); 1302 return -EINVAL; 1303 } 1304 wmi_handle = target_psoc_get_wmi_hdl(tgt_hdl); 1305 1306 if (wmi_extract_mlo_teardown_cmpl_event(wmi_handle, event, ¶ms) != 1307 QDF_STATUS_SUCCESS) 1308 return -EINVAL; 1309 1310 pdev = wlan_objmgr_get_pdev_by_id(psoc, params.pdev_id, 1311 WLAN_INIT_DEINIT_ID); 1312 if (pdev) { 1313 mlo_link_teardown_complete(pdev, grp_id); 1314 wlan_objmgr_pdev_release_ref(pdev, WLAN_INIT_DEINIT_ID); 1315 } 1316 1317 return 0; 1318 } 1319 1320 static QDF_STATUS init_deinit_register_mlo_ev_handlers(wmi_unified_t wmi_handle) 1321 { 1322 wmi_unified_register_event(wmi_handle, 1323 wmi_mlo_setup_complete_event_id, 1324 init_deinit_mlo_setup_comp_event_handler); 1325 wmi_unified_register_event(wmi_handle, 1326 wmi_mlo_teardown_complete_event_id, 1327 init_deinit_mlo_teardown_comp_event_handler); 1328 1329 return QDF_STATUS_SUCCESS; 1330 } 1331 #else 1332 static QDF_STATUS init_deinit_register_mlo_ev_handlers(wmi_unified_t wmi_handle) 1333 { 1334 return QDF_STATUS_SUCCESS; 1335 } 1336 #endif /*WLAN_FEATURE_11BE_MLO && WLAN_MLO_MULTI_CHIP*/ 1337 1338 QDF_STATUS init_deinit_register_tgt_psoc_ev_handlers( 1339 struct wlan_objmgr_psoc *psoc) 1340 { 1341 struct target_psoc_info *tgt_hdl; 1342 wmi_unified_t wmi_handle; 1343 QDF_STATUS retval = QDF_STATUS_SUCCESS; 1344 1345 if (!psoc) { 1346 target_if_err("psoc is null in register wmi handler"); 1347 return QDF_STATUS_E_FAILURE; 1348 } 1349 1350 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc); 1351 if (!tgt_hdl) { 1352 target_if_err("target_psoc_info null in register wmi hadler"); 1353 return QDF_STATUS_E_FAILURE; 1354 } 1355 1356 wmi_handle = (wmi_unified_t)target_psoc_get_wmi_hdl(tgt_hdl); 1357 1358 retval = wmi_unified_register_event_handler(wmi_handle, 1359 wmi_service_ready_event_id, 1360 init_deinit_service_ready_event_handler, 1361 WMI_RX_WORK_CTX); 1362 retval = wmi_unified_register_event_handler(wmi_handle, 1363 wmi_service_ready_ext_event_id, 1364 init_deinit_service_ext_ready_event_handler, 1365 WMI_RX_WORK_CTX); 1366 retval = wmi_unified_register_event_handler(wmi_handle, 1367 wmi_service_available_event_id, 1368 init_deinit_service_available_handler, 1369 WMI_RX_UMAC_CTX); 1370 retval = wmi_unified_register_event_handler(wmi_handle, 1371 wmi_ready_event_id, 1372 init_deinit_ready_event_handler, 1373 WMI_RX_WORK_CTX); 1374 retval = wmi_unified_register_event_handler( 1375 wmi_handle, 1376 wmi_service_ready_ext2_event_id, 1377 init_deinit_service_ext2_ready_event_handler, 1378 WMI_RX_WORK_CTX); 1379 retval = init_deinit_register_mlo_ev_handlers(wmi_handle); 1380 1381 #ifdef HEALTH_MON_SUPPORT 1382 retval = wmi_unified_register_event_handler( 1383 wmi_handle, 1384 wmi_extract_health_mon_init_done_info_eventid, 1385 init_deinit_health_mon_event_handler, 1386 WMI_RX_WORK_CTX); 1387 #endif /* HEALTH_MON_SUPPORT */ 1388 1389 return retval; 1390 } 1391 1392