1 /* 2 * Copyright (c) 2016-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 #include <wlan_ipa_obj_mgmt_api.h> 21 #include <qdf_types.h> 22 #include <qdf_lock.h> 23 #include <qdf_net_types.h> 24 #include <qdf_lro.h> 25 #include <qdf_module.h> 26 #include <hal_hw_headers.h> 27 #include <hal_api.h> 28 #include <hif.h> 29 #include <htt.h> 30 #include <wdi_event.h> 31 #include <queue.h> 32 #include "dp_types.h" 33 #include "dp_rings.h" 34 #include "dp_internal.h" 35 #include "dp_tx.h" 36 #include "dp_tx_desc.h" 37 #include "dp_rx.h" 38 #ifdef DP_RATETABLE_SUPPORT 39 #include "dp_ratetable.h" 40 #endif 41 #include <cdp_txrx_handle.h> 42 #include <wlan_cfg.h> 43 #include <wlan_utility.h> 44 #include "cdp_txrx_cmn_struct.h" 45 #include "cdp_txrx_stats_struct.h" 46 #include "cdp_txrx_cmn_reg.h" 47 #include <qdf_util.h> 48 #include "dp_peer.h" 49 #include "htt_stats.h" 50 #include "dp_htt.h" 51 #ifdef WLAN_SUPPORT_RX_FISA 52 #include <wlan_dp_fisa_rx.h> 53 #endif 54 #include "htt_ppdu_stats.h" 55 #include "qdf_mem.h" /* qdf_mem_malloc,free */ 56 #include "cfg_ucfg_api.h" 57 #include <wlan_module_ids.h> 58 #ifdef QCA_MULTIPASS_SUPPORT 59 #include <enet.h> 60 #endif 61 62 #ifdef QCA_LL_TX_FLOW_CONTROL_V2 63 #include "cdp_txrx_flow_ctrl_v2.h" 64 #else 65 66 static inline void 67 cdp_dump_flow_pool_info(struct cdp_soc_t *soc) 68 { 69 return; 70 } 71 #endif 72 #ifdef WIFI_MONITOR_SUPPORT 73 #include <dp_mon.h> 74 #endif 75 #include "dp_ipa.h" 76 #ifdef FEATURE_WDS 77 #include "dp_txrx_wds.h" 78 #endif 79 #ifdef WLAN_SUPPORT_MSCS 80 #include "dp_mscs.h" 81 #endif 82 #ifdef WLAN_SUPPORT_MESH_LATENCY 83 #include "dp_mesh_latency.h" 84 #endif 85 #ifdef WLAN_SUPPORT_SCS 86 #include "dp_scs.h" 87 #endif 88 #ifdef ATH_SUPPORT_IQUE 89 #include "dp_txrx_me.h" 90 #endif 91 #if defined(DP_CON_MON) 92 #ifndef REMOVE_PKT_LOG 93 #include <pktlog_ac_api.h> 94 #include <pktlog_ac.h> 95 #endif 96 #endif 97 #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR 98 #include <wlan_dp_swlm.h> 99 #endif 100 #ifdef WLAN_DP_PROFILE_SUPPORT 101 #include <wlan_dp_main.h> 102 #endif 103 #ifdef CONFIG_SAWF_DEF_QUEUES 104 #include "dp_sawf.h" 105 #endif 106 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 107 #include "dp_rx_tag.h" 108 #endif 109 #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF 110 #include <target_if_dp.h> 111 #endif 112 113 #if defined(DP_PEER_EXTENDED_API) || defined(WLAN_DP_PENDING_MEM_FLUSH) 114 #define SET_PEER_REF_CNT_ONE(_peer) \ 115 qdf_atomic_set(&(_peer)->ref_cnt, 1) 116 #else 117 #define SET_PEER_REF_CNT_ONE(_peer) 118 #endif 119 120 #ifdef WLAN_SYSFS_DP_STATS 121 /* sysfs event wait time for firmware stat request unit milliseconds */ 122 #define WLAN_SYSFS_STAT_REQ_WAIT_MS 3000 123 #endif 124 125 #ifdef QCA_DP_TX_FW_METADATA_V2 126 #define DP_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) \ 127 HTT_TX_TCL_METADATA_V2_PDEV_ID_SET(_var, _val) 128 #else 129 #define DP_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) \ 130 HTT_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) 131 #endif 132 133 QDF_COMPILE_TIME_ASSERT(max_rx_rings_check, 134 MAX_REO_DEST_RINGS == CDP_MAX_RX_RINGS); 135 136 QDF_COMPILE_TIME_ASSERT(max_tx_rings_check, 137 MAX_TCL_DATA_RINGS == CDP_MAX_TX_COMP_RINGS); 138 139 void dp_configure_arch_ops(struct dp_soc *soc); 140 qdf_size_t dp_get_soc_context_size(uint16_t device_id); 141 142 /* 143 * The max size of cdp_peer_stats_param_t is limited to 16 bytes. 144 * If the buffer size is exceeding this size limit, 145 * dp_txrx_get_peer_stats is to be used instead. 146 */ 147 QDF_COMPILE_TIME_ASSERT(cdp_peer_stats_param_t_max_size, 148 (sizeof(cdp_peer_stats_param_t) <= 16)); 149 150 #ifdef WLAN_FEATURE_DP_EVENT_HISTORY 151 /* 152 * If WLAN_CFG_INT_NUM_CONTEXTS is changed, HIF_NUM_INT_CONTEXTS 153 * also should be updated accordingly 154 */ 155 QDF_COMPILE_TIME_ASSERT(num_intr_grps, 156 HIF_NUM_INT_CONTEXTS == WLAN_CFG_INT_NUM_CONTEXTS); 157 158 /* 159 * HIF_EVENT_HIST_MAX should always be power of 2 160 */ 161 QDF_COMPILE_TIME_ASSERT(hif_event_history_size, 162 (HIF_EVENT_HIST_MAX & (HIF_EVENT_HIST_MAX - 1)) == 0); 163 #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ 164 165 /* 166 * If WLAN_CFG_INT_NUM_CONTEXTS is changed, 167 * WLAN_CFG_INT_NUM_CONTEXTS_MAX should also be updated 168 */ 169 QDF_COMPILE_TIME_ASSERT(wlan_cfg_num_int_ctxs, 170 WLAN_CFG_INT_NUM_CONTEXTS_MAX >= 171 WLAN_CFG_INT_NUM_CONTEXTS); 172 173 static void dp_soc_unset_qref_debug_list(struct dp_soc *soc); 174 static QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl); 175 static QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl); 176 177 static void dp_pdev_srng_deinit(struct dp_pdev *pdev); 178 static QDF_STATUS dp_pdev_srng_init(struct dp_pdev *pdev); 179 static void dp_pdev_srng_free(struct dp_pdev *pdev); 180 static QDF_STATUS dp_pdev_srng_alloc(struct dp_pdev *pdev); 181 182 static inline 183 QDF_STATUS dp_pdev_attach_wifi3(struct cdp_soc_t *txrx_soc, 184 struct cdp_pdev_attach_params *params); 185 186 static int dp_pdev_post_attach_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id); 187 188 static QDF_STATUS 189 dp_pdev_init_wifi3(struct cdp_soc_t *txrx_soc, 190 HTC_HANDLE htc_handle, 191 qdf_device_t qdf_osdev, 192 uint8_t pdev_id); 193 194 static QDF_STATUS 195 dp_pdev_deinit_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, int force); 196 197 static void dp_soc_detach_wifi3(struct cdp_soc_t *txrx_soc); 198 static void dp_soc_deinit_wifi3(struct cdp_soc_t *txrx_soc); 199 200 static void dp_pdev_detach(struct cdp_pdev *txrx_pdev, int force); 201 static QDF_STATUS dp_pdev_detach_wifi3(struct cdp_soc_t *psoc, 202 uint8_t pdev_id, 203 int force); 204 static struct dp_soc * 205 dp_soc_attach(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, 206 struct cdp_soc_attach_params *params); 207 static inline QDF_STATUS dp_peer_create_wifi3(struct cdp_soc_t *soc_hdl, 208 uint8_t vdev_id, 209 uint8_t *peer_mac_addr, 210 enum cdp_peer_type peer_type); 211 static QDF_STATUS dp_peer_delete_wifi3(struct cdp_soc_t *soc_hdl, 212 uint8_t vdev_id, 213 uint8_t *peer_mac, uint32_t bitmap, 214 enum cdp_peer_type peer_type); 215 static void dp_vdev_flush_peers(struct cdp_vdev *vdev_handle, 216 bool unmap_only, 217 bool mlo_peers_only); 218 #ifdef ENABLE_VERBOSE_DEBUG 219 bool is_dp_verbose_debug_enabled; 220 #endif 221 222 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) 223 static bool dp_get_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); 224 static void dp_set_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 225 bool enable); 226 static inline void 227 dp_get_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 228 struct cdp_cfr_rcc_stats *cfr_rcc_stats); 229 static inline void 230 dp_clear_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); 231 #endif 232 233 #ifdef DP_UMAC_HW_RESET_SUPPORT 234 static QDF_STATUS dp_umac_reset_action_trigger_recovery(struct dp_soc *soc); 235 static QDF_STATUS dp_umac_reset_handle_pre_reset(struct dp_soc *soc); 236 static QDF_STATUS dp_umac_reset_handle_post_reset(struct dp_soc *soc); 237 static QDF_STATUS dp_umac_reset_handle_post_reset_complete(struct dp_soc *soc); 238 #endif 239 240 #define MON_VDEV_TIMER_INIT 0x1 241 #define MON_VDEV_TIMER_RUNNING 0x2 242 243 #define DP_MCS_LENGTH (6*MAX_MCS) 244 245 #define DP_CURR_FW_STATS_AVAIL 19 246 #define DP_HTT_DBG_EXT_STATS_MAX 256 247 #define DP_MAX_SLEEP_TIME 100 248 #ifndef QCA_WIFI_3_0_EMU 249 #define SUSPEND_DRAIN_WAIT 500 250 #else 251 #define SUSPEND_DRAIN_WAIT 3000 252 #endif 253 254 #ifdef IPA_OFFLOAD 255 /* Exclude IPA rings from the interrupt context */ 256 #define TX_RING_MASK_VAL 0xb 257 #define RX_RING_MASK_VAL 0x7 258 #else 259 #define TX_RING_MASK_VAL 0xF 260 #define RX_RING_MASK_VAL 0xF 261 #endif 262 263 #define STR_MAXLEN 64 264 265 #define RNG_ERR "SRNG setup failed for" 266 267 /** 268 * enum dp_stats_type - Select the type of statistics 269 * @STATS_FW: Firmware-based statistic 270 * @STATS_HOST: Host-based statistic 271 * @STATS_TYPE_MAX: maximum enumeration 272 */ 273 enum dp_stats_type { 274 STATS_FW = 0, 275 STATS_HOST = 1, 276 STATS_TYPE_MAX = 2, 277 }; 278 279 /** 280 * enum dp_fw_stats - General Firmware statistics options 281 * @TXRX_FW_STATS_INVALID: statistic is not available 282 */ 283 enum dp_fw_stats { 284 TXRX_FW_STATS_INVALID = -1, 285 }; 286 287 /* 288 * dp_stats_mapping_table - Firmware and Host statistics 289 * currently supported 290 */ 291 #ifndef WLAN_SOFTUMAC_SUPPORT 292 const int dp_stats_mapping_table[][STATS_TYPE_MAX] = { 293 {HTT_DBG_EXT_STATS_RESET, TXRX_HOST_STATS_INVALID}, 294 {HTT_DBG_EXT_STATS_PDEV_TX, TXRX_HOST_STATS_INVALID}, 295 {HTT_DBG_EXT_STATS_PDEV_RX, TXRX_HOST_STATS_INVALID}, 296 {HTT_DBG_EXT_STATS_PDEV_TX_HWQ, TXRX_HOST_STATS_INVALID}, 297 {HTT_DBG_EXT_STATS_PDEV_TX_SCHED, TXRX_HOST_STATS_INVALID}, 298 {HTT_DBG_EXT_STATS_PDEV_ERROR, TXRX_HOST_STATS_INVALID}, 299 {HTT_DBG_EXT_STATS_PDEV_TQM, TXRX_HOST_STATS_INVALID}, 300 {HTT_DBG_EXT_STATS_TQM_CMDQ, TXRX_HOST_STATS_INVALID}, 301 {HTT_DBG_EXT_STATS_TX_DE_INFO, TXRX_HOST_STATS_INVALID}, 302 {HTT_DBG_EXT_STATS_PDEV_TX_RATE, TXRX_HOST_STATS_INVALID}, 303 {HTT_DBG_EXT_STATS_PDEV_RX_RATE, TXRX_HOST_STATS_INVALID}, 304 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 305 {HTT_DBG_EXT_STATS_TX_SELFGEN_INFO, TXRX_HOST_STATS_INVALID}, 306 {HTT_DBG_EXT_STATS_TX_MU_HWQ, TXRX_HOST_STATS_INVALID}, 307 {HTT_DBG_EXT_STATS_RING_IF_INFO, TXRX_HOST_STATS_INVALID}, 308 {HTT_DBG_EXT_STATS_SRNG_INFO, TXRX_HOST_STATS_INVALID}, 309 {HTT_DBG_EXT_STATS_SFM_INFO, TXRX_HOST_STATS_INVALID}, 310 {HTT_DBG_EXT_STATS_PDEV_TX_MU, TXRX_HOST_STATS_INVALID}, 311 {HTT_DBG_EXT_STATS_ACTIVE_PEERS_LIST, TXRX_HOST_STATS_INVALID}, 312 /* Last ENUM for HTT FW STATS */ 313 {DP_HTT_DBG_EXT_STATS_MAX, TXRX_HOST_STATS_INVALID}, 314 {TXRX_FW_STATS_INVALID, TXRX_CLEAR_STATS}, 315 {TXRX_FW_STATS_INVALID, TXRX_RX_RATE_STATS}, 316 {TXRX_FW_STATS_INVALID, TXRX_TX_RATE_STATS}, 317 {TXRX_FW_STATS_INVALID, TXRX_TX_HOST_STATS}, 318 {TXRX_FW_STATS_INVALID, TXRX_RX_HOST_STATS}, 319 {TXRX_FW_STATS_INVALID, TXRX_AST_STATS}, 320 {TXRX_FW_STATS_INVALID, TXRX_SRNG_PTR_STATS}, 321 {TXRX_FW_STATS_INVALID, TXRX_RX_MON_STATS}, 322 {TXRX_FW_STATS_INVALID, TXRX_REO_QUEUE_STATS}, 323 {TXRX_FW_STATS_INVALID, TXRX_SOC_CFG_PARAMS}, 324 {TXRX_FW_STATS_INVALID, TXRX_PDEV_CFG_PARAMS}, 325 {TXRX_FW_STATS_INVALID, TXRX_NAPI_STATS}, 326 {TXRX_FW_STATS_INVALID, TXRX_SOC_INTERRUPT_STATS}, 327 {TXRX_FW_STATS_INVALID, TXRX_SOC_FSE_STATS}, 328 {TXRX_FW_STATS_INVALID, TXRX_HAL_REG_WRITE_STATS}, 329 {TXRX_FW_STATS_INVALID, TXRX_SOC_REO_HW_DESC_DUMP}, 330 {TXRX_FW_STATS_INVALID, TXRX_SOC_WBM_IDLE_HPTP_DUMP}, 331 {TXRX_FW_STATS_INVALID, TXRX_SRNG_USAGE_WM_STATS}, 332 {HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, TXRX_HOST_STATS_INVALID}, 333 {HTT_DBG_EXT_STATS_TX_SOUNDING_INFO, TXRX_HOST_STATS_INVALID}, 334 {TXRX_FW_STATS_INVALID, TXRX_PEER_STATS}, 335 }; 336 #else 337 const int dp_stats_mapping_table[][STATS_TYPE_MAX] = { 338 {HTT_DBG_EXT_STATS_RESET, TXRX_HOST_STATS_INVALID}, 339 {HTT_DBG_EXT_STATS_PDEV_TX, TXRX_HOST_STATS_INVALID}, 340 {HTT_DBG_EXT_STATS_PDEV_RX, TXRX_HOST_STATS_INVALID}, 341 {HTT_DBG_EXT_STATS_PDEV_TX_HWQ, TXRX_HOST_STATS_INVALID}, 342 {HTT_DBG_EXT_STATS_PDEV_TX_SCHED, TXRX_HOST_STATS_INVALID}, 343 {HTT_DBG_EXT_STATS_PDEV_ERROR, TXRX_HOST_STATS_INVALID}, 344 {HTT_DBG_EXT_STATS_PDEV_TQM, TXRX_HOST_STATS_INVALID}, 345 {HTT_DBG_EXT_STATS_TQM_CMDQ, TXRX_HOST_STATS_INVALID}, 346 {HTT_DBG_EXT_STATS_TX_DE_INFO, TXRX_HOST_STATS_INVALID}, 347 {HTT_DBG_EXT_STATS_PDEV_TX_RATE, TXRX_HOST_STATS_INVALID}, 348 {HTT_DBG_EXT_STATS_PDEV_RX_RATE, TXRX_HOST_STATS_INVALID}, 349 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 350 {HTT_DBG_EXT_STATS_TX_SELFGEN_INFO, TXRX_HOST_STATS_INVALID}, 351 {HTT_DBG_EXT_STATS_TX_MU_HWQ, TXRX_HOST_STATS_INVALID}, 352 {HTT_DBG_EXT_STATS_RING_IF_INFO, TXRX_HOST_STATS_INVALID}, 353 {HTT_DBG_EXT_STATS_SRNG_INFO, TXRX_HOST_STATS_INVALID}, 354 {HTT_DBG_EXT_STATS_SFM_INFO, TXRX_HOST_STATS_INVALID}, 355 {HTT_DBG_EXT_STATS_PDEV_TX_MU, TXRX_HOST_STATS_INVALID}, 356 {HTT_DBG_EXT_STATS_ACTIVE_PEERS_LIST, TXRX_HOST_STATS_INVALID}, 357 /* Last ENUM for HTT FW STATS */ 358 {DP_HTT_DBG_EXT_STATS_MAX, TXRX_HOST_STATS_INVALID}, 359 {TXRX_FW_STATS_INVALID, TXRX_CLEAR_STATS}, 360 {TXRX_FW_STATS_INVALID, TXRX_RX_RATE_STATS}, 361 {TXRX_FW_STATS_INVALID, TXRX_TX_RATE_STATS}, 362 {TXRX_FW_STATS_INVALID, TXRX_TX_HOST_STATS}, 363 {TXRX_FW_STATS_INVALID, TXRX_RX_HOST_STATS}, 364 {TXRX_FW_STATS_INVALID, TXRX_AST_STATS}, 365 {TXRX_FW_STATS_INVALID, TXRX_SRNG_PTR_STATS}, 366 {TXRX_FW_STATS_INVALID, TXRX_RX_MON_STATS}, 367 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 368 {TXRX_FW_STATS_INVALID, TXRX_SOC_CFG_PARAMS}, 369 {TXRX_FW_STATS_INVALID, TXRX_PDEV_CFG_PARAMS}, 370 {TXRX_FW_STATS_INVALID, TXRX_NAPI_STATS}, 371 {TXRX_FW_STATS_INVALID, TXRX_SOC_INTERRUPT_STATS}, 372 {TXRX_FW_STATS_INVALID, TXRX_SOC_FSE_STATS}, 373 {TXRX_FW_STATS_INVALID, TXRX_HAL_REG_WRITE_STATS}, 374 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 375 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 376 {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, 377 {HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, TXRX_HOST_STATS_INVALID}, 378 {HTT_DBG_EXT_STATS_TX_SOUNDING_INFO, TXRX_HOST_STATS_INVALID} 379 }; 380 #endif 381 382 /* MCL specific functions */ 383 #if defined(DP_CON_MON) 384 385 #ifdef IPA_OFFLOAD 386 /** 387 * dp_get_num_rx_contexts() - get number of RX contexts 388 * @soc_hdl: cdp opaque soc handle 389 * 390 * Return: number of RX contexts 391 */ 392 static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) 393 { 394 int num_rx_contexts; 395 uint32_t reo_ring_map; 396 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 397 398 reo_ring_map = wlan_cfg_get_reo_rings_mapping(soc->wlan_cfg_ctx); 399 400 switch (soc->arch_id) { 401 case CDP_ARCH_TYPE_BE: 402 /* 2 REO rings are used for IPA */ 403 reo_ring_map &= ~(BIT(3) | BIT(7)); 404 405 break; 406 case CDP_ARCH_TYPE_LI: 407 /* 1 REO ring is used for IPA */ 408 reo_ring_map &= ~BIT(3); 409 break; 410 default: 411 dp_err("unknown arch_id 0x%x", soc->arch_id); 412 QDF_BUG(0); 413 } 414 /* 415 * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled 416 * in future 417 */ 418 num_rx_contexts = qdf_get_hweight32(reo_ring_map); 419 420 return num_rx_contexts; 421 } 422 #else 423 #ifdef WLAN_SOFTUMAC_SUPPORT 424 static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) 425 { 426 uint32_t rx_rings_config; 427 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 428 429 rx_rings_config = wlan_cfg_get_rx_rings_mapping(soc->wlan_cfg_ctx); 430 /* 431 * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled 432 * in future 433 */ 434 return qdf_get_hweight32(rx_rings_config); 435 } 436 #else 437 static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) 438 { 439 int num_rx_contexts; 440 uint32_t reo_config; 441 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 442 443 reo_config = wlan_cfg_get_reo_rings_mapping(soc->wlan_cfg_ctx); 444 /* 445 * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled 446 * in future 447 */ 448 num_rx_contexts = qdf_get_hweight32(reo_config); 449 450 return num_rx_contexts; 451 } 452 #endif /* WLAN_SOFTUMAC_SUPPORT */ 453 #endif 454 455 #endif 456 457 #ifdef FEATURE_MEC 458 void dp_peer_mec_flush_entries(struct dp_soc *soc) 459 { 460 unsigned int index; 461 struct dp_mec_entry *mecentry, *mecentry_next; 462 463 TAILQ_HEAD(, dp_mec_entry) free_list; 464 TAILQ_INIT(&free_list); 465 466 if (!soc->mec_hash.mask) 467 return; 468 469 if (!soc->mec_hash.bins) 470 return; 471 472 if (!qdf_atomic_read(&soc->mec_cnt)) 473 return; 474 475 qdf_spin_lock_bh(&soc->mec_lock); 476 for (index = 0; index <= soc->mec_hash.mask; index++) { 477 if (!TAILQ_EMPTY(&soc->mec_hash.bins[index])) { 478 TAILQ_FOREACH_SAFE(mecentry, &soc->mec_hash.bins[index], 479 hash_list_elem, mecentry_next) { 480 dp_peer_mec_detach_entry(soc, mecentry, &free_list); 481 } 482 } 483 } 484 qdf_spin_unlock_bh(&soc->mec_lock); 485 486 dp_peer_mec_free_list(soc, &free_list); 487 } 488 489 /** 490 * dp_print_mec_stats() - Dump MEC entries in table 491 * @soc: Datapath soc handle 492 * 493 * Return: none 494 */ 495 static void dp_print_mec_stats(struct dp_soc *soc) 496 { 497 int i; 498 uint32_t index; 499 struct dp_mec_entry *mecentry = NULL, *mec_list; 500 uint32_t num_entries = 0; 501 502 DP_PRINT_STATS("MEC Stats:"); 503 DP_PRINT_STATS(" Entries Added = %d", soc->stats.mec.added); 504 DP_PRINT_STATS(" Entries Deleted = %d", soc->stats.mec.deleted); 505 506 if (!qdf_atomic_read(&soc->mec_cnt)) 507 return; 508 509 mec_list = qdf_mem_malloc(sizeof(*mecentry) * DP_PEER_MAX_MEC_ENTRY); 510 if (!mec_list) { 511 dp_peer_warn("%pK: failed to allocate mec_list", soc); 512 return; 513 } 514 515 DP_PRINT_STATS("MEC Table:"); 516 for (index = 0; index <= soc->mec_hash.mask; index++) { 517 qdf_spin_lock_bh(&soc->mec_lock); 518 if (TAILQ_EMPTY(&soc->mec_hash.bins[index])) { 519 qdf_spin_unlock_bh(&soc->mec_lock); 520 continue; 521 } 522 523 TAILQ_FOREACH(mecentry, &soc->mec_hash.bins[index], 524 hash_list_elem) { 525 qdf_mem_copy(&mec_list[num_entries], mecentry, 526 sizeof(*mecentry)); 527 num_entries++; 528 } 529 qdf_spin_unlock_bh(&soc->mec_lock); 530 } 531 532 if (!num_entries) { 533 qdf_mem_free(mec_list); 534 return; 535 } 536 537 for (i = 0; i < num_entries; i++) { 538 DP_PRINT_STATS("%6d mac_addr = " QDF_MAC_ADDR_FMT 539 " is_active = %d pdev_id = %d vdev_id = %d", 540 i, 541 QDF_MAC_ADDR_REF(mec_list[i].mac_addr.raw), 542 mec_list[i].is_active, 543 mec_list[i].pdev_id, 544 mec_list[i].vdev_id); 545 } 546 qdf_mem_free(mec_list); 547 } 548 #else 549 static void dp_print_mec_stats(struct dp_soc *soc) 550 { 551 } 552 #endif 553 554 static int dp_peer_add_ast_wifi3(struct cdp_soc_t *soc_hdl, 555 uint8_t vdev_id, 556 uint8_t *peer_mac, 557 uint8_t *mac_addr, 558 enum cdp_txrx_ast_entry_type type, 559 uint32_t flags) 560 { 561 int ret = -1; 562 QDF_STATUS status = QDF_STATUS_SUCCESS; 563 struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc_hdl, 564 peer_mac, 0, vdev_id, 565 DP_MOD_ID_CDP); 566 567 if (!peer) { 568 dp_peer_debug("Peer is NULL!"); 569 return ret; 570 } 571 572 status = dp_peer_add_ast((struct dp_soc *)soc_hdl, 573 peer, 574 mac_addr, 575 type, 576 flags); 577 if ((status == QDF_STATUS_SUCCESS) || 578 (status == QDF_STATUS_E_ALREADY) || 579 (status == QDF_STATUS_E_AGAIN)) 580 ret = 0; 581 582 dp_hmwds_ast_add_notify(peer, mac_addr, 583 type, status, false); 584 585 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 586 587 return ret; 588 } 589 590 static int dp_peer_update_ast_wifi3(struct cdp_soc_t *soc_hdl, 591 uint8_t vdev_id, 592 uint8_t *peer_mac, 593 uint8_t *wds_macaddr, 594 uint32_t flags) 595 { 596 int status = -1; 597 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 598 struct dp_ast_entry *ast_entry = NULL; 599 struct dp_peer *peer; 600 601 if (soc->ast_offload_support) 602 return status; 603 604 peer = dp_peer_find_hash_find((struct dp_soc *)soc_hdl, 605 peer_mac, 0, vdev_id, 606 DP_MOD_ID_CDP); 607 608 if (!peer) { 609 dp_peer_debug("Peer is NULL!"); 610 return status; 611 } 612 613 qdf_spin_lock_bh(&soc->ast_lock); 614 ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, wds_macaddr, 615 peer->vdev->pdev->pdev_id); 616 617 if (ast_entry) { 618 status = dp_peer_update_ast(soc, 619 peer, 620 ast_entry, flags); 621 } 622 qdf_spin_unlock_bh(&soc->ast_lock); 623 624 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 625 626 return status; 627 } 628 629 /** 630 * dp_peer_reset_ast_entries() - Deletes all HMWDS entries for a peer 631 * @soc: Datapath SOC handle 632 * @peer: DP peer 633 * @arg: callback argument 634 * 635 * Return: None 636 */ 637 static void 638 dp_peer_reset_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) 639 { 640 struct dp_ast_entry *ast_entry = NULL; 641 struct dp_ast_entry *tmp_ast_entry; 642 643 DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, tmp_ast_entry) { 644 if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) || 645 (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)) 646 dp_peer_del_ast(soc, ast_entry); 647 } 648 } 649 650 /** 651 * dp_wds_reset_ast_wifi3() - Reset the is_active param for ast entry 652 * @soc_hdl: Datapath SOC handle 653 * @wds_macaddr: WDS entry MAC Address 654 * @peer_mac_addr: WDS entry MAC Address 655 * @vdev_id: id of vdev handle 656 * 657 * Return: QDF_STATUS 658 */ 659 static QDF_STATUS dp_wds_reset_ast_wifi3(struct cdp_soc_t *soc_hdl, 660 uint8_t *wds_macaddr, 661 uint8_t *peer_mac_addr, 662 uint8_t vdev_id) 663 { 664 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 665 struct dp_ast_entry *ast_entry = NULL; 666 struct dp_peer *peer; 667 struct dp_pdev *pdev; 668 struct dp_vdev *vdev; 669 670 if (soc->ast_offload_support) 671 return QDF_STATUS_E_FAILURE; 672 673 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 674 675 if (!vdev) 676 return QDF_STATUS_E_FAILURE; 677 678 pdev = vdev->pdev; 679 680 if (peer_mac_addr) { 681 peer = dp_peer_find_hash_find(soc, peer_mac_addr, 682 0, vdev->vdev_id, 683 DP_MOD_ID_CDP); 684 if (!peer) { 685 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 686 return QDF_STATUS_E_FAILURE; 687 } 688 689 qdf_spin_lock_bh(&soc->ast_lock); 690 dp_peer_reset_ast_entries(soc, peer, NULL); 691 qdf_spin_unlock_bh(&soc->ast_lock); 692 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 693 } else if (wds_macaddr) { 694 qdf_spin_lock_bh(&soc->ast_lock); 695 ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, wds_macaddr, 696 pdev->pdev_id); 697 698 if (ast_entry) { 699 if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) || 700 (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)) 701 dp_peer_del_ast(soc, ast_entry); 702 } 703 qdf_spin_unlock_bh(&soc->ast_lock); 704 } 705 706 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 707 return QDF_STATUS_SUCCESS; 708 } 709 710 /** 711 * dp_wds_reset_ast_table_wifi3() - Reset the is_active param for all ast entry 712 * @soc_hdl: Datapath SOC handle 713 * @vdev_id: id of vdev object 714 * 715 * Return: QDF_STATUS 716 */ 717 static QDF_STATUS 718 dp_wds_reset_ast_table_wifi3(struct cdp_soc_t *soc_hdl, 719 uint8_t vdev_id) 720 { 721 struct dp_soc *soc = (struct dp_soc *) soc_hdl; 722 723 if (soc->ast_offload_support) 724 return QDF_STATUS_SUCCESS; 725 726 qdf_spin_lock_bh(&soc->ast_lock); 727 728 dp_soc_iterate_peer(soc, dp_peer_reset_ast_entries, NULL, 729 DP_MOD_ID_CDP); 730 qdf_spin_unlock_bh(&soc->ast_lock); 731 732 return QDF_STATUS_SUCCESS; 733 } 734 735 /** 736 * dp_peer_flush_ast_entries() - Delete all wds and hmwds ast entries of a peer 737 * @soc: Datapath SOC 738 * @peer: Datapath peer 739 * @arg: arg to callback 740 * 741 * Return: None 742 */ 743 static void 744 dp_peer_flush_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) 745 { 746 struct dp_ast_entry *ase = NULL; 747 struct dp_ast_entry *temp_ase; 748 749 DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) { 750 if ((ase->type == 751 CDP_TXRX_AST_TYPE_STATIC) || 752 (ase->type == 753 CDP_TXRX_AST_TYPE_SELF) || 754 (ase->type == 755 CDP_TXRX_AST_TYPE_STA_BSS)) 756 continue; 757 dp_peer_del_ast(soc, ase); 758 } 759 } 760 761 /** 762 * dp_wds_flush_ast_table_wifi3() - Delete all wds and hmwds ast entry 763 * @soc_hdl: Datapath SOC handle 764 * 765 * Return: None 766 */ 767 static void dp_wds_flush_ast_table_wifi3(struct cdp_soc_t *soc_hdl) 768 { 769 struct dp_soc *soc = (struct dp_soc *) soc_hdl; 770 771 qdf_spin_lock_bh(&soc->ast_lock); 772 773 dp_soc_iterate_peer(soc, dp_peer_flush_ast_entries, NULL, 774 DP_MOD_ID_CDP); 775 776 qdf_spin_unlock_bh(&soc->ast_lock); 777 dp_peer_mec_flush_entries(soc); 778 } 779 780 #if defined(IPA_WDS_EASYMESH_FEATURE) && defined(FEATURE_AST) 781 /** 782 * dp_peer_send_wds_disconnect() - Send Disconnect event to IPA for each peer 783 * @soc: Datapath SOC 784 * @peer: Datapath peer 785 * 786 * Return: None 787 */ 788 static void 789 dp_peer_send_wds_disconnect(struct dp_soc *soc, struct dp_peer *peer) 790 { 791 struct dp_ast_entry *ase = NULL; 792 struct dp_ast_entry *temp_ase; 793 794 DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) { 795 if (ase->type == CDP_TXRX_AST_TYPE_WDS) { 796 soc->cdp_soc.ol_ops->peer_send_wds_disconnect(soc->ctrl_psoc, 797 ase->mac_addr.raw, 798 ase->vdev_id); 799 } 800 } 801 } 802 #elif defined(FEATURE_AST) 803 static void 804 dp_peer_send_wds_disconnect(struct dp_soc *soc, struct dp_peer *peer) 805 { 806 } 807 #endif 808 809 /** 810 * dp_peer_check_ast_offload() - check ast offload support is enable or not 811 * @soc: soc handle 812 * 813 * Return: false in case of IPA and true/false in IPQ case 814 * 815 */ 816 #if defined(IPA_OFFLOAD) && defined(QCA_WIFI_QCN9224) 817 static inline bool dp_peer_check_ast_offload(struct dp_soc *soc) 818 { 819 return false; 820 } 821 #else 822 static inline bool dp_peer_check_ast_offload(struct dp_soc *soc) 823 { 824 if (soc->ast_offload_support) 825 return true; 826 827 return false; 828 } 829 #endif 830 831 /** 832 * dp_peer_get_ast_info_by_soc_wifi3() - search the soc AST hash table 833 * and return ast entry information 834 * of first ast entry found in the 835 * table with given mac address 836 * @soc_hdl: data path soc handle 837 * @ast_mac_addr: AST entry mac address 838 * @ast_entry_info: ast entry information 839 * 840 * Return: true if ast entry found with ast_mac_addr 841 * false if ast entry not found 842 */ 843 static bool dp_peer_get_ast_info_by_soc_wifi3 844 (struct cdp_soc_t *soc_hdl, 845 uint8_t *ast_mac_addr, 846 struct cdp_ast_entry_info *ast_entry_info) 847 { 848 struct dp_ast_entry *ast_entry = NULL; 849 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 850 struct dp_peer *peer = NULL; 851 852 if (dp_peer_check_ast_offload(soc)) 853 return false; 854 855 qdf_spin_lock_bh(&soc->ast_lock); 856 857 ast_entry = dp_peer_ast_hash_find_soc(soc, ast_mac_addr); 858 if ((!ast_entry) || 859 (ast_entry->delete_in_progress && !ast_entry->callback)) { 860 qdf_spin_unlock_bh(&soc->ast_lock); 861 return false; 862 } 863 864 peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id, 865 DP_MOD_ID_AST); 866 if (!peer) { 867 qdf_spin_unlock_bh(&soc->ast_lock); 868 return false; 869 } 870 871 ast_entry_info->type = ast_entry->type; 872 ast_entry_info->pdev_id = ast_entry->pdev_id; 873 ast_entry_info->vdev_id = ast_entry->vdev_id; 874 ast_entry_info->peer_id = ast_entry->peer_id; 875 qdf_mem_copy(&ast_entry_info->peer_mac_addr[0], 876 &peer->mac_addr.raw[0], 877 QDF_MAC_ADDR_SIZE); 878 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 879 qdf_spin_unlock_bh(&soc->ast_lock); 880 return true; 881 } 882 883 /** 884 * dp_peer_get_ast_info_by_pdevid_wifi3() - search the soc AST hash table 885 * and return ast entry information 886 * if mac address and pdev_id matches 887 * @soc_hdl: data path soc handle 888 * @ast_mac_addr: AST entry mac address 889 * @pdev_id: pdev_id 890 * @ast_entry_info: ast entry information 891 * 892 * Return: true if ast entry found with ast_mac_addr 893 * false if ast entry not found 894 */ 895 static bool dp_peer_get_ast_info_by_pdevid_wifi3 896 (struct cdp_soc_t *soc_hdl, 897 uint8_t *ast_mac_addr, 898 uint8_t pdev_id, 899 struct cdp_ast_entry_info *ast_entry_info) 900 { 901 struct dp_ast_entry *ast_entry; 902 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 903 struct dp_peer *peer = NULL; 904 905 if (soc->ast_offload_support) 906 return false; 907 908 qdf_spin_lock_bh(&soc->ast_lock); 909 910 ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, ast_mac_addr, 911 pdev_id); 912 913 if ((!ast_entry) || 914 (ast_entry->delete_in_progress && !ast_entry->callback)) { 915 qdf_spin_unlock_bh(&soc->ast_lock); 916 return false; 917 } 918 919 peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id, 920 DP_MOD_ID_AST); 921 if (!peer) { 922 qdf_spin_unlock_bh(&soc->ast_lock); 923 return false; 924 } 925 926 ast_entry_info->type = ast_entry->type; 927 ast_entry_info->pdev_id = ast_entry->pdev_id; 928 ast_entry_info->vdev_id = ast_entry->vdev_id; 929 ast_entry_info->peer_id = ast_entry->peer_id; 930 qdf_mem_copy(&ast_entry_info->peer_mac_addr[0], 931 &peer->mac_addr.raw[0], 932 QDF_MAC_ADDR_SIZE); 933 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 934 qdf_spin_unlock_bh(&soc->ast_lock); 935 return true; 936 } 937 938 /** 939 * dp_peer_ast_entry_del_by_soc() - delete the ast entry from soc AST hash table 940 * with given mac address 941 * @soc_handle: data path soc handle 942 * @mac_addr: AST entry mac address 943 * @callback: callback function to called on ast delete response from FW 944 * @cookie: argument to be passed to callback 945 * 946 * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 947 * is sent 948 * QDF_STATUS_E_INVAL false if ast entry not found 949 */ 950 static QDF_STATUS dp_peer_ast_entry_del_by_soc(struct cdp_soc_t *soc_handle, 951 uint8_t *mac_addr, 952 txrx_ast_free_cb callback, 953 void *cookie) 954 955 { 956 struct dp_soc *soc = (struct dp_soc *)soc_handle; 957 struct dp_ast_entry *ast_entry = NULL; 958 txrx_ast_free_cb cb = NULL; 959 void *arg = NULL; 960 961 if (soc->ast_offload_support) 962 return -QDF_STATUS_E_INVAL; 963 964 qdf_spin_lock_bh(&soc->ast_lock); 965 ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr); 966 if (!ast_entry) { 967 qdf_spin_unlock_bh(&soc->ast_lock); 968 return -QDF_STATUS_E_INVAL; 969 } 970 971 if (ast_entry->callback) { 972 cb = ast_entry->callback; 973 arg = ast_entry->cookie; 974 } 975 976 ast_entry->callback = callback; 977 ast_entry->cookie = cookie; 978 979 /* 980 * if delete_in_progress is set AST delete is sent to target 981 * and host is waiting for response should not send delete 982 * again 983 */ 984 if (!ast_entry->delete_in_progress) 985 dp_peer_del_ast(soc, ast_entry); 986 987 qdf_spin_unlock_bh(&soc->ast_lock); 988 if (cb) { 989 cb(soc->ctrl_psoc, 990 dp_soc_to_cdp_soc(soc), 991 arg, 992 CDP_TXRX_AST_DELETE_IN_PROGRESS); 993 } 994 return QDF_STATUS_SUCCESS; 995 } 996 997 /** 998 * dp_peer_ast_entry_del_by_pdev() - delete the ast entry from soc AST hash 999 * table if mac address and pdev_id matches 1000 * @soc_handle: data path soc handle 1001 * @mac_addr: AST entry mac address 1002 * @pdev_id: pdev id 1003 * @callback: callback function to called on ast delete response from FW 1004 * @cookie: argument to be passed to callback 1005 * 1006 * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 1007 * is sent 1008 * QDF_STATUS_E_INVAL false if ast entry not found 1009 */ 1010 1011 static QDF_STATUS dp_peer_ast_entry_del_by_pdev(struct cdp_soc_t *soc_handle, 1012 uint8_t *mac_addr, 1013 uint8_t pdev_id, 1014 txrx_ast_free_cb callback, 1015 void *cookie) 1016 1017 { 1018 struct dp_soc *soc = (struct dp_soc *)soc_handle; 1019 struct dp_ast_entry *ast_entry; 1020 txrx_ast_free_cb cb = NULL; 1021 void *arg = NULL; 1022 1023 if (soc->ast_offload_support) 1024 return -QDF_STATUS_E_INVAL; 1025 1026 qdf_spin_lock_bh(&soc->ast_lock); 1027 ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, mac_addr, pdev_id); 1028 1029 if (!ast_entry) { 1030 qdf_spin_unlock_bh(&soc->ast_lock); 1031 return -QDF_STATUS_E_INVAL; 1032 } 1033 1034 if (ast_entry->callback) { 1035 cb = ast_entry->callback; 1036 arg = ast_entry->cookie; 1037 } 1038 1039 ast_entry->callback = callback; 1040 ast_entry->cookie = cookie; 1041 1042 /* 1043 * if delete_in_progress is set AST delete is sent to target 1044 * and host is waiting for response should not sent delete 1045 * again 1046 */ 1047 if (!ast_entry->delete_in_progress) 1048 dp_peer_del_ast(soc, ast_entry); 1049 1050 qdf_spin_unlock_bh(&soc->ast_lock); 1051 1052 if (cb) { 1053 cb(soc->ctrl_psoc, 1054 dp_soc_to_cdp_soc(soc), 1055 arg, 1056 CDP_TXRX_AST_DELETE_IN_PROGRESS); 1057 } 1058 return QDF_STATUS_SUCCESS; 1059 } 1060 1061 /** 1062 * dp_peer_HMWDS_ast_entry_del() - delete the ast entry from soc AST hash 1063 * table if HMWDS rem-addr command is issued 1064 * 1065 * @soc_handle: data path soc handle 1066 * @vdev_id: vdev id 1067 * @wds_macaddr: AST entry mac address to delete 1068 * @type: cdp_txrx_ast_entry_type to send to FW 1069 * @delete_in_fw: flag to indicate AST entry deletion in FW 1070 * 1071 * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete 1072 * is sent 1073 * QDF_STATUS_E_INVAL false if ast entry not found 1074 */ 1075 static QDF_STATUS dp_peer_HMWDS_ast_entry_del(struct cdp_soc_t *soc_handle, 1076 uint8_t vdev_id, 1077 uint8_t *wds_macaddr, 1078 uint8_t type, 1079 uint8_t delete_in_fw) 1080 { 1081 struct dp_soc *soc = (struct dp_soc *)soc_handle; 1082 1083 if (soc->ast_offload_support) { 1084 dp_del_wds_entry_wrapper(soc, vdev_id, wds_macaddr, type, 1085 delete_in_fw); 1086 return QDF_STATUS_SUCCESS; 1087 } 1088 1089 return -QDF_STATUS_E_INVAL; 1090 } 1091 1092 #ifdef FEATURE_AST 1093 /** 1094 * dp_print_mlo_ast_stats() - Print AST stats for MLO peers 1095 * 1096 * @soc: core DP soc context 1097 * 1098 * Return: void 1099 */ 1100 static void dp_print_mlo_ast_stats(struct dp_soc *soc) 1101 { 1102 if (soc->arch_ops.print_mlo_ast_stats) 1103 soc->arch_ops.print_mlo_ast_stats(soc); 1104 } 1105 1106 void 1107 dp_print_peer_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) 1108 { 1109 struct dp_ast_entry *ase, *tmp_ase; 1110 uint32_t num_entries = 0; 1111 char type[CDP_TXRX_AST_TYPE_MAX][10] = { 1112 "NONE", "STATIC", "SELF", "WDS", "HMWDS", "BSS", 1113 "DA", "HMWDS_SEC", "MLD"}; 1114 1115 DP_PEER_ITERATE_ASE_LIST(peer, ase, tmp_ase) { 1116 DP_PRINT_STATS("%6d mac_addr = "QDF_MAC_ADDR_FMT 1117 " peer_mac_addr = "QDF_MAC_ADDR_FMT 1118 " peer_id = %u" 1119 " type = %s" 1120 " next_hop = %d" 1121 " is_active = %d" 1122 " ast_idx = %d" 1123 " ast_hash = %d" 1124 " delete_in_progress = %d" 1125 " pdev_id = %d" 1126 " vdev_id = %d", 1127 ++num_entries, 1128 QDF_MAC_ADDR_REF(ase->mac_addr.raw), 1129 QDF_MAC_ADDR_REF(peer->mac_addr.raw), 1130 ase->peer_id, 1131 type[ase->type], 1132 ase->next_hop, 1133 ase->is_active, 1134 ase->ast_idx, 1135 ase->ast_hash_value, 1136 ase->delete_in_progress, 1137 ase->pdev_id, 1138 ase->vdev_id); 1139 } 1140 } 1141 1142 void dp_print_ast_stats(struct dp_soc *soc) 1143 { 1144 DP_PRINT_STATS("AST Stats:"); 1145 DP_PRINT_STATS(" Entries Added = %d", soc->stats.ast.added); 1146 DP_PRINT_STATS(" Entries Deleted = %d", soc->stats.ast.deleted); 1147 DP_PRINT_STATS(" Entries Agedout = %d", soc->stats.ast.aged_out); 1148 DP_PRINT_STATS(" Entries MAP ERR = %d", soc->stats.ast.map_err); 1149 DP_PRINT_STATS(" Entries Mismatch ERR = %d", 1150 soc->stats.ast.ast_mismatch); 1151 1152 DP_PRINT_STATS("AST Table:"); 1153 1154 qdf_spin_lock_bh(&soc->ast_lock); 1155 1156 dp_soc_iterate_peer(soc, dp_print_peer_ast_entries, NULL, 1157 DP_MOD_ID_GENERIC_STATS); 1158 1159 qdf_spin_unlock_bh(&soc->ast_lock); 1160 1161 dp_print_mlo_ast_stats(soc); 1162 } 1163 #else 1164 void dp_print_ast_stats(struct dp_soc *soc) 1165 { 1166 DP_PRINT_STATS("AST Stats not available.Enable FEATURE_AST"); 1167 return; 1168 } 1169 #endif 1170 1171 /** 1172 * dp_print_peer_info() - Dump peer info 1173 * @soc: Datapath soc handle 1174 * @peer: Datapath peer handle 1175 * @arg: argument to iter function 1176 * 1177 * Return: void 1178 */ 1179 static void 1180 dp_print_peer_info(struct dp_soc *soc, struct dp_peer *peer, void *arg) 1181 { 1182 struct dp_txrx_peer *txrx_peer = NULL; 1183 1184 txrx_peer = dp_get_txrx_peer(peer); 1185 if (!txrx_peer) 1186 return; 1187 1188 DP_PRINT_STATS(" peer id = %d" 1189 " peer_mac_addr = "QDF_MAC_ADDR_FMT 1190 " nawds_enabled = %d" 1191 " bss_peer = %d" 1192 " wds_enabled = %d" 1193 " tx_cap_enabled = %d" 1194 " rx_cap_enabled = %d", 1195 peer->peer_id, 1196 QDF_MAC_ADDR_REF(peer->mac_addr.raw), 1197 txrx_peer->nawds_enabled, 1198 txrx_peer->bss_peer, 1199 txrx_peer->wds_enabled, 1200 dp_monitor_is_tx_cap_enabled(peer), 1201 dp_monitor_is_rx_cap_enabled(peer)); 1202 } 1203 1204 /** 1205 * dp_print_peer_table() - Dump all Peer stats 1206 * @vdev: Datapath Vdev handle 1207 * 1208 * Return: void 1209 */ 1210 static void dp_print_peer_table(struct dp_vdev *vdev) 1211 { 1212 DP_PRINT_STATS("Dumping Peer Table Stats:"); 1213 dp_vdev_iterate_peer(vdev, dp_print_peer_info, NULL, 1214 DP_MOD_ID_GENERIC_STATS); 1215 } 1216 1217 #ifdef DP_MEM_PRE_ALLOC 1218 1219 void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 1220 size_t ctxt_size) 1221 { 1222 void *ctxt_mem; 1223 1224 if (!soc->cdp_soc.ol_ops->dp_prealloc_get_context) { 1225 dp_warn("dp_prealloc_get_context null!"); 1226 goto dynamic_alloc; 1227 } 1228 1229 ctxt_mem = soc->cdp_soc.ol_ops->dp_prealloc_get_context(ctxt_type, 1230 ctxt_size); 1231 1232 if (ctxt_mem) 1233 goto end; 1234 1235 dynamic_alloc: 1236 dp_info("switch to dynamic-alloc for type %d, size %zu", 1237 ctxt_type, ctxt_size); 1238 ctxt_mem = qdf_mem_malloc(ctxt_size); 1239 end: 1240 return ctxt_mem; 1241 } 1242 1243 void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, 1244 void *vaddr) 1245 { 1246 QDF_STATUS status; 1247 1248 if (soc->cdp_soc.ol_ops->dp_prealloc_put_context) { 1249 status = soc->cdp_soc.ol_ops->dp_prealloc_put_context( 1250 ctxt_type, 1251 vaddr); 1252 } else { 1253 dp_warn("dp_prealloc_put_context null!"); 1254 status = QDF_STATUS_E_NOSUPPORT; 1255 } 1256 1257 if (QDF_IS_STATUS_ERROR(status)) { 1258 dp_info("Context type %d not pre-allocated", ctxt_type); 1259 qdf_mem_free(vaddr); 1260 } 1261 } 1262 1263 static inline 1264 void *dp_srng_aligned_mem_alloc_consistent(struct dp_soc *soc, 1265 struct dp_srng *srng, 1266 uint32_t ring_type) 1267 { 1268 void *mem; 1269 1270 qdf_assert(!srng->is_mem_prealloc); 1271 1272 if (!soc->cdp_soc.ol_ops->dp_prealloc_get_consistent) { 1273 dp_warn("dp_prealloc_get_consistent is null!"); 1274 goto qdf; 1275 } 1276 1277 mem = 1278 soc->cdp_soc.ol_ops->dp_prealloc_get_consistent 1279 (&srng->alloc_size, 1280 &srng->base_vaddr_unaligned, 1281 &srng->base_paddr_unaligned, 1282 &srng->base_paddr_aligned, 1283 DP_RING_BASE_ALIGN, ring_type); 1284 1285 if (mem) { 1286 srng->is_mem_prealloc = true; 1287 goto end; 1288 } 1289 qdf: 1290 mem = qdf_aligned_mem_alloc_consistent(soc->osdev, &srng->alloc_size, 1291 &srng->base_vaddr_unaligned, 1292 &srng->base_paddr_unaligned, 1293 &srng->base_paddr_aligned, 1294 DP_RING_BASE_ALIGN); 1295 end: 1296 dp_info("%s memory %pK dp_srng %pK ring_type %d alloc_size %d num_entries %d", 1297 srng->is_mem_prealloc ? "pre-alloc" : "dynamic-alloc", mem, 1298 srng, ring_type, srng->alloc_size, srng->num_entries); 1299 return mem; 1300 } 1301 1302 static inline void dp_srng_mem_free_consistent(struct dp_soc *soc, 1303 struct dp_srng *srng) 1304 { 1305 if (srng->is_mem_prealloc) { 1306 if (!soc->cdp_soc.ol_ops->dp_prealloc_put_consistent) { 1307 dp_warn("dp_prealloc_put_consistent is null!"); 1308 QDF_BUG(0); 1309 return; 1310 } 1311 soc->cdp_soc.ol_ops->dp_prealloc_put_consistent 1312 (srng->alloc_size, 1313 srng->base_vaddr_unaligned, 1314 srng->base_paddr_unaligned); 1315 1316 } else { 1317 qdf_mem_free_consistent(soc->osdev, soc->osdev->dev, 1318 srng->alloc_size, 1319 srng->base_vaddr_unaligned, 1320 srng->base_paddr_unaligned, 0); 1321 } 1322 } 1323 1324 void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, 1325 enum qdf_dp_desc_type desc_type, 1326 struct qdf_mem_multi_page_t *pages, 1327 size_t element_size, 1328 uint32_t element_num, 1329 qdf_dma_context_t memctxt, 1330 bool cacheable) 1331 { 1332 if (!soc->cdp_soc.ol_ops->dp_get_multi_pages) { 1333 dp_warn("dp_get_multi_pages is null!"); 1334 goto qdf; 1335 } 1336 1337 pages->num_pages = 0; 1338 pages->is_mem_prealloc = 0; 1339 soc->cdp_soc.ol_ops->dp_get_multi_pages(desc_type, 1340 element_size, 1341 element_num, 1342 pages, 1343 cacheable); 1344 if (pages->num_pages) 1345 goto end; 1346 1347 qdf: 1348 qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size, 1349 element_num, memctxt, cacheable); 1350 end: 1351 dp_info("%s desc_type %d element_size %d element_num %d cacheable %d", 1352 pages->is_mem_prealloc ? "pre-alloc" : "dynamic-alloc", 1353 desc_type, (int)element_size, element_num, cacheable); 1354 } 1355 1356 void dp_desc_multi_pages_mem_free(struct dp_soc *soc, 1357 enum qdf_dp_desc_type desc_type, 1358 struct qdf_mem_multi_page_t *pages, 1359 qdf_dma_context_t memctxt, 1360 bool cacheable) 1361 { 1362 if (pages->is_mem_prealloc) { 1363 if (!soc->cdp_soc.ol_ops->dp_put_multi_pages) { 1364 dp_warn("dp_put_multi_pages is null!"); 1365 QDF_BUG(0); 1366 return; 1367 } 1368 1369 soc->cdp_soc.ol_ops->dp_put_multi_pages(desc_type, pages); 1370 qdf_mem_zero(pages, sizeof(*pages)); 1371 } else { 1372 qdf_mem_multi_pages_free(soc->osdev, pages, 1373 memctxt, cacheable); 1374 } 1375 } 1376 1377 #else 1378 1379 static inline 1380 void *dp_srng_aligned_mem_alloc_consistent(struct dp_soc *soc, 1381 struct dp_srng *srng, 1382 uint32_t ring_type) 1383 1384 { 1385 void *mem; 1386 1387 mem = qdf_aligned_mem_alloc_consistent(soc->osdev, &srng->alloc_size, 1388 &srng->base_vaddr_unaligned, 1389 &srng->base_paddr_unaligned, 1390 &srng->base_paddr_aligned, 1391 DP_RING_BASE_ALIGN); 1392 if (mem) 1393 qdf_mem_set(srng->base_vaddr_unaligned, 0, srng->alloc_size); 1394 1395 return mem; 1396 } 1397 1398 static inline void dp_srng_mem_free_consistent(struct dp_soc *soc, 1399 struct dp_srng *srng) 1400 { 1401 qdf_mem_free_consistent(soc->osdev, soc->osdev->dev, 1402 srng->alloc_size, 1403 srng->base_vaddr_unaligned, 1404 srng->base_paddr_unaligned, 0); 1405 } 1406 1407 #endif /* DP_MEM_PRE_ALLOC */ 1408 1409 #ifdef QCA_SUPPORT_WDS_EXTENDED 1410 bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev) 1411 { 1412 return vdev->wds_ext_enabled; 1413 } 1414 #else 1415 bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev) 1416 { 1417 return false; 1418 } 1419 #endif 1420 1421 void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev) 1422 { 1423 struct dp_vdev *vdev = NULL; 1424 uint8_t rx_fast_flag = true; 1425 1426 /* Check if protocol tagging enable */ 1427 if (pdev->is_rx_protocol_tagging_enabled) { 1428 rx_fast_flag = false; 1429 goto update_flag; 1430 } 1431 1432 qdf_spin_lock_bh(&pdev->vdev_list_lock); 1433 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 1434 /* Check if any VDEV has NAWDS enabled */ 1435 if (vdev->nawds_enabled) { 1436 rx_fast_flag = false; 1437 break; 1438 } 1439 1440 /* Check if any VDEV has multipass enabled */ 1441 if (vdev->multipass_en) { 1442 rx_fast_flag = false; 1443 break; 1444 } 1445 1446 /* Check if any VDEV has mesh enabled */ 1447 if (vdev->mesh_vdev) { 1448 rx_fast_flag = false; 1449 break; 1450 } 1451 } 1452 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 1453 1454 update_flag: 1455 dp_init_info("Updated Rx fast flag to %u", rx_fast_flag); 1456 pdev->rx_fast_flag = rx_fast_flag; 1457 } 1458 1459 void dp_srng_free(struct dp_soc *soc, struct dp_srng *srng) 1460 { 1461 if (srng->alloc_size && srng->base_vaddr_unaligned) { 1462 if (!srng->cached) { 1463 dp_srng_mem_free_consistent(soc, srng); 1464 } else { 1465 qdf_mem_free(srng->base_vaddr_unaligned); 1466 } 1467 srng->alloc_size = 0; 1468 srng->base_vaddr_unaligned = NULL; 1469 } 1470 srng->hal_srng = NULL; 1471 } 1472 1473 qdf_export_symbol(dp_srng_free); 1474 1475 QDF_STATUS dp_srng_init(struct dp_soc *soc, struct dp_srng *srng, int ring_type, 1476 int ring_num, int mac_id) 1477 { 1478 return soc->arch_ops.txrx_srng_init(soc, srng, ring_type, 1479 ring_num, mac_id); 1480 } 1481 1482 qdf_export_symbol(dp_srng_init); 1483 1484 QDF_STATUS dp_srng_alloc(struct dp_soc *soc, struct dp_srng *srng, 1485 int ring_type, uint32_t num_entries, 1486 bool cached) 1487 { 1488 hal_soc_handle_t hal_soc = soc->hal_soc; 1489 uint32_t entry_size = hal_srng_get_entrysize(hal_soc, ring_type); 1490 uint32_t max_entries = hal_srng_max_entries(hal_soc, ring_type); 1491 1492 if (srng->base_vaddr_unaligned) { 1493 dp_init_err("%pK: Ring type: %d, is already allocated", 1494 soc, ring_type); 1495 return QDF_STATUS_SUCCESS; 1496 } 1497 1498 num_entries = (num_entries > max_entries) ? max_entries : num_entries; 1499 srng->hal_srng = NULL; 1500 srng->alloc_size = num_entries * entry_size; 1501 srng->num_entries = num_entries; 1502 srng->cached = cached; 1503 1504 if (!cached) { 1505 srng->base_vaddr_aligned = 1506 dp_srng_aligned_mem_alloc_consistent(soc, 1507 srng, 1508 ring_type); 1509 } else { 1510 srng->base_vaddr_aligned = qdf_aligned_malloc( 1511 &srng->alloc_size, 1512 &srng->base_vaddr_unaligned, 1513 &srng->base_paddr_unaligned, 1514 &srng->base_paddr_aligned, 1515 DP_RING_BASE_ALIGN); 1516 } 1517 1518 if (!srng->base_vaddr_aligned) 1519 return QDF_STATUS_E_NOMEM; 1520 1521 return QDF_STATUS_SUCCESS; 1522 } 1523 1524 qdf_export_symbol(dp_srng_alloc); 1525 1526 void dp_srng_deinit(struct dp_soc *soc, struct dp_srng *srng, 1527 int ring_type, int ring_num) 1528 { 1529 if (!srng->hal_srng) { 1530 dp_init_err("%pK: Ring type: %d, num:%d not setup", 1531 soc, ring_type, ring_num); 1532 return; 1533 } 1534 1535 if (dp_check_umac_reset_in_progress(soc)) 1536 goto srng_cleanup; 1537 1538 if (soc->arch_ops.dp_free_ppeds_interrupts) 1539 soc->arch_ops.dp_free_ppeds_interrupts(soc, srng, ring_type, 1540 ring_num); 1541 1542 srng_cleanup: 1543 hal_srng_cleanup(soc->hal_soc, srng->hal_srng, 1544 dp_check_umac_reset_in_progress(soc)); 1545 srng->hal_srng = NULL; 1546 } 1547 1548 qdf_export_symbol(dp_srng_deinit); 1549 1550 /* TODO: Need this interface from HIF */ 1551 void *hif_get_hal_handle(struct hif_opaque_softc *hif_handle); 1552 1553 #ifdef WLAN_FEATURE_DP_EVENT_HISTORY 1554 int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 1555 hal_ring_handle_t hal_ring_hdl) 1556 { 1557 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 1558 uint32_t hp, tp; 1559 uint8_t ring_id; 1560 1561 if (!int_ctx) 1562 return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); 1563 1564 hal_get_sw_hptp(hal_soc, hal_ring_hdl, &tp, &hp); 1565 ring_id = hal_srng_ring_id_get(hal_ring_hdl); 1566 1567 hif_record_event(dp_soc->hif_handle, int_ctx->dp_intr_id, 1568 ring_id, hp, tp, HIF_EVENT_SRNG_ACCESS_START); 1569 1570 return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); 1571 } 1572 1573 void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc, 1574 hal_ring_handle_t hal_ring_hdl) 1575 { 1576 hal_soc_handle_t hal_soc = dp_soc->hal_soc; 1577 uint32_t hp, tp; 1578 uint8_t ring_id; 1579 1580 if (!int_ctx) 1581 return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); 1582 1583 hal_get_sw_hptp(hal_soc, hal_ring_hdl, &tp, &hp); 1584 ring_id = hal_srng_ring_id_get(hal_ring_hdl); 1585 1586 hif_record_event(dp_soc->hif_handle, int_ctx->dp_intr_id, 1587 ring_id, hp, tp, HIF_EVENT_SRNG_ACCESS_END); 1588 1589 return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); 1590 } 1591 1592 static inline void dp_srng_record_timer_entry(struct dp_soc *dp_soc, 1593 uint8_t hist_group_id) 1594 { 1595 hif_record_event(dp_soc->hif_handle, hist_group_id, 1596 0, 0, 0, HIF_EVENT_TIMER_ENTRY); 1597 } 1598 1599 static inline void dp_srng_record_timer_exit(struct dp_soc *dp_soc, 1600 uint8_t hist_group_id) 1601 { 1602 hif_record_event(dp_soc->hif_handle, hist_group_id, 1603 0, 0, 0, HIF_EVENT_TIMER_EXIT); 1604 } 1605 #else 1606 1607 static inline void dp_srng_record_timer_entry(struct dp_soc *dp_soc, 1608 uint8_t hist_group_id) 1609 { 1610 } 1611 1612 static inline void dp_srng_record_timer_exit(struct dp_soc *dp_soc, 1613 uint8_t hist_group_id) 1614 { 1615 } 1616 1617 #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ 1618 1619 enum timer_yield_status 1620 dp_should_timer_irq_yield(struct dp_soc *soc, uint32_t work_done, 1621 uint64_t start_time) 1622 { 1623 uint64_t cur_time = qdf_get_log_timestamp(); 1624 1625 if (!work_done) 1626 return DP_TIMER_WORK_DONE; 1627 1628 if (cur_time - start_time > DP_MAX_TIMER_EXEC_TIME_TICKS) 1629 return DP_TIMER_TIME_EXHAUST; 1630 1631 return DP_TIMER_NO_YIELD; 1632 } 1633 1634 qdf_export_symbol(dp_should_timer_irq_yield); 1635 1636 void dp_interrupt_timer(void *arg) 1637 { 1638 struct dp_soc *soc = (struct dp_soc *) arg; 1639 struct dp_pdev *pdev = soc->pdev_list[0]; 1640 enum timer_yield_status yield = DP_TIMER_NO_YIELD; 1641 uint32_t work_done = 0, total_work_done = 0; 1642 int budget = 0xffff, i; 1643 uint32_t remaining_quota = budget; 1644 uint64_t start_time; 1645 uint32_t lmac_id = DP_MON_INVALID_LMAC_ID; 1646 uint8_t dp_intr_id = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); 1647 uint32_t lmac_iter; 1648 int max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx); 1649 enum reg_wifi_band mon_band; 1650 int cpu = dp_srng_get_cpu(); 1651 1652 /* 1653 * this logic makes all data path interfacing rings (UMAC/LMAC) 1654 * and Monitor rings polling mode when NSS offload is disabled 1655 */ 1656 if (wlan_cfg_is_poll_mode_enabled(soc->wlan_cfg_ctx) && 1657 !wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { 1658 if (qdf_atomic_read(&soc->cmn_init_done)) { 1659 for (i = 0; i < wlan_cfg_get_num_contexts( 1660 soc->wlan_cfg_ctx); i++) 1661 dp_service_srngs(&soc->intr_ctx[i], 0xffff, 1662 cpu); 1663 1664 qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); 1665 } 1666 return; 1667 } 1668 1669 if (!qdf_atomic_read(&soc->cmn_init_done)) 1670 return; 1671 1672 if (dp_monitor_is_chan_band_known(pdev)) { 1673 mon_band = dp_monitor_get_chan_band(pdev); 1674 lmac_id = pdev->ch_band_lmac_id_mapping[mon_band]; 1675 if (qdf_likely(lmac_id != DP_MON_INVALID_LMAC_ID)) { 1676 dp_intr_id = soc->mon_intr_id_lmac_map[lmac_id]; 1677 dp_srng_record_timer_entry(soc, dp_intr_id); 1678 } 1679 } 1680 1681 start_time = qdf_get_log_timestamp(); 1682 dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings); 1683 1684 while (yield == DP_TIMER_NO_YIELD) { 1685 for (lmac_iter = 0; lmac_iter < max_mac_rings; lmac_iter++) { 1686 if (lmac_iter == lmac_id) 1687 work_done = dp_monitor_process(soc, 1688 &soc->intr_ctx[dp_intr_id], 1689 lmac_iter, remaining_quota); 1690 else 1691 work_done = 1692 dp_monitor_drop_packets_for_mac(pdev, 1693 lmac_iter, 1694 remaining_quota); 1695 if (work_done) { 1696 budget -= work_done; 1697 if (budget <= 0) { 1698 yield = DP_TIMER_WORK_EXHAUST; 1699 goto budget_done; 1700 } 1701 remaining_quota = budget; 1702 total_work_done += work_done; 1703 } 1704 } 1705 1706 yield = dp_should_timer_irq_yield(soc, total_work_done, 1707 start_time); 1708 total_work_done = 0; 1709 } 1710 1711 budget_done: 1712 if (yield == DP_TIMER_WORK_EXHAUST || 1713 yield == DP_TIMER_TIME_EXHAUST) 1714 qdf_timer_mod(&soc->int_timer, 1); 1715 else 1716 qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); 1717 1718 if (lmac_id != DP_MON_INVALID_LMAC_ID) 1719 dp_srng_record_timer_exit(soc, dp_intr_id); 1720 } 1721 1722 #if defined(DP_INTR_POLL_BOTH) 1723 /** 1724 * dp_soc_interrupt_attach_wrapper() - Register handlers for DP interrupts 1725 * @txrx_soc: DP SOC handle 1726 * 1727 * Call the appropriate attach function based on the mode of operation. 1728 * This is a WAR for enabling monitor mode. 1729 * 1730 * Return: 0 for success. nonzero for failure. 1731 */ 1732 static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) 1733 { 1734 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 1735 1736 if (!(soc->wlan_cfg_ctx->napi_enabled) || 1737 (dp_is_monitor_mode_using_poll(soc) && 1738 soc->cdp_soc.ol_ops->get_con_mode && 1739 soc->cdp_soc.ol_ops->get_con_mode() == 1740 QDF_GLOBAL_MONITOR_MODE)) { 1741 dp_info("Poll mode"); 1742 return dp_soc_attach_poll(txrx_soc); 1743 } else { 1744 dp_info("Interrupt mode"); 1745 return dp_soc_interrupt_attach(txrx_soc); 1746 } 1747 } 1748 #else 1749 #if defined(DP_INTR_POLL_BASED) && DP_INTR_POLL_BASED 1750 static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) 1751 { 1752 return dp_soc_attach_poll(txrx_soc); 1753 } 1754 #else 1755 static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) 1756 { 1757 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 1758 1759 if (wlan_cfg_is_poll_mode_enabled(soc->wlan_cfg_ctx)) 1760 return dp_soc_attach_poll(txrx_soc); 1761 else 1762 return dp_soc_interrupt_attach(txrx_soc); 1763 } 1764 #endif 1765 #endif 1766 1767 void dp_link_desc_ring_replenish(struct dp_soc *soc, uint32_t mac_id) 1768 { 1769 uint32_t cookie = 0; 1770 uint32_t page_idx = 0; 1771 struct qdf_mem_multi_page_t *pages; 1772 struct qdf_mem_dma_page_t *dma_pages; 1773 uint32_t offset = 0; 1774 uint32_t count = 0; 1775 uint32_t desc_id = 0; 1776 void *desc_srng; 1777 int link_desc_size = hal_get_link_desc_size(soc->hal_soc); 1778 uint32_t *total_link_descs_addr; 1779 uint32_t total_link_descs; 1780 uint32_t scatter_buf_num; 1781 uint32_t num_entries_per_buf = 0; 1782 uint32_t rem_entries; 1783 uint32_t num_descs_per_page; 1784 uint32_t num_scatter_bufs = 0; 1785 uint8_t *scatter_buf_ptr; 1786 void *desc; 1787 1788 num_scatter_bufs = soc->num_scatter_bufs; 1789 1790 if (mac_id == WLAN_INVALID_PDEV_ID) { 1791 pages = &soc->link_desc_pages; 1792 total_link_descs = soc->total_link_descs; 1793 desc_srng = soc->wbm_idle_link_ring.hal_srng; 1794 } else { 1795 pages = dp_monitor_get_link_desc_pages(soc, mac_id); 1796 /* dp_monitor_get_link_desc_pages returns NULL only 1797 * if monitor SOC is NULL 1798 */ 1799 if (!pages) { 1800 dp_err("can not get link desc pages"); 1801 QDF_ASSERT(0); 1802 return; 1803 } 1804 total_link_descs_addr = 1805 dp_monitor_get_total_link_descs(soc, mac_id); 1806 total_link_descs = *total_link_descs_addr; 1807 desc_srng = dp_monitor_get_link_desc_ring(soc, mac_id); 1808 } 1809 1810 dma_pages = pages->dma_pages; 1811 do { 1812 qdf_mem_zero(dma_pages[page_idx].page_v_addr_start, 1813 pages->page_size); 1814 page_idx++; 1815 } while (page_idx < pages->num_pages); 1816 1817 if (desc_srng) { 1818 hal_srng_access_start_unlocked(soc->hal_soc, desc_srng); 1819 page_idx = 0; 1820 count = 0; 1821 offset = 0; 1822 while ((desc = hal_srng_src_get_next(soc->hal_soc, 1823 desc_srng)) && 1824 (count < total_link_descs)) { 1825 page_idx = count / pages->num_element_per_page; 1826 if (desc_id == pages->num_element_per_page) 1827 desc_id = 0; 1828 1829 offset = count % pages->num_element_per_page; 1830 cookie = LINK_DESC_COOKIE(desc_id, page_idx, 1831 soc->link_desc_id_start); 1832 1833 hal_set_link_desc_addr(soc->hal_soc, desc, cookie, 1834 dma_pages[page_idx].page_p_addr 1835 + (offset * link_desc_size), 1836 soc->idle_link_bm_id); 1837 count++; 1838 desc_id++; 1839 } 1840 hal_srng_access_end_unlocked(soc->hal_soc, desc_srng); 1841 } else { 1842 /* Populate idle list scatter buffers with link descriptor 1843 * pointers 1844 */ 1845 scatter_buf_num = 0; 1846 num_entries_per_buf = hal_idle_scatter_buf_num_entries( 1847 soc->hal_soc, 1848 soc->wbm_idle_scatter_buf_size); 1849 1850 scatter_buf_ptr = (uint8_t *)( 1851 soc->wbm_idle_scatter_buf_base_vaddr[scatter_buf_num]); 1852 rem_entries = num_entries_per_buf; 1853 page_idx = 0; count = 0; 1854 offset = 0; 1855 num_descs_per_page = pages->num_element_per_page; 1856 1857 while (count < total_link_descs) { 1858 page_idx = count / num_descs_per_page; 1859 offset = count % num_descs_per_page; 1860 if (desc_id == pages->num_element_per_page) 1861 desc_id = 0; 1862 1863 cookie = LINK_DESC_COOKIE(desc_id, page_idx, 1864 soc->link_desc_id_start); 1865 hal_set_link_desc_addr(soc->hal_soc, 1866 (void *)scatter_buf_ptr, 1867 cookie, 1868 dma_pages[page_idx].page_p_addr + 1869 (offset * link_desc_size), 1870 soc->idle_link_bm_id); 1871 rem_entries--; 1872 if (rem_entries) { 1873 scatter_buf_ptr += link_desc_size; 1874 } else { 1875 rem_entries = num_entries_per_buf; 1876 scatter_buf_num++; 1877 if (scatter_buf_num >= num_scatter_bufs) 1878 break; 1879 scatter_buf_ptr = (uint8_t *) 1880 (soc->wbm_idle_scatter_buf_base_vaddr[ 1881 scatter_buf_num]); 1882 } 1883 count++; 1884 desc_id++; 1885 } 1886 /* Setup link descriptor idle list in HW */ 1887 hal_setup_link_idle_list(soc->hal_soc, 1888 soc->wbm_idle_scatter_buf_base_paddr, 1889 soc->wbm_idle_scatter_buf_base_vaddr, 1890 num_scatter_bufs, soc->wbm_idle_scatter_buf_size, 1891 (uint32_t)(scatter_buf_ptr - 1892 (uint8_t *)(soc->wbm_idle_scatter_buf_base_vaddr[ 1893 scatter_buf_num-1])), total_link_descs); 1894 } 1895 } 1896 1897 qdf_export_symbol(dp_link_desc_ring_replenish); 1898 1899 /** 1900 * dp_soc_ppeds_stop() - Stop PPE DS processing 1901 * @soc_handle: DP SOC handle 1902 * 1903 * Return: none 1904 */ 1905 static void dp_soc_ppeds_stop(struct cdp_soc_t *soc_handle) 1906 { 1907 struct dp_soc *soc = (struct dp_soc *)soc_handle; 1908 1909 if (soc->arch_ops.txrx_soc_ppeds_stop) 1910 soc->arch_ops.txrx_soc_ppeds_stop(soc); 1911 } 1912 1913 #ifdef ENABLE_VERBOSE_DEBUG 1914 void dp_enable_verbose_debug(struct dp_soc *soc) 1915 { 1916 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 1917 1918 soc_cfg_ctx = soc->wlan_cfg_ctx; 1919 1920 if (soc_cfg_ctx->per_pkt_trace & dp_verbose_debug_mask) 1921 is_dp_verbose_debug_enabled = true; 1922 1923 if (soc_cfg_ctx->per_pkt_trace & hal_verbose_debug_mask) 1924 hal_set_verbose_debug(true); 1925 else 1926 hal_set_verbose_debug(false); 1927 } 1928 #else 1929 void dp_enable_verbose_debug(struct dp_soc *soc) 1930 { 1931 } 1932 #endif 1933 1934 static QDF_STATUS dp_lro_hash_setup(struct dp_soc *soc, struct dp_pdev *pdev) 1935 { 1936 struct cdp_lro_hash_config lro_hash; 1937 QDF_STATUS status; 1938 1939 if (!wlan_cfg_is_lro_enabled(soc->wlan_cfg_ctx) && 1940 !wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx) && 1941 !wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { 1942 dp_err("LRO, GRO and RX hash disabled"); 1943 return QDF_STATUS_E_FAILURE; 1944 } 1945 1946 qdf_mem_zero(&lro_hash, sizeof(lro_hash)); 1947 1948 if (wlan_cfg_is_lro_enabled(soc->wlan_cfg_ctx) || 1949 wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx)) { 1950 lro_hash.lro_enable = 1; 1951 lro_hash.tcp_flag = QDF_TCPHDR_ACK; 1952 lro_hash.tcp_flag_mask = QDF_TCPHDR_FIN | QDF_TCPHDR_SYN | 1953 QDF_TCPHDR_RST | QDF_TCPHDR_ACK | QDF_TCPHDR_URG | 1954 QDF_TCPHDR_ECE | QDF_TCPHDR_CWR; 1955 } 1956 1957 soc->arch_ops.get_rx_hash_key(soc, &lro_hash); 1958 1959 qdf_assert(soc->cdp_soc.ol_ops->lro_hash_config); 1960 1961 if (!soc->cdp_soc.ol_ops->lro_hash_config) { 1962 QDF_BUG(0); 1963 dp_err("lro_hash_config not configured"); 1964 return QDF_STATUS_E_FAILURE; 1965 } 1966 1967 status = soc->cdp_soc.ol_ops->lro_hash_config(soc->ctrl_psoc, 1968 pdev->pdev_id, 1969 &lro_hash); 1970 if (!QDF_IS_STATUS_SUCCESS(status)) { 1971 dp_err("failed to send lro_hash_config to FW %u", status); 1972 return status; 1973 } 1974 1975 dp_info("LRO CMD config: lro_enable: 0x%x tcp_flag 0x%x tcp_flag_mask 0x%x", 1976 lro_hash.lro_enable, lro_hash.tcp_flag, 1977 lro_hash.tcp_flag_mask); 1978 1979 dp_info("toeplitz_hash_ipv4:"); 1980 qdf_trace_hex_dump(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 1981 lro_hash.toeplitz_hash_ipv4, 1982 (sizeof(lro_hash.toeplitz_hash_ipv4[0]) * 1983 LRO_IPV4_SEED_ARR_SZ)); 1984 1985 dp_info("toeplitz_hash_ipv6:"); 1986 qdf_trace_hex_dump(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 1987 lro_hash.toeplitz_hash_ipv6, 1988 (sizeof(lro_hash.toeplitz_hash_ipv6[0]) * 1989 LRO_IPV6_SEED_ARR_SZ)); 1990 1991 return status; 1992 } 1993 1994 #if defined(WLAN_MAX_PDEVS) && (WLAN_MAX_PDEVS == 1) 1995 /** 1996 * dp_reap_timer_init() - initialize the reap timer 1997 * @soc: data path SoC handle 1998 * 1999 * Return: void 2000 */ 2001 static void dp_reap_timer_init(struct dp_soc *soc) 2002 { 2003 /* 2004 * Timer to reap rxdma status rings. 2005 * Needed until we enable ppdu end interrupts 2006 */ 2007 dp_monitor_reap_timer_init(soc); 2008 dp_monitor_vdev_timer_init(soc); 2009 } 2010 2011 /** 2012 * dp_reap_timer_deinit() - de-initialize the reap timer 2013 * @soc: data path SoC handle 2014 * 2015 * Return: void 2016 */ 2017 static void dp_reap_timer_deinit(struct dp_soc *soc) 2018 { 2019 dp_monitor_reap_timer_deinit(soc); 2020 } 2021 #else 2022 /* WIN use case */ 2023 static void dp_reap_timer_init(struct dp_soc *soc) 2024 { 2025 /* Configure LMAC rings in Polled mode */ 2026 if (soc->lmac_polled_mode) { 2027 /* 2028 * Timer to reap lmac rings. 2029 */ 2030 qdf_timer_init(soc->osdev, &soc->lmac_reap_timer, 2031 dp_service_lmac_rings, (void *)soc, 2032 QDF_TIMER_TYPE_WAKE_APPS); 2033 soc->lmac_timer_init = 1; 2034 qdf_timer_mod(&soc->lmac_reap_timer, DP_INTR_POLL_TIMER_MS); 2035 } 2036 } 2037 2038 static void dp_reap_timer_deinit(struct dp_soc *soc) 2039 { 2040 if (soc->lmac_timer_init) { 2041 qdf_timer_stop(&soc->lmac_reap_timer); 2042 qdf_timer_free(&soc->lmac_reap_timer); 2043 soc->lmac_timer_init = 0; 2044 } 2045 } 2046 #endif 2047 2048 #ifdef QCA_HOST2FW_RXBUF_RING 2049 /** 2050 * dp_rxdma_ring_alloc() - allocate the RXDMA rings 2051 * @soc: data path SoC handle 2052 * @pdev: Physical device handle 2053 * 2054 * Return: 0 - success, > 0 - failure 2055 */ 2056 static int dp_rxdma_ring_alloc(struct dp_soc *soc, struct dp_pdev *pdev) 2057 { 2058 struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx; 2059 int max_mac_rings; 2060 int i; 2061 int ring_size; 2062 2063 pdev_cfg_ctx = pdev->wlan_cfg_ctx; 2064 max_mac_rings = wlan_cfg_get_num_mac_rings(pdev_cfg_ctx); 2065 ring_size = wlan_cfg_get_rx_dma_buf_ring_size(pdev_cfg_ctx); 2066 2067 for (i = 0; i < max_mac_rings; i++) { 2068 dp_verbose_debug("pdev_id %d mac_id %d", pdev->pdev_id, i); 2069 if (dp_srng_alloc(soc, &pdev->rx_mac_buf_ring[i], 2070 RXDMA_BUF, ring_size, 0)) { 2071 dp_init_err("%pK: failed rx mac ring setup", soc); 2072 return QDF_STATUS_E_FAILURE; 2073 } 2074 } 2075 return QDF_STATUS_SUCCESS; 2076 } 2077 2078 /** 2079 * dp_rxdma_ring_setup() - configure the RXDMA rings 2080 * @soc: data path SoC handle 2081 * @pdev: Physical device handle 2082 * 2083 * Return: 0 - success, > 0 - failure 2084 */ 2085 static int dp_rxdma_ring_setup(struct dp_soc *soc, struct dp_pdev *pdev) 2086 { 2087 struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx; 2088 int max_mac_rings; 2089 int i; 2090 2091 pdev_cfg_ctx = pdev->wlan_cfg_ctx; 2092 max_mac_rings = wlan_cfg_get_num_mac_rings(pdev_cfg_ctx); 2093 2094 for (i = 0; i < max_mac_rings; i++) { 2095 dp_verbose_debug("pdev_id %d mac_id %d", pdev->pdev_id, i); 2096 if (dp_srng_init(soc, &pdev->rx_mac_buf_ring[i], 2097 RXDMA_BUF, 1, i)) { 2098 dp_init_err("%pK: failed rx mac ring setup", soc); 2099 return QDF_STATUS_E_FAILURE; 2100 } 2101 } 2102 return QDF_STATUS_SUCCESS; 2103 } 2104 2105 /** 2106 * dp_rxdma_ring_cleanup() - Deinit the RXDMA rings and reap timer 2107 * @soc: data path SoC handle 2108 * @pdev: Physical device handle 2109 * 2110 * Return: void 2111 */ 2112 static void dp_rxdma_ring_cleanup(struct dp_soc *soc, struct dp_pdev *pdev) 2113 { 2114 int i; 2115 2116 for (i = 0; i < MAX_RX_MAC_RINGS; i++) 2117 dp_srng_deinit(soc, &pdev->rx_mac_buf_ring[i], RXDMA_BUF, 1); 2118 2119 dp_reap_timer_deinit(soc); 2120 } 2121 2122 /** 2123 * dp_rxdma_ring_free() - Free the RXDMA rings 2124 * @pdev: Physical device handle 2125 * 2126 * Return: void 2127 */ 2128 static void dp_rxdma_ring_free(struct dp_pdev *pdev) 2129 { 2130 int i; 2131 2132 for (i = 0; i < MAX_RX_MAC_RINGS; i++) 2133 dp_srng_free(pdev->soc, &pdev->rx_mac_buf_ring[i]); 2134 } 2135 2136 #else 2137 static int dp_rxdma_ring_alloc(struct dp_soc *soc, struct dp_pdev *pdev) 2138 { 2139 return QDF_STATUS_SUCCESS; 2140 } 2141 2142 static int dp_rxdma_ring_setup(struct dp_soc *soc, struct dp_pdev *pdev) 2143 { 2144 return QDF_STATUS_SUCCESS; 2145 } 2146 2147 static void dp_rxdma_ring_cleanup(struct dp_soc *soc, struct dp_pdev *pdev) 2148 { 2149 dp_reap_timer_deinit(soc); 2150 } 2151 2152 static void dp_rxdma_ring_free(struct dp_pdev *pdev) 2153 { 2154 } 2155 #endif 2156 2157 #ifdef IPA_OFFLOAD 2158 /** 2159 * dp_setup_ipa_rx_refill_buf_ring - Setup second Rx refill buffer ring 2160 * @soc: data path instance 2161 * @pdev: core txrx pdev context 2162 * 2163 * Return: QDF_STATUS_SUCCESS: success 2164 * QDF_STATUS_E_RESOURCES: Error return 2165 */ 2166 static int dp_setup_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2167 struct dp_pdev *pdev) 2168 { 2169 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 2170 int entries; 2171 2172 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { 2173 soc_cfg_ctx = soc->wlan_cfg_ctx; 2174 entries = 2175 wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); 2176 2177 /* Setup second Rx refill buffer ring */ 2178 if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, 2179 entries, 0)) { 2180 dp_init_err("%pK: dp_srng_alloc failed second" 2181 "rx refill ring", soc); 2182 return QDF_STATUS_E_FAILURE; 2183 } 2184 } 2185 2186 return QDF_STATUS_SUCCESS; 2187 } 2188 2189 #ifdef IPA_WDI3_VLAN_SUPPORT 2190 static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2191 struct dp_pdev *pdev) 2192 { 2193 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 2194 int entries; 2195 2196 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && 2197 wlan_ipa_is_vlan_enabled()) { 2198 soc_cfg_ctx = soc->wlan_cfg_ctx; 2199 entries = 2200 wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); 2201 2202 /* Setup second Rx refill buffer ring */ 2203 if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, 2204 entries, 0)) { 2205 dp_init_err("%pK: alloc failed for 3rd rx refill ring", 2206 soc); 2207 return QDF_STATUS_E_FAILURE; 2208 } 2209 } 2210 2211 return QDF_STATUS_SUCCESS; 2212 } 2213 2214 static int dp_init_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2215 struct dp_pdev *pdev) 2216 { 2217 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && 2218 wlan_ipa_is_vlan_enabled()) { 2219 if (dp_srng_init(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, 2220 IPA_RX_ALT_REFILL_BUF_RING_IDX, 2221 pdev->pdev_id)) { 2222 dp_init_err("%pK: init failed for 3rd rx refill ring", 2223 soc); 2224 return QDF_STATUS_E_FAILURE; 2225 } 2226 } 2227 2228 return QDF_STATUS_SUCCESS; 2229 } 2230 2231 static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2232 struct dp_pdev *pdev) 2233 { 2234 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && 2235 wlan_ipa_is_vlan_enabled()) 2236 dp_srng_deinit(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, 0); 2237 } 2238 2239 static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2240 struct dp_pdev *pdev) 2241 { 2242 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && 2243 wlan_ipa_is_vlan_enabled()) 2244 dp_srng_free(soc, &pdev->rx_refill_buf_ring3); 2245 } 2246 #else 2247 static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2248 struct dp_pdev *pdev) 2249 { 2250 return QDF_STATUS_SUCCESS; 2251 } 2252 2253 static int dp_init_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2254 struct dp_pdev *pdev) 2255 { 2256 return QDF_STATUS_SUCCESS; 2257 } 2258 2259 static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2260 struct dp_pdev *pdev) 2261 { 2262 } 2263 2264 static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2265 struct dp_pdev *pdev) 2266 { 2267 } 2268 #endif 2269 2270 /** 2271 * dp_deinit_ipa_rx_refill_buf_ring - deinit second Rx refill buffer ring 2272 * @soc: data path instance 2273 * @pdev: core txrx pdev context 2274 * 2275 * Return: void 2276 */ 2277 static void dp_deinit_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2278 struct dp_pdev *pdev) 2279 { 2280 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) 2281 dp_srng_deinit(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, 0); 2282 } 2283 2284 /** 2285 * dp_init_ipa_rx_refill_buf_ring - Init second Rx refill buffer ring 2286 * @soc: data path instance 2287 * @pdev: core txrx pdev context 2288 * 2289 * Return: QDF_STATUS_SUCCESS: success 2290 * QDF_STATUS_E_RESOURCES: Error return 2291 */ 2292 static int dp_init_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2293 struct dp_pdev *pdev) 2294 { 2295 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { 2296 if (dp_srng_init(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, 2297 IPA_RX_REFILL_BUF_RING_IDX, pdev->pdev_id)) { 2298 dp_init_err("%pK: dp_srng_init failed second" 2299 "rx refill ring", soc); 2300 return QDF_STATUS_E_FAILURE; 2301 } 2302 } 2303 2304 if (dp_init_ipa_rx_alt_refill_buf_ring(soc, pdev)) { 2305 dp_deinit_ipa_rx_refill_buf_ring(soc, pdev); 2306 return QDF_STATUS_E_FAILURE; 2307 } 2308 2309 return QDF_STATUS_SUCCESS; 2310 } 2311 2312 /** 2313 * dp_free_ipa_rx_refill_buf_ring - free second Rx refill buffer ring 2314 * @soc: data path instance 2315 * @pdev: core txrx pdev context 2316 * 2317 * Return: void 2318 */ 2319 static void dp_free_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2320 struct dp_pdev *pdev) 2321 { 2322 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) 2323 dp_srng_free(soc, &pdev->rx_refill_buf_ring2); 2324 } 2325 #else 2326 static int dp_setup_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2327 struct dp_pdev *pdev) 2328 { 2329 return QDF_STATUS_SUCCESS; 2330 } 2331 2332 static int dp_init_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2333 struct dp_pdev *pdev) 2334 { 2335 return QDF_STATUS_SUCCESS; 2336 } 2337 2338 static void dp_deinit_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2339 struct dp_pdev *pdev) 2340 { 2341 } 2342 2343 static void dp_free_ipa_rx_refill_buf_ring(struct dp_soc *soc, 2344 struct dp_pdev *pdev) 2345 { 2346 } 2347 2348 static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2349 struct dp_pdev *pdev) 2350 { 2351 return QDF_STATUS_SUCCESS; 2352 } 2353 2354 static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2355 struct dp_pdev *pdev) 2356 { 2357 } 2358 2359 static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, 2360 struct dp_pdev *pdev) 2361 { 2362 } 2363 #endif 2364 2365 #ifdef WLAN_FEATURE_DP_CFG_EVENT_HISTORY 2366 2367 /** 2368 * dp_soc_cfg_history_attach() - Allocate and attach datapath config events 2369 * history 2370 * @soc: DP soc handle 2371 * 2372 * Return: None 2373 */ 2374 static void dp_soc_cfg_history_attach(struct dp_soc *soc) 2375 { 2376 dp_soc_frag_history_attach(soc, &soc->cfg_event_history, 2377 DP_CFG_EVT_HIST_MAX_SLOTS, 2378 DP_CFG_EVT_HIST_PER_SLOT_MAX, 2379 sizeof(struct dp_cfg_event), 2380 true, DP_CFG_EVENT_HIST_TYPE); 2381 } 2382 2383 /** 2384 * dp_soc_cfg_history_detach() - Detach and free DP config events history 2385 * @soc: DP soc handle 2386 * 2387 * Return: none 2388 */ 2389 static void dp_soc_cfg_history_detach(struct dp_soc *soc) 2390 { 2391 dp_soc_frag_history_detach(soc, &soc->cfg_event_history, 2392 DP_CFG_EVT_HIST_MAX_SLOTS, 2393 true, DP_CFG_EVENT_HIST_TYPE); 2394 } 2395 2396 #else 2397 static void dp_soc_cfg_history_attach(struct dp_soc *soc) 2398 { 2399 } 2400 2401 static void dp_soc_cfg_history_detach(struct dp_soc *soc) 2402 { 2403 } 2404 #endif 2405 2406 #ifdef DP_TX_HW_DESC_HISTORY 2407 /** 2408 * dp_soc_tx_hw_desc_history_attach - Attach TX HW descriptor history 2409 * 2410 * @soc: DP soc handle 2411 * 2412 * Return: None 2413 */ 2414 static void dp_soc_tx_hw_desc_history_attach(struct dp_soc *soc) 2415 { 2416 dp_soc_frag_history_attach(soc, &soc->tx_hw_desc_history, 2417 DP_TX_HW_DESC_HIST_MAX_SLOTS, 2418 DP_TX_HW_DESC_HIST_PER_SLOT_MAX, 2419 sizeof(struct dp_tx_hw_desc_evt), 2420 true, DP_TX_HW_DESC_HIST_TYPE); 2421 } 2422 2423 static void dp_soc_tx_hw_desc_history_detach(struct dp_soc *soc) 2424 { 2425 dp_soc_frag_history_detach(soc, &soc->tx_hw_desc_history, 2426 DP_TX_HW_DESC_HIST_MAX_SLOTS, 2427 true, DP_TX_HW_DESC_HIST_TYPE); 2428 } 2429 2430 #else /* DP_TX_HW_DESC_HISTORY */ 2431 static inline void 2432 dp_soc_tx_hw_desc_history_attach(struct dp_soc *soc) 2433 { 2434 } 2435 2436 static inline void 2437 dp_soc_tx_hw_desc_history_detach(struct dp_soc *soc) 2438 { 2439 } 2440 #endif /* DP_TX_HW_DESC_HISTORY */ 2441 2442 #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY 2443 #ifndef RX_DEFRAG_DO_NOT_REINJECT 2444 /** 2445 * dp_soc_rx_reinject_ring_history_attach - Attach the reo reinject ring 2446 * history. 2447 * @soc: DP soc handle 2448 * 2449 * Return: None 2450 */ 2451 static void dp_soc_rx_reinject_ring_history_attach(struct dp_soc *soc) 2452 { 2453 soc->rx_reinject_ring_history = 2454 dp_context_alloc_mem(soc, DP_RX_REINJECT_RING_HIST_TYPE, 2455 sizeof(struct dp_rx_reinject_history)); 2456 if (soc->rx_reinject_ring_history) 2457 qdf_atomic_init(&soc->rx_reinject_ring_history->index); 2458 } 2459 #else /* RX_DEFRAG_DO_NOT_REINJECT */ 2460 static inline void 2461 dp_soc_rx_reinject_ring_history_attach(struct dp_soc *soc) 2462 { 2463 } 2464 #endif /* RX_DEFRAG_DO_NOT_REINJECT */ 2465 2466 /** 2467 * dp_soc_rx_history_attach() - Attach the ring history record buffers 2468 * @soc: DP soc structure 2469 * 2470 * This function allocates the memory for recording the rx ring, rx error 2471 * ring and the reinject ring entries. There is no error returned in case 2472 * of allocation failure since the record function checks if the history is 2473 * initialized or not. We do not want to fail the driver load in case of 2474 * failure to allocate memory for debug history. 2475 * 2476 * Return: None 2477 */ 2478 static void dp_soc_rx_history_attach(struct dp_soc *soc) 2479 { 2480 int i; 2481 uint32_t rx_ring_hist_size; 2482 uint32_t rx_refill_ring_hist_size; 2483 2484 rx_ring_hist_size = sizeof(*soc->rx_ring_history[0]); 2485 rx_refill_ring_hist_size = sizeof(*soc->rx_refill_ring_history[0]); 2486 2487 for (i = 0; i < MAX_REO_DEST_RINGS; i++) { 2488 soc->rx_ring_history[i] = dp_context_alloc_mem( 2489 soc, DP_RX_RING_HIST_TYPE, rx_ring_hist_size); 2490 if (soc->rx_ring_history[i]) 2491 qdf_atomic_init(&soc->rx_ring_history[i]->index); 2492 } 2493 2494 soc->rx_err_ring_history = dp_context_alloc_mem( 2495 soc, DP_RX_ERR_RING_HIST_TYPE, rx_ring_hist_size); 2496 if (soc->rx_err_ring_history) 2497 qdf_atomic_init(&soc->rx_err_ring_history->index); 2498 2499 dp_soc_rx_reinject_ring_history_attach(soc); 2500 2501 for (i = 0; i < MAX_PDEV_CNT; i++) { 2502 soc->rx_refill_ring_history[i] = dp_context_alloc_mem( 2503 soc, 2504 DP_RX_REFILL_RING_HIST_TYPE, 2505 rx_refill_ring_hist_size); 2506 2507 if (soc->rx_refill_ring_history[i]) 2508 qdf_atomic_init(&soc->rx_refill_ring_history[i]->index); 2509 } 2510 } 2511 2512 static void dp_soc_rx_history_detach(struct dp_soc *soc) 2513 { 2514 int i; 2515 2516 for (i = 0; i < MAX_REO_DEST_RINGS; i++) 2517 dp_context_free_mem(soc, DP_RX_RING_HIST_TYPE, 2518 soc->rx_ring_history[i]); 2519 2520 dp_context_free_mem(soc, DP_RX_ERR_RING_HIST_TYPE, 2521 soc->rx_err_ring_history); 2522 2523 /* 2524 * No need for a featurized detach since qdf_mem_free takes 2525 * care of NULL pointer. 2526 */ 2527 dp_context_free_mem(soc, DP_RX_REINJECT_RING_HIST_TYPE, 2528 soc->rx_reinject_ring_history); 2529 2530 for (i = 0; i < MAX_PDEV_CNT; i++) 2531 dp_context_free_mem(soc, DP_RX_REFILL_RING_HIST_TYPE, 2532 soc->rx_refill_ring_history[i]); 2533 } 2534 2535 #else 2536 static inline void dp_soc_rx_history_attach(struct dp_soc *soc) 2537 { 2538 } 2539 2540 static inline void dp_soc_rx_history_detach(struct dp_soc *soc) 2541 { 2542 } 2543 #endif 2544 2545 #ifdef WLAN_FEATURE_DP_MON_STATUS_RING_HISTORY 2546 /** 2547 * dp_soc_mon_status_ring_history_attach() - Attach the monitor status 2548 * buffer record history. 2549 * @soc: DP soc handle 2550 * 2551 * This function allocates memory to track the event for a monitor 2552 * status buffer, before its parsed and freed. 2553 * 2554 * Return: None 2555 */ 2556 static void dp_soc_mon_status_ring_history_attach(struct dp_soc *soc) 2557 { 2558 soc->mon_status_ring_history = dp_context_alloc_mem(soc, 2559 DP_MON_STATUS_BUF_HIST_TYPE, 2560 sizeof(struct dp_mon_status_ring_history)); 2561 if (!soc->mon_status_ring_history) { 2562 dp_err("Failed to alloc memory for mon status ring history"); 2563 return; 2564 } 2565 } 2566 2567 /** 2568 * dp_soc_mon_status_ring_history_detach() - Detach the monitor status buffer 2569 * record history. 2570 * @soc: DP soc handle 2571 * 2572 * Return: None 2573 */ 2574 static void dp_soc_mon_status_ring_history_detach(struct dp_soc *soc) 2575 { 2576 dp_context_free_mem(soc, DP_MON_STATUS_BUF_HIST_TYPE, 2577 soc->mon_status_ring_history); 2578 } 2579 #else 2580 static void dp_soc_mon_status_ring_history_attach(struct dp_soc *soc) 2581 { 2582 } 2583 2584 static void dp_soc_mon_status_ring_history_detach(struct dp_soc *soc) 2585 { 2586 } 2587 #endif 2588 2589 #ifdef WLAN_FEATURE_DP_TX_DESC_HISTORY 2590 /** 2591 * dp_soc_tx_history_attach() - Attach the ring history record buffers 2592 * @soc: DP soc structure 2593 * 2594 * This function allocates the memory for recording the tx tcl ring and 2595 * the tx comp ring entries. There is no error returned in case 2596 * of allocation failure since the record function checks if the history is 2597 * initialized or not. We do not want to fail the driver load in case of 2598 * failure to allocate memory for debug history. 2599 * 2600 * Return: None 2601 */ 2602 static void dp_soc_tx_history_attach(struct dp_soc *soc) 2603 { 2604 dp_soc_frag_history_attach(soc, &soc->tx_tcl_history, 2605 DP_TX_TCL_HIST_MAX_SLOTS, 2606 DP_TX_TCL_HIST_PER_SLOT_MAX, 2607 sizeof(struct dp_tx_desc_event), 2608 true, DP_TX_TCL_HIST_TYPE); 2609 dp_soc_frag_history_attach(soc, &soc->tx_comp_history, 2610 DP_TX_COMP_HIST_MAX_SLOTS, 2611 DP_TX_COMP_HIST_PER_SLOT_MAX, 2612 sizeof(struct dp_tx_desc_event), 2613 true, DP_TX_COMP_HIST_TYPE); 2614 } 2615 2616 /** 2617 * dp_soc_tx_history_detach() - Detach the ring history record buffers 2618 * @soc: DP soc structure 2619 * 2620 * This function frees the memory for recording the tx tcl ring and 2621 * the tx comp ring entries. 2622 * 2623 * Return: None 2624 */ 2625 static void dp_soc_tx_history_detach(struct dp_soc *soc) 2626 { 2627 dp_soc_frag_history_detach(soc, &soc->tx_tcl_history, 2628 DP_TX_TCL_HIST_MAX_SLOTS, 2629 true, DP_TX_TCL_HIST_TYPE); 2630 dp_soc_frag_history_detach(soc, &soc->tx_comp_history, 2631 DP_TX_COMP_HIST_MAX_SLOTS, 2632 true, DP_TX_COMP_HIST_TYPE); 2633 } 2634 2635 #else 2636 static inline void dp_soc_tx_history_attach(struct dp_soc *soc) 2637 { 2638 } 2639 2640 static inline void dp_soc_tx_history_detach(struct dp_soc *soc) 2641 { 2642 } 2643 #endif /* WLAN_FEATURE_DP_TX_DESC_HISTORY */ 2644 2645 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 2646 QDF_STATUS 2647 dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) 2648 { 2649 struct dp_rx_fst *rx_fst = NULL; 2650 QDF_STATUS ret = QDF_STATUS_SUCCESS; 2651 2652 /* for Lithium the below API is not registered 2653 * hence fst attach happens for each pdev 2654 */ 2655 if (!soc->arch_ops.dp_get_rx_fst) 2656 return dp_rx_fst_attach(soc, pdev); 2657 2658 rx_fst = soc->arch_ops.dp_get_rx_fst(); 2659 2660 /* for BE the FST attach is called only once per 2661 * ML context. if rx_fst is already registered 2662 * increase the ref count and return. 2663 */ 2664 if (rx_fst) { 2665 soc->rx_fst = rx_fst; 2666 pdev->rx_fst = rx_fst; 2667 soc->arch_ops.dp_rx_fst_ref(); 2668 } else { 2669 ret = dp_rx_fst_attach(soc, pdev); 2670 if ((ret != QDF_STATUS_SUCCESS) && 2671 (ret != QDF_STATUS_E_NOSUPPORT)) 2672 return ret; 2673 2674 soc->arch_ops.dp_set_rx_fst(soc->rx_fst); 2675 soc->arch_ops.dp_rx_fst_ref(); 2676 } 2677 return ret; 2678 } 2679 2680 void 2681 dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) 2682 { 2683 struct dp_rx_fst *rx_fst = NULL; 2684 2685 /* for Lithium the below API is not registered 2686 * hence fst detach happens for each pdev 2687 */ 2688 if (!soc->arch_ops.dp_get_rx_fst) { 2689 dp_rx_fst_detach(soc, pdev); 2690 return; 2691 } 2692 2693 rx_fst = soc->arch_ops.dp_get_rx_fst(); 2694 2695 /* for BE the FST detach is called only when last 2696 * ref count reaches 1. 2697 */ 2698 if (rx_fst) { 2699 if (soc->arch_ops.dp_rx_fst_deref() == 1) 2700 dp_rx_fst_detach(soc, pdev); 2701 } 2702 pdev->rx_fst = NULL; 2703 } 2704 #else 2705 QDF_STATUS 2706 dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) 2707 { 2708 return QDF_STATUS_SUCCESS; 2709 } 2710 2711 void 2712 dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) 2713 { 2714 } 2715 #endif 2716 2717 /** 2718 * dp_pdev_attach_wifi3() - attach txrx pdev 2719 * @txrx_soc: Datapath SOC handle 2720 * @params: Params for PDEV attach 2721 * 2722 * Return: QDF_STATUS 2723 */ 2724 static inline 2725 QDF_STATUS dp_pdev_attach_wifi3(struct cdp_soc_t *txrx_soc, 2726 struct cdp_pdev_attach_params *params) 2727 { 2728 qdf_size_t pdev_context_size; 2729 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 2730 struct dp_pdev *pdev = NULL; 2731 uint8_t pdev_id = params->pdev_id; 2732 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 2733 int nss_cfg; 2734 QDF_STATUS ret; 2735 2736 pdev_context_size = 2737 soc->arch_ops.txrx_get_context_size(DP_CONTEXT_TYPE_PDEV); 2738 if (pdev_context_size) 2739 pdev = dp_context_alloc_mem(soc, DP_PDEV_TYPE, 2740 pdev_context_size); 2741 2742 if (!pdev) { 2743 dp_init_err("%pK: DP PDEV memory allocation failed", 2744 soc); 2745 goto fail0; 2746 } 2747 wlan_minidump_log(pdev, sizeof(*pdev), soc->ctrl_psoc, 2748 WLAN_MD_DP_PDEV, "dp_pdev"); 2749 2750 soc_cfg_ctx = soc->wlan_cfg_ctx; 2751 pdev->wlan_cfg_ctx = wlan_cfg_pdev_attach(soc->ctrl_psoc); 2752 2753 if (!pdev->wlan_cfg_ctx) { 2754 dp_init_err("%pK: pdev cfg_attach failed", soc); 2755 goto fail1; 2756 } 2757 2758 pdev->soc = soc; 2759 pdev->pdev_id = pdev_id; 2760 soc->pdev_list[pdev_id] = pdev; 2761 2762 pdev->lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, pdev_id); 2763 soc->pdev_count++; 2764 2765 /*sync DP pdev cfg items with profile support after cfg_pdev_attach*/ 2766 wlan_dp_pdev_cfg_sync_profile((struct cdp_soc_t *)soc, pdev_id); 2767 2768 /* 2769 * set nss pdev config based on soc config 2770 */ 2771 nss_cfg = wlan_cfg_get_dp_soc_nss_cfg(soc_cfg_ctx); 2772 wlan_cfg_set_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx, 2773 (nss_cfg & (1 << pdev_id))); 2774 2775 /* Allocate memory for pdev srng rings */ 2776 if (dp_pdev_srng_alloc(pdev)) { 2777 dp_init_err("%pK: dp_pdev_srng_alloc failed", soc); 2778 goto fail2; 2779 } 2780 2781 /* Setup second Rx refill buffer ring */ 2782 if (dp_setup_ipa_rx_refill_buf_ring(soc, pdev)) { 2783 dp_init_err("%pK: dp_srng_alloc failed rxrefill2 ring", 2784 soc); 2785 goto fail3; 2786 } 2787 2788 /* Allocate memory for pdev rxdma rings */ 2789 if (dp_rxdma_ring_alloc(soc, pdev)) { 2790 dp_init_err("%pK: dp_rxdma_ring_alloc failed", soc); 2791 goto fail4; 2792 } 2793 2794 /* Rx specific init */ 2795 if (dp_rx_pdev_desc_pool_alloc(pdev)) { 2796 dp_init_err("%pK: dp_rx_pdev_attach failed", soc); 2797 goto fail4; 2798 } 2799 2800 if (dp_monitor_pdev_attach(pdev)) { 2801 dp_init_err("%pK: dp_monitor_pdev_attach failed", soc); 2802 goto fail5; 2803 } 2804 2805 soc->arch_ops.txrx_pdev_attach(pdev, params); 2806 2807 /* Setup third Rx refill buffer ring */ 2808 if (dp_setup_ipa_rx_alt_refill_buf_ring(soc, pdev)) { 2809 dp_init_err("%pK: dp_srng_alloc failed rxrefill3 ring", 2810 soc); 2811 goto fail6; 2812 } 2813 2814 ret = dp_rx_fst_attach_wrapper(soc, pdev); 2815 if ((ret != QDF_STATUS_SUCCESS) && (ret != QDF_STATUS_E_NOSUPPORT)) { 2816 dp_init_err("%pK: RX FST attach failed: pdev %d err %d", 2817 soc, pdev_id, ret); 2818 goto fail7; 2819 } 2820 2821 return QDF_STATUS_SUCCESS; 2822 2823 fail7: 2824 dp_free_ipa_rx_alt_refill_buf_ring(soc, pdev); 2825 fail6: 2826 dp_monitor_pdev_detach(pdev); 2827 fail5: 2828 dp_rx_pdev_desc_pool_free(pdev); 2829 fail4: 2830 dp_rxdma_ring_free(pdev); 2831 dp_free_ipa_rx_refill_buf_ring(soc, pdev); 2832 fail3: 2833 dp_pdev_srng_free(pdev); 2834 fail2: 2835 wlan_cfg_pdev_detach(pdev->wlan_cfg_ctx); 2836 fail1: 2837 soc->pdev_list[pdev_id] = NULL; 2838 qdf_mem_free(pdev); 2839 fail0: 2840 return QDF_STATUS_E_FAILURE; 2841 } 2842 2843 /** 2844 * dp_pdev_flush_pending_vdevs() - Flush all delete pending vdevs in pdev 2845 * @pdev: Datapath PDEV handle 2846 * 2847 * This is the last chance to flush all pending dp vdevs/peers, 2848 * some peer/vdev leak case like Non-SSR + peer unmap missing 2849 * will be covered here. 2850 * 2851 * Return: None 2852 */ 2853 static void dp_pdev_flush_pending_vdevs(struct dp_pdev *pdev) 2854 { 2855 struct dp_soc *soc = pdev->soc; 2856 struct dp_vdev *vdev_arr[MAX_VDEV_CNT] = {0}; 2857 uint32_t i = 0; 2858 uint32_t num_vdevs = 0; 2859 struct dp_vdev *vdev = NULL; 2860 2861 if (TAILQ_EMPTY(&soc->inactive_vdev_list)) 2862 return; 2863 2864 qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); 2865 TAILQ_FOREACH(vdev, &soc->inactive_vdev_list, 2866 inactive_list_elem) { 2867 if (vdev->pdev != pdev) 2868 continue; 2869 2870 vdev_arr[num_vdevs] = vdev; 2871 num_vdevs++; 2872 /* take reference to free */ 2873 dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CDP); 2874 } 2875 qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); 2876 2877 for (i = 0; i < num_vdevs; i++) { 2878 dp_vdev_flush_peers((struct cdp_vdev *)vdev_arr[i], 0, 0); 2879 dp_vdev_unref_delete(soc, vdev_arr[i], DP_MOD_ID_CDP); 2880 } 2881 } 2882 2883 #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT 2884 /** 2885 * dp_vdev_stats_hw_offload_target_config() - Send HTT command to FW 2886 * for enable/disable of HW vdev stats 2887 * @soc: Datapath soc handle 2888 * @pdev_id: INVALID_PDEV_ID for all pdevs or 0,1,2 for individual pdev 2889 * @enable: flag to represent enable/disable of hw vdev stats 2890 * 2891 * Return: none 2892 */ 2893 static void dp_vdev_stats_hw_offload_target_config(struct dp_soc *soc, 2894 uint8_t pdev_id, 2895 bool enable) 2896 { 2897 /* Check SOC level config for HW offload vdev stats support */ 2898 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { 2899 dp_debug("%pK: HW vdev offload stats is disabled", soc); 2900 return; 2901 } 2902 2903 /* Send HTT command to FW for enable of stats */ 2904 dp_h2t_hw_vdev_stats_config_send(soc, pdev_id, enable, false, 0); 2905 } 2906 2907 /** 2908 * dp_vdev_stats_hw_offload_target_clear() - Clear HW vdev stats on target 2909 * @soc: Datapath soc handle 2910 * @pdev_id: pdev_id (0,1,2) 2911 * @vdev_id_bitmask: bitmask with vdev_id(s) for which stats are to be 2912 * cleared on HW 2913 * 2914 * Return: none 2915 */ 2916 static 2917 void dp_vdev_stats_hw_offload_target_clear(struct dp_soc *soc, uint8_t pdev_id, 2918 uint64_t vdev_id_bitmask) 2919 { 2920 /* Check SOC level config for HW offload vdev stats support */ 2921 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { 2922 dp_debug("%pK: HW vdev offload stats is disabled", soc); 2923 return; 2924 } 2925 2926 /* Send HTT command to FW for reset of stats */ 2927 dp_h2t_hw_vdev_stats_config_send(soc, pdev_id, true, true, 2928 vdev_id_bitmask); 2929 } 2930 #else 2931 static void 2932 dp_vdev_stats_hw_offload_target_config(struct dp_soc *soc, uint8_t pdev_id, 2933 bool enable) 2934 { 2935 } 2936 2937 static 2938 void dp_vdev_stats_hw_offload_target_clear(struct dp_soc *soc, uint8_t pdev_id, 2939 uint64_t vdev_id_bitmask) 2940 { 2941 } 2942 #endif /*QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT */ 2943 2944 /** 2945 * dp_pdev_deinit() - Deinit txrx pdev 2946 * @txrx_pdev: Datapath PDEV handle 2947 * @force: Force deinit 2948 * 2949 * Return: None 2950 */ 2951 static void dp_pdev_deinit(struct cdp_pdev *txrx_pdev, int force) 2952 { 2953 struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; 2954 qdf_nbuf_t curr_nbuf, next_nbuf; 2955 2956 if (pdev->pdev_deinit) 2957 return; 2958 2959 dp_tx_me_exit(pdev); 2960 dp_rx_pdev_buffers_free(pdev); 2961 dp_rx_pdev_desc_pool_deinit(pdev); 2962 dp_pdev_bkp_stats_detach(pdev); 2963 qdf_event_destroy(&pdev->fw_peer_stats_event); 2964 qdf_event_destroy(&pdev->fw_stats_event); 2965 qdf_event_destroy(&pdev->fw_obss_stats_event); 2966 if (pdev->sojourn_buf) 2967 qdf_nbuf_free(pdev->sojourn_buf); 2968 2969 dp_pdev_flush_pending_vdevs(pdev); 2970 dp_tx_desc_flush(pdev, NULL, true); 2971 2972 qdf_spinlock_destroy(&pdev->tx_mutex); 2973 qdf_spinlock_destroy(&pdev->vdev_list_lock); 2974 2975 dp_monitor_pdev_deinit(pdev); 2976 2977 dp_pdev_srng_deinit(pdev); 2978 2979 dp_ipa_uc_detach(pdev->soc, pdev); 2980 dp_deinit_ipa_rx_alt_refill_buf_ring(pdev->soc, pdev); 2981 dp_deinit_ipa_rx_refill_buf_ring(pdev->soc, pdev); 2982 dp_rxdma_ring_cleanup(pdev->soc, pdev); 2983 2984 curr_nbuf = pdev->invalid_peer_head_msdu; 2985 while (curr_nbuf) { 2986 next_nbuf = qdf_nbuf_next(curr_nbuf); 2987 dp_rx_nbuf_free(curr_nbuf); 2988 curr_nbuf = next_nbuf; 2989 } 2990 pdev->invalid_peer_head_msdu = NULL; 2991 pdev->invalid_peer_tail_msdu = NULL; 2992 2993 dp_wdi_event_detach(pdev); 2994 pdev->pdev_deinit = 1; 2995 } 2996 2997 /** 2998 * dp_pdev_deinit_wifi3() - Deinit txrx pdev 2999 * @psoc: Datapath psoc handle 3000 * @pdev_id: Id of datapath PDEV handle 3001 * @force: Force deinit 3002 * 3003 * Return: QDF_STATUS 3004 */ 3005 static QDF_STATUS 3006 dp_pdev_deinit_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, 3007 int force) 3008 { 3009 struct dp_pdev *txrx_pdev; 3010 3011 txrx_pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)psoc, 3012 pdev_id); 3013 3014 if (!txrx_pdev) 3015 return QDF_STATUS_E_FAILURE; 3016 3017 dp_pdev_deinit((struct cdp_pdev *)txrx_pdev, force); 3018 3019 return QDF_STATUS_SUCCESS; 3020 } 3021 3022 /** 3023 * dp_pdev_post_attach() - Do post pdev attach after dev_alloc_name 3024 * @txrx_pdev: Datapath PDEV handle 3025 * 3026 * Return: None 3027 */ 3028 static void dp_pdev_post_attach(struct cdp_pdev *txrx_pdev) 3029 { 3030 struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; 3031 3032 dp_monitor_tx_capture_debugfs_init(pdev); 3033 3034 if (dp_pdev_htt_stats_dbgfs_init(pdev)) { 3035 dp_init_err("%pK: Failed to initialize pdev HTT stats debugfs", pdev->soc); 3036 } 3037 } 3038 3039 /** 3040 * dp_pdev_post_attach_wifi3() - attach txrx pdev post 3041 * @soc: Datapath soc handle 3042 * @pdev_id: pdev id of pdev 3043 * 3044 * Return: QDF_STATUS 3045 */ 3046 static int dp_pdev_post_attach_wifi3(struct cdp_soc_t *soc, 3047 uint8_t pdev_id) 3048 { 3049 struct dp_pdev *pdev; 3050 3051 pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 3052 pdev_id); 3053 3054 if (!pdev) { 3055 dp_init_err("%pK: DP PDEV is Null for pdev id %d", 3056 (struct dp_soc *)soc, pdev_id); 3057 return QDF_STATUS_E_FAILURE; 3058 } 3059 3060 dp_pdev_post_attach((struct cdp_pdev *)pdev); 3061 return QDF_STATUS_SUCCESS; 3062 } 3063 3064 /** 3065 * dp_pdev_detach() - Complete rest of pdev detach 3066 * @txrx_pdev: Datapath PDEV handle 3067 * @force: Force deinit 3068 * 3069 * Return: None 3070 */ 3071 static void dp_pdev_detach(struct cdp_pdev *txrx_pdev, int force) 3072 { 3073 struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; 3074 struct dp_soc *soc = pdev->soc; 3075 3076 dp_rx_fst_detach_wrapper(soc, pdev); 3077 dp_pdev_htt_stats_dbgfs_deinit(pdev); 3078 dp_rx_pdev_desc_pool_free(pdev); 3079 dp_monitor_pdev_detach(pdev); 3080 dp_rxdma_ring_free(pdev); 3081 dp_free_ipa_rx_refill_buf_ring(soc, pdev); 3082 dp_free_ipa_rx_alt_refill_buf_ring(soc, pdev); 3083 dp_pdev_srng_free(pdev); 3084 3085 soc->pdev_count--; 3086 soc->pdev_list[pdev->pdev_id] = NULL; 3087 3088 wlan_cfg_pdev_detach(pdev->wlan_cfg_ctx); 3089 wlan_minidump_remove(pdev, sizeof(*pdev), soc->ctrl_psoc, 3090 WLAN_MD_DP_PDEV, "dp_pdev"); 3091 dp_context_free_mem(soc, DP_PDEV_TYPE, pdev); 3092 } 3093 3094 /** 3095 * dp_pdev_detach_wifi3() - detach txrx pdev 3096 * @psoc: Datapath soc handle 3097 * @pdev_id: pdev id of pdev 3098 * @force: Force detach 3099 * 3100 * Return: QDF_STATUS 3101 */ 3102 static QDF_STATUS dp_pdev_detach_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, 3103 int force) 3104 { 3105 struct dp_pdev *pdev; 3106 struct dp_soc *soc = (struct dp_soc *)psoc; 3107 3108 pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)psoc, 3109 pdev_id); 3110 3111 if (!pdev) { 3112 dp_init_err("%pK: DP PDEV is Null for pdev id %d", 3113 (struct dp_soc *)psoc, pdev_id); 3114 return QDF_STATUS_E_FAILURE; 3115 } 3116 3117 soc->arch_ops.txrx_pdev_detach(pdev); 3118 3119 dp_pdev_detach((struct cdp_pdev *)pdev, force); 3120 return QDF_STATUS_SUCCESS; 3121 } 3122 3123 void dp_soc_print_inactive_objects(struct dp_soc *soc) 3124 { 3125 struct dp_peer *peer = NULL; 3126 struct dp_peer *tmp_peer = NULL; 3127 struct dp_vdev *vdev = NULL; 3128 struct dp_vdev *tmp_vdev = NULL; 3129 int i = 0; 3130 uint32_t count; 3131 3132 if (TAILQ_EMPTY(&soc->inactive_peer_list) && 3133 TAILQ_EMPTY(&soc->inactive_vdev_list)) 3134 return; 3135 3136 TAILQ_FOREACH_SAFE(peer, &soc->inactive_peer_list, 3137 inactive_list_elem, tmp_peer) { 3138 for (i = 0; i < DP_MOD_ID_MAX; i++) { 3139 count = qdf_atomic_read(&peer->mod_refs[i]); 3140 if (count) 3141 DP_PRINT_STATS("peer %pK Module id %u ==> %u", 3142 peer, i, count); 3143 } 3144 } 3145 3146 TAILQ_FOREACH_SAFE(vdev, &soc->inactive_vdev_list, 3147 inactive_list_elem, tmp_vdev) { 3148 for (i = 0; i < DP_MOD_ID_MAX; i++) { 3149 count = qdf_atomic_read(&vdev->mod_refs[i]); 3150 if (count) 3151 DP_PRINT_STATS("vdev %pK Module id %u ==> %u", 3152 vdev, i, count); 3153 } 3154 } 3155 QDF_BUG(0); 3156 } 3157 3158 /** 3159 * dp_soc_deinit_wifi3() - Deinitialize txrx SOC 3160 * @txrx_soc: Opaque DP SOC handle 3161 * 3162 * Return: None 3163 */ 3164 static void dp_soc_deinit_wifi3(struct cdp_soc_t *txrx_soc) 3165 { 3166 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 3167 3168 soc->arch_ops.txrx_soc_deinit(soc); 3169 } 3170 3171 /** 3172 * dp_soc_detach() - Detach rest of txrx SOC 3173 * @txrx_soc: DP SOC handle, struct cdp_soc_t is first element of struct dp_soc. 3174 * 3175 * Return: None 3176 */ 3177 static void dp_soc_detach(struct cdp_soc_t *txrx_soc) 3178 { 3179 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 3180 3181 soc->arch_ops.txrx_soc_detach(soc); 3182 3183 dp_runtime_deinit(); 3184 3185 dp_soc_unset_qref_debug_list(soc); 3186 dp_sysfs_deinitialize_stats(soc); 3187 dp_soc_swlm_detach(soc); 3188 dp_soc_tx_desc_sw_pools_free(soc); 3189 dp_soc_srng_free(soc); 3190 dp_hw_link_desc_ring_free(soc); 3191 dp_hw_link_desc_pool_banks_free(soc, WLAN_INVALID_PDEV_ID); 3192 wlan_cfg_soc_detach(soc->wlan_cfg_ctx); 3193 dp_soc_tx_hw_desc_history_detach(soc); 3194 dp_soc_tx_history_detach(soc); 3195 dp_soc_mon_status_ring_history_detach(soc); 3196 dp_soc_rx_history_detach(soc); 3197 dp_soc_cfg_history_detach(soc); 3198 3199 if (!dp_monitor_modularized_enable()) { 3200 dp_mon_soc_detach_wrapper(soc); 3201 } 3202 3203 qdf_mem_free(soc->cdp_soc.ops); 3204 qdf_mem_common_free(soc); 3205 } 3206 3207 /** 3208 * dp_soc_detach_wifi3() - Detach txrx SOC 3209 * @txrx_soc: DP SOC handle, struct cdp_soc_t is first element of struct dp_soc. 3210 * 3211 * Return: None 3212 */ 3213 static void dp_soc_detach_wifi3(struct cdp_soc_t *txrx_soc) 3214 { 3215 dp_soc_detach(txrx_soc); 3216 } 3217 3218 #ifdef QCA_HOST2FW_RXBUF_RING 3219 #ifdef IPA_WDI3_VLAN_SUPPORT 3220 static inline 3221 void dp_rxdma_setup_refill_ring3(struct dp_soc *soc, 3222 struct dp_pdev *pdev, 3223 uint8_t idx) 3224 { 3225 if (pdev->rx_refill_buf_ring3.hal_srng) 3226 htt_srng_setup(soc->htt_handle, idx, 3227 pdev->rx_refill_buf_ring3.hal_srng, 3228 RXDMA_BUF); 3229 } 3230 #else 3231 static inline 3232 void dp_rxdma_setup_refill_ring3(struct dp_soc *soc, 3233 struct dp_pdev *pdev, 3234 uint8_t idx) 3235 { } 3236 #endif 3237 3238 #ifdef WIFI_MONITOR_SUPPORT 3239 static inline QDF_STATUS dp_lpc_tx_config(struct dp_pdev *pdev) 3240 { 3241 return dp_local_pkt_capture_tx_config(pdev); 3242 } 3243 #else 3244 static inline QDF_STATUS dp_lpc_tx_config(struct dp_pdev *pdev) 3245 { 3246 return QDF_STATUS_SUCCESS; 3247 } 3248 #endif 3249 3250 /** 3251 * dp_rxdma_ring_config() - configure the RX DMA rings 3252 * @soc: data path SoC handle 3253 * 3254 * This function is used to configure the MAC rings. 3255 * On MCL host provides buffers in Host2FW ring 3256 * FW refills (copies) buffers to the ring and updates 3257 * ring_idx in register 3258 * 3259 * Return: zero on success, non-zero on failure 3260 */ 3261 static QDF_STATUS dp_rxdma_ring_config(struct dp_soc *soc) 3262 { 3263 int i; 3264 QDF_STATUS status = QDF_STATUS_SUCCESS; 3265 3266 for (i = 0; i < MAX_PDEV_CNT; i++) { 3267 struct dp_pdev *pdev = soc->pdev_list[i]; 3268 3269 if (pdev) { 3270 int mac_id; 3271 int max_mac_rings = 3272 wlan_cfg_get_num_mac_rings 3273 (pdev->wlan_cfg_ctx); 3274 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, 0, i); 3275 3276 htt_srng_setup(soc->htt_handle, i, 3277 soc->rx_refill_buf_ring[lmac_id] 3278 .hal_srng, 3279 RXDMA_BUF); 3280 3281 if (pdev->rx_refill_buf_ring2.hal_srng) 3282 htt_srng_setup(soc->htt_handle, i, 3283 pdev->rx_refill_buf_ring2 3284 .hal_srng, 3285 RXDMA_BUF); 3286 3287 dp_rxdma_setup_refill_ring3(soc, pdev, i); 3288 3289 dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings); 3290 dp_lpc_tx_config(pdev); 3291 dp_info("pdev_id %d max_mac_rings %d", 3292 pdev->pdev_id, max_mac_rings); 3293 3294 for (mac_id = 0; mac_id < max_mac_rings; mac_id++) { 3295 int mac_for_pdev = 3296 dp_get_mac_id_for_pdev(mac_id, 3297 pdev->pdev_id); 3298 /* 3299 * Obtain lmac id from pdev to access the LMAC 3300 * ring in soc context 3301 */ 3302 lmac_id = 3303 dp_get_lmac_id_for_pdev_id(soc, 3304 mac_id, 3305 pdev->pdev_id); 3306 dp_info("mac_id %d", mac_for_pdev); 3307 3308 htt_srng_setup(soc->htt_handle, mac_for_pdev, 3309 pdev->rx_mac_buf_ring[mac_id] 3310 .hal_srng, 3311 RXDMA_BUF); 3312 3313 if (!soc->rxdma2sw_rings_not_supported) 3314 dp_htt_setup_rxdma_err_dst_ring(soc, 3315 mac_for_pdev, lmac_id); 3316 3317 /* Configure monitor mode rings */ 3318 status = dp_monitor_htt_srng_setup(soc, pdev, 3319 lmac_id, 3320 mac_for_pdev); 3321 if (status != QDF_STATUS_SUCCESS) { 3322 dp_err("Failed to send htt monitor messages to target"); 3323 return status; 3324 } 3325 3326 } 3327 } 3328 } 3329 3330 dp_reap_timer_init(soc); 3331 return status; 3332 } 3333 #else 3334 /* This is only for WIN */ 3335 static QDF_STATUS dp_rxdma_ring_config(struct dp_soc *soc) 3336 { 3337 int i; 3338 QDF_STATUS status = QDF_STATUS_SUCCESS; 3339 int mac_for_pdev; 3340 int lmac_id; 3341 3342 /* Configure monitor mode rings */ 3343 dp_monitor_soc_htt_srng_setup(soc); 3344 3345 for (i = 0; i < MAX_PDEV_CNT; i++) { 3346 struct dp_pdev *pdev = soc->pdev_list[i]; 3347 3348 if (!pdev) 3349 continue; 3350 3351 mac_for_pdev = i; 3352 lmac_id = dp_get_lmac_id_for_pdev_id(soc, 0, i); 3353 3354 if (soc->rx_refill_buf_ring[lmac_id].hal_srng) 3355 htt_srng_setup(soc->htt_handle, mac_for_pdev, 3356 soc->rx_refill_buf_ring[lmac_id]. 3357 hal_srng, RXDMA_BUF); 3358 3359 /* Configure monitor mode rings */ 3360 dp_monitor_htt_srng_setup(soc, pdev, 3361 lmac_id, 3362 mac_for_pdev); 3363 if (!soc->rxdma2sw_rings_not_supported) 3364 htt_srng_setup(soc->htt_handle, mac_for_pdev, 3365 soc->rxdma_err_dst_ring[lmac_id].hal_srng, 3366 RXDMA_DST); 3367 } 3368 3369 dp_reap_timer_init(soc); 3370 return status; 3371 } 3372 #endif 3373 3374 /** 3375 * dp_rx_target_fst_config() - configure the RXOLE Flow Search Engine 3376 * 3377 * This function is used to configure the FSE HW block in RX OLE on a 3378 * per pdev basis. Here, we will be programming parameters related to 3379 * the Flow Search Table. 3380 * 3381 * @soc: data path SoC handle 3382 * 3383 * Return: zero on success, non-zero on failure 3384 */ 3385 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 3386 static QDF_STATUS 3387 dp_rx_target_fst_config(struct dp_soc *soc) 3388 { 3389 int i; 3390 QDF_STATUS status = QDF_STATUS_SUCCESS; 3391 3392 for (i = 0; i < MAX_PDEV_CNT; i++) { 3393 struct dp_pdev *pdev = soc->pdev_list[i]; 3394 3395 /* Flow search is not enabled if NSS offload is enabled */ 3396 if (pdev && 3397 !wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) { 3398 status = dp_rx_flow_send_fst_fw_setup(pdev->soc, pdev); 3399 if (status != QDF_STATUS_SUCCESS) 3400 break; 3401 } 3402 } 3403 return status; 3404 } 3405 #else 3406 static inline QDF_STATUS dp_rx_target_fst_config(struct dp_soc *soc) 3407 { 3408 return QDF_STATUS_SUCCESS; 3409 } 3410 #endif 3411 3412 #ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR 3413 static inline QDF_STATUS dp_print_swlm_stats(struct dp_soc *soc) 3414 { 3415 return QDF_STATUS_SUCCESS; 3416 } 3417 #endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */ 3418 3419 #ifdef WLAN_SUPPORT_PPEDS 3420 /** 3421 * dp_soc_target_ppe_rxole_rxdma_cfg() - Configure the RxOLe and RxDMA for PPE 3422 * @soc: DP Tx/Rx handle 3423 * 3424 * Return: QDF_STATUS 3425 */ 3426 static 3427 QDF_STATUS dp_soc_target_ppe_rxole_rxdma_cfg(struct dp_soc *soc) 3428 { 3429 struct dp_htt_rxdma_rxole_ppe_config htt_cfg = {0}; 3430 QDF_STATUS status; 3431 3432 /* 3433 * Program RxDMA to override the reo destination indication 3434 * with REO2PPE_DST_IND, when use_ppe is set to 1 in RX_MSDU_END, 3435 * thereby driving the packet to REO2PPE ring. 3436 * If the MSDU is spanning more than 1 buffer, then this 3437 * override is not done. 3438 */ 3439 htt_cfg.override = 1; 3440 htt_cfg.reo_destination_indication = REO2PPE_DST_IND; 3441 htt_cfg.multi_buffer_msdu_override_en = 0; 3442 3443 /* 3444 * Override use_ppe to 0 in RxOLE for the following 3445 * cases. 3446 */ 3447 htt_cfg.intra_bss_override = 1; 3448 htt_cfg.decap_raw_override = 1; 3449 htt_cfg.decap_nwifi_override = 1; 3450 htt_cfg.ip_frag_override = 1; 3451 3452 status = dp_htt_rxdma_rxole_ppe_cfg_set(soc, &htt_cfg); 3453 if (status != QDF_STATUS_SUCCESS) 3454 dp_err("RxOLE and RxDMA PPE config failed %d", status); 3455 3456 return status; 3457 } 3458 3459 #else 3460 static inline 3461 QDF_STATUS dp_soc_target_ppe_rxole_rxdma_cfg(struct dp_soc *soc) 3462 { 3463 return QDF_STATUS_SUCCESS; 3464 } 3465 3466 #endif /* WLAN_SUPPORT_PPEDS */ 3467 3468 #ifdef DP_UMAC_HW_RESET_SUPPORT 3469 static void dp_register_umac_reset_handlers(struct dp_soc *soc) 3470 { 3471 dp_umac_reset_register_rx_action_callback(soc, 3472 dp_umac_reset_action_trigger_recovery, 3473 UMAC_RESET_ACTION_DO_TRIGGER_RECOVERY); 3474 3475 dp_umac_reset_register_rx_action_callback(soc, 3476 dp_umac_reset_handle_pre_reset, UMAC_RESET_ACTION_DO_PRE_RESET); 3477 3478 dp_umac_reset_register_rx_action_callback(soc, 3479 dp_umac_reset_handle_post_reset, 3480 UMAC_RESET_ACTION_DO_POST_RESET_START); 3481 3482 dp_umac_reset_register_rx_action_callback(soc, 3483 dp_umac_reset_handle_post_reset_complete, 3484 UMAC_RESET_ACTION_DO_POST_RESET_COMPLETE); 3485 3486 } 3487 #else 3488 static void dp_register_umac_reset_handlers(struct dp_soc *soc) 3489 { 3490 } 3491 #endif 3492 /** 3493 * dp_soc_attach_target_wifi3() - SOC initialization in the target 3494 * @cdp_soc: Opaque Datapath SOC handle 3495 * 3496 * Return: zero on success, non-zero on failure 3497 */ 3498 static QDF_STATUS 3499 dp_soc_attach_target_wifi3(struct cdp_soc_t *cdp_soc) 3500 { 3501 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 3502 QDF_STATUS status = QDF_STATUS_SUCCESS; 3503 struct hal_reo_params reo_params; 3504 3505 htt_soc_attach_target(soc->htt_handle); 3506 3507 status = dp_soc_target_ppe_rxole_rxdma_cfg(soc); 3508 if (status != QDF_STATUS_SUCCESS) { 3509 dp_err("Failed to send htt RxOLE and RxDMA messages to target"); 3510 return status; 3511 } 3512 3513 status = dp_rxdma_ring_config(soc); 3514 if (status != QDF_STATUS_SUCCESS) { 3515 dp_err("Failed to send htt srng setup messages to target"); 3516 return status; 3517 } 3518 3519 status = soc->arch_ops.dp_rxdma_ring_sel_cfg(soc); 3520 if (status != QDF_STATUS_SUCCESS) { 3521 dp_err("Failed to send htt ring config message to target"); 3522 return status; 3523 } 3524 3525 status = dp_soc_umac_reset_init(cdp_soc); 3526 if (status != QDF_STATUS_SUCCESS && 3527 status != QDF_STATUS_E_NOSUPPORT) { 3528 dp_err("Failed to initialize UMAC reset"); 3529 return status; 3530 } 3531 3532 dp_register_umac_reset_handlers(soc); 3533 3534 status = dp_rx_target_fst_config(soc); 3535 if (status != QDF_STATUS_SUCCESS && 3536 status != QDF_STATUS_E_NOSUPPORT) { 3537 dp_err("Failed to send htt fst setup config message to target"); 3538 return status; 3539 } 3540 3541 DP_STATS_INIT(soc); 3542 3543 dp_runtime_init(soc); 3544 3545 /* Enable HW vdev offload stats if feature is supported */ 3546 dp_vdev_stats_hw_offload_target_config(soc, INVALID_PDEV_ID, true); 3547 3548 /* initialize work queue for stats processing */ 3549 qdf_create_work(0, &soc->htt_stats.work, htt_t2h_stats_handler, soc); 3550 3551 wlan_cfg_soc_update_tgt_params(soc->wlan_cfg_ctx, 3552 soc->ctrl_psoc); 3553 /* Setup HW REO */ 3554 qdf_mem_zero(&reo_params, sizeof(reo_params)); 3555 3556 if (wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { 3557 /* 3558 * Reo ring remap is not required if both radios 3559 * are offloaded to NSS 3560 */ 3561 3562 if (soc->arch_ops.reo_remap_config(soc, &reo_params.remap0, 3563 &reo_params.remap1, 3564 &reo_params.remap2)) 3565 reo_params.rx_hash_enabled = true; 3566 else 3567 reo_params.rx_hash_enabled = false; 3568 } 3569 3570 /* 3571 * set the fragment destination ring 3572 */ 3573 dp_reo_frag_dst_set(soc, &reo_params.frag_dst_ring); 3574 3575 if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) 3576 reo_params.alt_dst_ind_0 = REO_REMAP_RELEASE; 3577 3578 reo_params.reo_qref = &soc->reo_qref; 3579 hal_reo_setup(soc->hal_soc, &reo_params, 1); 3580 3581 hal_reo_set_err_dst_remap(soc->hal_soc); 3582 3583 soc->features.pn_in_reo_dest = hal_reo_enable_pn_in_dest(soc->hal_soc); 3584 3585 return QDF_STATUS_SUCCESS; 3586 } 3587 3588 /** 3589 * dp_vdev_id_map_tbl_add() - Add vdev into vdev_id table 3590 * @soc: SoC handle 3591 * @vdev: vdev handle 3592 * @vdev_id: vdev_id 3593 * 3594 * Return: None 3595 */ 3596 static void dp_vdev_id_map_tbl_add(struct dp_soc *soc, 3597 struct dp_vdev *vdev, 3598 uint8_t vdev_id) 3599 { 3600 QDF_ASSERT(vdev_id <= MAX_VDEV_CNT); 3601 3602 qdf_spin_lock_bh(&soc->vdev_map_lock); 3603 3604 if (dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CONFIG) != 3605 QDF_STATUS_SUCCESS) { 3606 dp_vdev_info("%pK: unable to get vdev reference at MAP vdev %pK vdev_id %u", 3607 soc, vdev, vdev_id); 3608 qdf_spin_unlock_bh(&soc->vdev_map_lock); 3609 return; 3610 } 3611 3612 if (!soc->vdev_id_map[vdev_id]) 3613 soc->vdev_id_map[vdev_id] = vdev; 3614 else 3615 QDF_ASSERT(0); 3616 3617 qdf_spin_unlock_bh(&soc->vdev_map_lock); 3618 } 3619 3620 /** 3621 * dp_vdev_id_map_tbl_remove() - remove vdev from vdev_id table 3622 * @soc: SoC handle 3623 * @vdev: vdev handle 3624 * 3625 * Return: None 3626 */ 3627 static void dp_vdev_id_map_tbl_remove(struct dp_soc *soc, 3628 struct dp_vdev *vdev) 3629 { 3630 qdf_spin_lock_bh(&soc->vdev_map_lock); 3631 QDF_ASSERT(soc->vdev_id_map[vdev->vdev_id] == vdev); 3632 3633 soc->vdev_id_map[vdev->vdev_id] = NULL; 3634 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); 3635 qdf_spin_unlock_bh(&soc->vdev_map_lock); 3636 } 3637 3638 /** 3639 * dp_vdev_pdev_list_add() - add vdev into pdev's list 3640 * @soc: soc handle 3641 * @pdev: pdev handle 3642 * @vdev: vdev handle 3643 * 3644 * Return: none 3645 */ 3646 static void dp_vdev_pdev_list_add(struct dp_soc *soc, 3647 struct dp_pdev *pdev, 3648 struct dp_vdev *vdev) 3649 { 3650 qdf_spin_lock_bh(&pdev->vdev_list_lock); 3651 if (dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CONFIG) != 3652 QDF_STATUS_SUCCESS) { 3653 dp_vdev_info("%pK: unable to get vdev reference at MAP vdev %pK", 3654 soc, vdev); 3655 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 3656 return; 3657 } 3658 /* add this vdev into the pdev's list */ 3659 TAILQ_INSERT_TAIL(&pdev->vdev_list, vdev, vdev_list_elem); 3660 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 3661 } 3662 3663 /** 3664 * dp_vdev_pdev_list_remove() - remove vdev from pdev's list 3665 * @soc: SoC handle 3666 * @pdev: pdev handle 3667 * @vdev: VDEV handle 3668 * 3669 * Return: none 3670 */ 3671 static void dp_vdev_pdev_list_remove(struct dp_soc *soc, 3672 struct dp_pdev *pdev, 3673 struct dp_vdev *vdev) 3674 { 3675 uint8_t found = 0; 3676 struct dp_vdev *tmpvdev = NULL; 3677 3678 qdf_spin_lock_bh(&pdev->vdev_list_lock); 3679 TAILQ_FOREACH(tmpvdev, &pdev->vdev_list, vdev_list_elem) { 3680 if (tmpvdev == vdev) { 3681 found = 1; 3682 break; 3683 } 3684 } 3685 3686 if (found) { 3687 TAILQ_REMOVE(&pdev->vdev_list, vdev, vdev_list_elem); 3688 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); 3689 } else { 3690 dp_vdev_debug("%pK: vdev:%pK not found in pdev:%pK vdevlist:%pK", 3691 soc, vdev, pdev, &pdev->vdev_list); 3692 QDF_ASSERT(0); 3693 } 3694 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 3695 } 3696 3697 #ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT 3698 /** 3699 * dp_vdev_init_rx_eapol() - initializing osif_rx_eapol 3700 * @vdev: Datapath VDEV handle 3701 * 3702 * Return: None 3703 */ 3704 static inline void dp_vdev_init_rx_eapol(struct dp_vdev *vdev) 3705 { 3706 vdev->osif_rx_eapol = NULL; 3707 } 3708 3709 /** 3710 * dp_vdev_register_rx_eapol() - Register VDEV operations for rx_eapol 3711 * @vdev: DP vdev handle 3712 * @txrx_ops: Tx and Rx operations 3713 * 3714 * Return: None 3715 */ 3716 static inline void dp_vdev_register_rx_eapol(struct dp_vdev *vdev, 3717 struct ol_txrx_ops *txrx_ops) 3718 { 3719 vdev->osif_rx_eapol = txrx_ops->rx.rx_eapol; 3720 } 3721 #else 3722 static inline void dp_vdev_init_rx_eapol(struct dp_vdev *vdev) 3723 { 3724 } 3725 3726 static inline void dp_vdev_register_rx_eapol(struct dp_vdev *vdev, 3727 struct ol_txrx_ops *txrx_ops) 3728 { 3729 } 3730 #endif 3731 3732 #ifdef WLAN_FEATURE_11BE_MLO 3733 static inline void dp_vdev_save_mld_addr(struct dp_vdev *vdev, 3734 struct cdp_vdev_info *vdev_info) 3735 { 3736 if (vdev_info->mld_mac_addr) 3737 qdf_mem_copy(&vdev->mld_mac_addr.raw[0], 3738 vdev_info->mld_mac_addr, QDF_MAC_ADDR_SIZE); 3739 } 3740 3741 #ifdef WLAN_MLO_MULTI_CHIP 3742 static inline void 3743 dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, 3744 struct cdp_vdev_info *vdev_info) 3745 { 3746 if (vdev_info->is_bridge_vap) 3747 vdev->is_bridge_vdev = 1; 3748 3749 dp_info("is_bridge_link = %d vdev id = %d chip id = %d", 3750 vdev->is_bridge_vdev, vdev->vdev_id, 3751 dp_mlo_get_chip_id(vdev->pdev->soc)); 3752 } 3753 #else 3754 static inline void 3755 dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, 3756 struct cdp_vdev_info *vdev_info) 3757 { 3758 } 3759 #endif /* WLAN_MLO_MULTI_CHIP */ 3760 3761 #else 3762 static inline void dp_vdev_save_mld_addr(struct dp_vdev *vdev, 3763 struct cdp_vdev_info *vdev_info) 3764 { 3765 3766 } 3767 3768 static inline void 3769 dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, 3770 struct cdp_vdev_info *vdev_info) 3771 { 3772 } 3773 #endif 3774 3775 #ifdef DP_TRAFFIC_END_INDICATION 3776 /** 3777 * dp_tx_vdev_traffic_end_indication_attach() - Initialize data end indication 3778 * related members in VDEV 3779 * @vdev: DP vdev handle 3780 * 3781 * Return: None 3782 */ 3783 static inline void 3784 dp_tx_vdev_traffic_end_indication_attach(struct dp_vdev *vdev) 3785 { 3786 qdf_nbuf_queue_init(&vdev->end_ind_pkt_q); 3787 } 3788 3789 /** 3790 * dp_tx_vdev_traffic_end_indication_detach() - De-init data end indication 3791 * related members in VDEV 3792 * @vdev: DP vdev handle 3793 * 3794 * Return: None 3795 */ 3796 static inline void 3797 dp_tx_vdev_traffic_end_indication_detach(struct dp_vdev *vdev) 3798 { 3799 qdf_nbuf_t nbuf; 3800 3801 while ((nbuf = qdf_nbuf_queue_remove(&vdev->end_ind_pkt_q)) != NULL) 3802 qdf_nbuf_free(nbuf); 3803 } 3804 #else 3805 static inline void 3806 dp_tx_vdev_traffic_end_indication_attach(struct dp_vdev *vdev) 3807 {} 3808 3809 static inline void 3810 dp_tx_vdev_traffic_end_indication_detach(struct dp_vdev *vdev) 3811 {} 3812 #endif 3813 3814 #ifdef WLAN_DP_VDEV_NO_SELF_PEER 3815 static inline bool dp_vdev_self_peer_required(struct dp_soc *soc, 3816 struct dp_vdev *vdev) 3817 { 3818 return false; 3819 } 3820 #else 3821 static inline bool dp_vdev_self_peer_required(struct dp_soc *soc, 3822 struct dp_vdev *vdev) 3823 { 3824 if (wlan_op_mode_sta == vdev->opmode) 3825 return true; 3826 3827 return false; 3828 } 3829 #endif 3830 3831 /** 3832 * dp_vdev_attach_wifi3() - attach txrx vdev 3833 * @cdp_soc: CDP SoC context 3834 * @pdev_id: PDEV ID for vdev creation 3835 * @vdev_info: parameters used for vdev creation 3836 * 3837 * Return: status 3838 */ 3839 static QDF_STATUS dp_vdev_attach_wifi3(struct cdp_soc_t *cdp_soc, 3840 uint8_t pdev_id, 3841 struct cdp_vdev_info *vdev_info) 3842 { 3843 int i = 0; 3844 qdf_size_t vdev_context_size; 3845 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 3846 struct dp_pdev *pdev = 3847 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 3848 pdev_id); 3849 struct dp_vdev *vdev; 3850 uint8_t *vdev_mac_addr = vdev_info->vdev_mac_addr; 3851 uint8_t vdev_id = vdev_info->vdev_id; 3852 enum wlan_op_mode op_mode = vdev_info->op_mode; 3853 enum wlan_op_subtype subtype = vdev_info->subtype; 3854 enum QDF_OPMODE qdf_opmode = vdev_info->qdf_opmode; 3855 uint8_t vdev_stats_id = vdev_info->vdev_stats_id; 3856 3857 vdev_context_size = 3858 soc->arch_ops.txrx_get_context_size(DP_CONTEXT_TYPE_VDEV); 3859 vdev = qdf_mem_malloc(vdev_context_size); 3860 3861 if (!pdev) { 3862 dp_init_err("%pK: DP PDEV is Null for pdev id %d", 3863 cdp_soc, pdev_id); 3864 qdf_mem_free(vdev); 3865 goto fail0; 3866 } 3867 3868 if (!vdev) { 3869 dp_init_err("%pK: DP VDEV memory allocation failed", 3870 cdp_soc); 3871 goto fail0; 3872 } 3873 3874 wlan_minidump_log(vdev, sizeof(*vdev), soc->ctrl_psoc, 3875 WLAN_MD_DP_VDEV, "dp_vdev"); 3876 3877 vdev->pdev = pdev; 3878 vdev->vdev_id = vdev_id; 3879 vdev->vdev_stats_id = vdev_stats_id; 3880 vdev->opmode = op_mode; 3881 vdev->subtype = subtype; 3882 vdev->qdf_opmode = qdf_opmode; 3883 vdev->osdev = soc->osdev; 3884 3885 vdev->osif_rx = NULL; 3886 vdev->osif_rsim_rx_decap = NULL; 3887 vdev->osif_get_key = NULL; 3888 vdev->osif_tx_free_ext = NULL; 3889 vdev->osif_vdev = NULL; 3890 3891 vdev->delete.pending = 0; 3892 vdev->safemode = 0; 3893 vdev->drop_unenc = 1; 3894 vdev->sec_type = cdp_sec_type_none; 3895 vdev->multipass_en = false; 3896 vdev->wrap_vdev = false; 3897 dp_vdev_init_rx_eapol(vdev); 3898 qdf_atomic_init(&vdev->ref_cnt); 3899 for (i = 0; i < DP_MOD_ID_MAX; i++) 3900 qdf_atomic_init(&vdev->mod_refs[i]); 3901 3902 /* Take one reference for create*/ 3903 qdf_atomic_inc(&vdev->ref_cnt); 3904 qdf_atomic_inc(&vdev->mod_refs[DP_MOD_ID_CONFIG]); 3905 vdev->num_peers = 0; 3906 #ifdef notyet 3907 vdev->filters_num = 0; 3908 #endif 3909 vdev->lmac_id = pdev->lmac_id; 3910 3911 qdf_mem_copy(&vdev->mac_addr.raw[0], vdev_mac_addr, QDF_MAC_ADDR_SIZE); 3912 3913 dp_vdev_update_bridge_vdev_param(vdev, vdev_info); 3914 dp_vdev_save_mld_addr(vdev, vdev_info); 3915 3916 /* TODO: Initialize default HTT meta data that will be used in 3917 * TCL descriptors for packets transmitted from this VDEV 3918 */ 3919 3920 qdf_spinlock_create(&vdev->peer_list_lock); 3921 TAILQ_INIT(&vdev->peer_list); 3922 dp_peer_multipass_list_init(vdev); 3923 if ((soc->intr_mode == DP_INTR_POLL) && 3924 wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx) != 0) { 3925 if ((pdev->vdev_count == 0) || 3926 (wlan_op_mode_monitor == vdev->opmode)) 3927 qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); 3928 } else if (dp_soc_get_con_mode(soc) == QDF_GLOBAL_MISSION_MODE && 3929 soc->intr_mode == DP_INTR_MSI && 3930 wlan_op_mode_monitor == vdev->opmode && 3931 !wlan_cfg_get_local_pkt_capture(soc->wlan_cfg_ctx)) { 3932 /* Timer to reap status ring in mission mode */ 3933 dp_monitor_vdev_timer_start(soc); 3934 } 3935 3936 dp_vdev_id_map_tbl_add(soc, vdev, vdev_id); 3937 3938 if (wlan_op_mode_monitor == vdev->opmode) { 3939 if (dp_monitor_vdev_attach(vdev) == QDF_STATUS_SUCCESS) { 3940 dp_monitor_pdev_set_mon_vdev(vdev); 3941 return dp_monitor_vdev_set_monitor_mode_buf_rings(pdev); 3942 } 3943 return QDF_STATUS_E_FAILURE; 3944 } 3945 3946 vdev->tx_encap_type = wlan_cfg_pkt_type(soc->wlan_cfg_ctx); 3947 vdev->rx_decap_type = wlan_cfg_pkt_type(soc->wlan_cfg_ctx); 3948 vdev->dscp_tid_map_id = 0; 3949 vdev->mcast_enhancement_en = 0; 3950 vdev->igmp_mcast_enhanc_en = 0; 3951 vdev->raw_mode_war = wlan_cfg_get_raw_mode_war(soc->wlan_cfg_ctx); 3952 vdev->prev_tx_enq_tstamp = 0; 3953 vdev->prev_rx_deliver_tstamp = 0; 3954 vdev->skip_sw_tid_classification = DP_TX_HW_DSCP_TID_MAP_VALID; 3955 dp_tx_vdev_traffic_end_indication_attach(vdev); 3956 3957 dp_vdev_pdev_list_add(soc, pdev, vdev); 3958 pdev->vdev_count++; 3959 3960 if (wlan_op_mode_sta != vdev->opmode && 3961 wlan_op_mode_ndi != vdev->opmode) 3962 vdev->ap_bridge_enabled = true; 3963 else 3964 vdev->ap_bridge_enabled = false; 3965 dp_init_info("%pK: wlan_cfg_ap_bridge_enabled %d", 3966 cdp_soc, vdev->ap_bridge_enabled); 3967 3968 dp_tx_vdev_attach(vdev); 3969 3970 dp_monitor_vdev_attach(vdev); 3971 if (!pdev->is_lro_hash_configured) { 3972 if (QDF_IS_STATUS_SUCCESS(dp_lro_hash_setup(soc, pdev))) 3973 pdev->is_lro_hash_configured = true; 3974 else 3975 dp_err("LRO hash setup failure!"); 3976 } 3977 3978 dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_ATTACH, vdev); 3979 dp_info("Created vdev %pK ("QDF_MAC_ADDR_FMT") vdev_id %d", vdev, 3980 QDF_MAC_ADDR_REF(vdev->mac_addr.raw), vdev->vdev_id); 3981 DP_STATS_INIT(vdev); 3982 3983 if (QDF_IS_STATUS_ERROR(soc->arch_ops.txrx_vdev_attach(soc, vdev))) 3984 goto fail0; 3985 3986 if (dp_vdev_self_peer_required(soc, vdev)) 3987 dp_peer_create_wifi3((struct cdp_soc_t *)soc, vdev_id, 3988 vdev->mac_addr.raw, CDP_LINK_PEER_TYPE); 3989 3990 dp_pdev_update_fast_rx_flag(soc, pdev); 3991 3992 return QDF_STATUS_SUCCESS; 3993 3994 fail0: 3995 return QDF_STATUS_E_FAILURE; 3996 } 3997 3998 #ifndef QCA_HOST_MODE_WIFI_DISABLED 3999 /** 4000 * dp_vdev_fetch_tx_handler() - Fetch Tx handlers 4001 * @vdev: struct dp_vdev * 4002 * @soc: struct dp_soc * 4003 * @ctx: struct ol_txrx_hardtart_ctxt * 4004 */ 4005 static inline void dp_vdev_fetch_tx_handler(struct dp_vdev *vdev, 4006 struct dp_soc *soc, 4007 struct ol_txrx_hardtart_ctxt *ctx) 4008 { 4009 /* Enable vdev_id check only for ap, if flag is enabled */ 4010 if (vdev->mesh_vdev) 4011 ctx->tx = dp_tx_send_mesh; 4012 else if ((wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx)) && 4013 (vdev->opmode == wlan_op_mode_ap)) { 4014 ctx->tx = dp_tx_send_vdev_id_check; 4015 ctx->tx_fast = dp_tx_send_vdev_id_check; 4016 } else { 4017 ctx->tx = dp_tx_send; 4018 ctx->tx_fast = soc->arch_ops.dp_tx_send_fast; 4019 } 4020 4021 /* Avoid check in regular exception Path */ 4022 if ((wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx)) && 4023 (vdev->opmode == wlan_op_mode_ap)) 4024 ctx->tx_exception = dp_tx_send_exception_vdev_id_check; 4025 else 4026 ctx->tx_exception = dp_tx_send_exception; 4027 } 4028 4029 /** 4030 * dp_vdev_register_tx_handler() - Register Tx handler 4031 * @vdev: struct dp_vdev * 4032 * @soc: struct dp_soc * 4033 * @txrx_ops: struct ol_txrx_ops * 4034 */ 4035 static inline void dp_vdev_register_tx_handler(struct dp_vdev *vdev, 4036 struct dp_soc *soc, 4037 struct ol_txrx_ops *txrx_ops) 4038 { 4039 struct ol_txrx_hardtart_ctxt ctx = {0}; 4040 4041 dp_vdev_fetch_tx_handler(vdev, soc, &ctx); 4042 4043 txrx_ops->tx.tx = ctx.tx; 4044 txrx_ops->tx.tx_fast = ctx.tx_fast; 4045 txrx_ops->tx.tx_exception = ctx.tx_exception; 4046 4047 dp_info("Configure tx_vdev_id_chk_handler Feature Flag: %d and mode:%d for vdev_id:%d", 4048 wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx), 4049 vdev->opmode, vdev->vdev_id); 4050 } 4051 #else /* QCA_HOST_MODE_WIFI_DISABLED */ 4052 static inline void dp_vdev_register_tx_handler(struct dp_vdev *vdev, 4053 struct dp_soc *soc, 4054 struct ol_txrx_ops *txrx_ops) 4055 { 4056 } 4057 4058 static inline void dp_vdev_fetch_tx_handler(struct dp_vdev *vdev, 4059 struct dp_soc *soc, 4060 struct ol_txrx_hardtart_ctxt *ctx) 4061 { 4062 } 4063 #endif /* QCA_HOST_MODE_WIFI_DISABLED */ 4064 4065 /** 4066 * dp_vdev_register_wifi3() - Register VDEV operations from osif layer 4067 * @soc_hdl: Datapath soc handle 4068 * @vdev_id: id of Datapath VDEV handle 4069 * @osif_vdev: OSIF vdev handle 4070 * @txrx_ops: Tx and Rx operations 4071 * 4072 * Return: DP VDEV handle on success, NULL on failure 4073 */ 4074 static QDF_STATUS dp_vdev_register_wifi3(struct cdp_soc_t *soc_hdl, 4075 uint8_t vdev_id, 4076 ol_osif_vdev_handle osif_vdev, 4077 struct ol_txrx_ops *txrx_ops) 4078 { 4079 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 4080 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 4081 DP_MOD_ID_CDP); 4082 4083 if (!vdev) 4084 return QDF_STATUS_E_FAILURE; 4085 4086 vdev->osif_vdev = osif_vdev; 4087 vdev->osif_rx = txrx_ops->rx.rx; 4088 vdev->osif_rx_stack = txrx_ops->rx.rx_stack; 4089 vdev->osif_rx_flush = txrx_ops->rx.rx_flush; 4090 vdev->osif_gro_flush = txrx_ops->rx.rx_gro_flush; 4091 vdev->osif_rsim_rx_decap = txrx_ops->rx.rsim_rx_decap; 4092 vdev->osif_fisa_rx = txrx_ops->rx.osif_fisa_rx; 4093 vdev->osif_fisa_flush = txrx_ops->rx.osif_fisa_flush; 4094 vdev->osif_get_key = txrx_ops->get_key; 4095 dp_monitor_vdev_register_osif(vdev, txrx_ops); 4096 vdev->osif_tx_free_ext = txrx_ops->tx.tx_free_ext; 4097 vdev->tx_comp = txrx_ops->tx.tx_comp; 4098 vdev->stats_cb = txrx_ops->rx.stats_rx; 4099 vdev->tx_classify_critical_pkt_cb = 4100 txrx_ops->tx.tx_classify_critical_pkt_cb; 4101 #ifdef notyet 4102 #if ATH_SUPPORT_WAPI 4103 vdev->osif_check_wai = txrx_ops->rx.wai_check; 4104 #endif 4105 #endif 4106 #ifdef UMAC_SUPPORT_PROXY_ARP 4107 vdev->osif_proxy_arp = txrx_ops->proxy_arp; 4108 #endif 4109 vdev->me_convert = txrx_ops->me_convert; 4110 vdev->get_tsf_time = txrx_ops->get_tsf_time; 4111 4112 dp_vdev_register_rx_eapol(vdev, txrx_ops); 4113 4114 dp_vdev_register_tx_handler(vdev, soc, txrx_ops); 4115 4116 dp_init_info("%pK: DP Vdev Register success", soc); 4117 4118 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4119 return QDF_STATUS_SUCCESS; 4120 } 4121 4122 #ifdef WLAN_FEATURE_11BE_MLO 4123 void dp_peer_delete(struct dp_soc *soc, 4124 struct dp_peer *peer, 4125 void *arg) 4126 { 4127 if (!peer->valid) 4128 return; 4129 4130 dp_peer_delete_wifi3((struct cdp_soc_t *)soc, 4131 peer->vdev->vdev_id, 4132 peer->mac_addr.raw, 0, 4133 peer->peer_type); 4134 } 4135 #else 4136 void dp_peer_delete(struct dp_soc *soc, 4137 struct dp_peer *peer, 4138 void *arg) 4139 { 4140 if (!peer->valid) 4141 return; 4142 4143 dp_peer_delete_wifi3((struct cdp_soc_t *)soc, 4144 peer->vdev->vdev_id, 4145 peer->mac_addr.raw, 0, 4146 CDP_LINK_PEER_TYPE); 4147 } 4148 #endif 4149 4150 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 4151 static uint8_t 4152 dp_mlo_get_num_link_peer(struct dp_soc *soc, struct dp_peer *peer) 4153 { 4154 if (soc->cdp_soc.ol_ops->peer_get_num_mlo_links) 4155 return soc->cdp_soc.ol_ops->peer_get_num_mlo_links( 4156 soc->ctrl_psoc, 4157 peer->vdev->vdev_id, 4158 peer->mac_addr.raw, 4159 IS_MLO_DP_MLD_PEER(peer)); 4160 4161 return 0; 4162 } 4163 4164 void dp_mlo_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) 4165 { 4166 if (!peer->valid) 4167 return; 4168 4169 /* skip deleting the SLO peers */ 4170 if (dp_mlo_get_num_link_peer(soc, peer) == 1) 4171 return; 4172 4173 if (IS_MLO_DP_LINK_PEER(peer)) 4174 dp_peer_delete_wifi3((struct cdp_soc_t *)soc, 4175 peer->vdev->vdev_id, 4176 peer->mac_addr.raw, 0, 4177 CDP_LINK_PEER_TYPE); 4178 } 4179 4180 /** 4181 * dp_mlo_link_peer_flush() - flush all the link peers 4182 * @soc: Datapath soc handle 4183 * @peer: DP peer handle to be checked 4184 * 4185 * Return: None 4186 */ 4187 static void dp_mlo_link_peer_flush(struct dp_soc *soc, struct dp_peer *peer) 4188 { 4189 int cnt = 0; 4190 struct dp_peer *link_peer = NULL; 4191 struct dp_mld_link_peers link_peers_info = {NULL}; 4192 4193 if (!IS_MLO_DP_MLD_PEER(peer)) 4194 return; 4195 4196 /* get link peers with reference */ 4197 dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, 4198 DP_MOD_ID_CDP); 4199 for (cnt = 0; cnt < link_peers_info.num_links; cnt++) { 4200 link_peer = link_peers_info.link_peers[cnt]; 4201 if (!link_peer) 4202 continue; 4203 4204 /* delete all the link peers */ 4205 dp_mlo_peer_delete(link_peer->vdev->pdev->soc, link_peer, NULL); 4206 /* unmap all the link peers */ 4207 dp_rx_peer_unmap_handler(link_peer->vdev->pdev->soc, 4208 link_peer->peer_id, 4209 link_peer->vdev->vdev_id, 4210 link_peer->mac_addr.raw, 0, 4211 DP_PEER_WDS_COUNT_INVALID); 4212 } 4213 dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); 4214 } 4215 #else 4216 static uint8_t 4217 dp_mlo_get_num_link_peer(struct dp_soc *soc, struct dp_peer *peer) 4218 { 4219 return 0; 4220 } 4221 4222 void dp_mlo_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) 4223 { 4224 } 4225 4226 static void dp_mlo_link_peer_flush(struct dp_soc *soc, struct dp_peer *peer) 4227 { 4228 } 4229 #endif 4230 /** 4231 * dp_vdev_flush_peers() - Forcibily Flush peers of vdev 4232 * @vdev_handle: Datapath VDEV handle 4233 * @unmap_only: Flag to indicate "only unmap" 4234 * @mlo_peers_only: true if only MLO peers should be flushed 4235 * 4236 * Return: void 4237 */ 4238 static void dp_vdev_flush_peers(struct cdp_vdev *vdev_handle, 4239 bool unmap_only, 4240 bool mlo_peers_only) 4241 { 4242 struct dp_vdev *vdev = (struct dp_vdev *)vdev_handle; 4243 struct dp_pdev *pdev = vdev->pdev; 4244 struct dp_soc *soc = pdev->soc; 4245 struct dp_peer *peer; 4246 uint32_t i = 0; 4247 4248 4249 if (!unmap_only) { 4250 if (!mlo_peers_only) 4251 dp_vdev_iterate_peer_lock_safe(vdev, 4252 dp_peer_delete, 4253 NULL, 4254 DP_MOD_ID_CDP); 4255 else 4256 dp_vdev_iterate_peer_lock_safe(vdev, 4257 dp_mlo_peer_delete, 4258 NULL, 4259 DP_MOD_ID_CDP); 4260 } 4261 4262 for (i = 0; i < soc->max_peer_id ; i++) { 4263 peer = __dp_peer_get_ref_by_id(soc, i, DP_MOD_ID_CDP); 4264 4265 if (!peer) 4266 continue; 4267 4268 if (peer->vdev != vdev) { 4269 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 4270 continue; 4271 } 4272 4273 if (!mlo_peers_only) { 4274 dp_info("peer: " QDF_MAC_ADDR_FMT " is getting unmap", 4275 QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 4276 dp_mlo_link_peer_flush(soc, peer); 4277 dp_rx_peer_unmap_handler(soc, i, 4278 vdev->vdev_id, 4279 peer->mac_addr.raw, 0, 4280 DP_PEER_WDS_COUNT_INVALID); 4281 SET_PEER_REF_CNT_ONE(peer); 4282 } else if (IS_MLO_DP_LINK_PEER(peer) || 4283 IS_MLO_DP_MLD_PEER(peer)) { 4284 dp_info("peer: " QDF_MAC_ADDR_FMT " is getting unmap", 4285 QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 4286 4287 /* skip deleting the SLO peers */ 4288 if (dp_mlo_get_num_link_peer(soc, peer) == 1) { 4289 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 4290 continue; 4291 } 4292 4293 dp_mlo_link_peer_flush(soc, peer); 4294 dp_rx_peer_unmap_handler(soc, i, 4295 vdev->vdev_id, 4296 peer->mac_addr.raw, 0, 4297 DP_PEER_WDS_COUNT_INVALID); 4298 SET_PEER_REF_CNT_ONE(peer); 4299 } 4300 4301 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 4302 } 4303 } 4304 4305 #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT 4306 /** 4307 * dp_txrx_alloc_vdev_stats_id()- Allocate vdev_stats_id 4308 * @soc_hdl: Datapath soc handle 4309 * @vdev_stats_id: Address of vdev_stats_id 4310 * 4311 * Return: QDF_STATUS 4312 */ 4313 static QDF_STATUS dp_txrx_alloc_vdev_stats_id(struct cdp_soc_t *soc_hdl, 4314 uint8_t *vdev_stats_id) 4315 { 4316 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 4317 uint8_t id = 0; 4318 4319 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { 4320 *vdev_stats_id = CDP_INVALID_VDEV_STATS_ID; 4321 return QDF_STATUS_E_FAILURE; 4322 } 4323 4324 while (id < CDP_MAX_VDEV_STATS_ID) { 4325 if (!qdf_atomic_test_and_set_bit(id, &soc->vdev_stats_id_map)) { 4326 *vdev_stats_id = id; 4327 return QDF_STATUS_SUCCESS; 4328 } 4329 id++; 4330 } 4331 4332 *vdev_stats_id = CDP_INVALID_VDEV_STATS_ID; 4333 return QDF_STATUS_E_FAILURE; 4334 } 4335 4336 /** 4337 * dp_txrx_reset_vdev_stats_id() - Reset vdev_stats_id in dp_soc 4338 * @soc_hdl: Datapath soc handle 4339 * @vdev_stats_id: vdev_stats_id to reset in dp_soc 4340 * 4341 * Return: none 4342 */ 4343 static void dp_txrx_reset_vdev_stats_id(struct cdp_soc_t *soc_hdl, 4344 uint8_t vdev_stats_id) 4345 { 4346 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 4347 4348 if ((!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) || 4349 (vdev_stats_id >= CDP_MAX_VDEV_STATS_ID)) 4350 return; 4351 4352 qdf_atomic_clear_bit(vdev_stats_id, &soc->vdev_stats_id_map); 4353 } 4354 #else 4355 static void dp_txrx_reset_vdev_stats_id(struct cdp_soc_t *soc, 4356 uint8_t vdev_stats_id) 4357 {} 4358 #endif 4359 /** 4360 * dp_vdev_detach_wifi3() - Detach txrx vdev 4361 * @cdp_soc: Datapath soc handle 4362 * @vdev_id: VDEV Id 4363 * @callback: Callback OL_IF on completion of detach 4364 * @cb_context: Callback context 4365 * 4366 */ 4367 static QDF_STATUS dp_vdev_detach_wifi3(struct cdp_soc_t *cdp_soc, 4368 uint8_t vdev_id, 4369 ol_txrx_vdev_delete_cb callback, 4370 void *cb_context) 4371 { 4372 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 4373 struct dp_pdev *pdev; 4374 struct dp_neighbour_peer *peer = NULL; 4375 struct dp_peer *vap_self_peer = NULL; 4376 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 4377 DP_MOD_ID_CDP); 4378 4379 if (!vdev) 4380 return QDF_STATUS_E_FAILURE; 4381 4382 soc->arch_ops.txrx_vdev_detach(soc, vdev); 4383 4384 pdev = vdev->pdev; 4385 4386 vap_self_peer = dp_sta_vdev_self_peer_ref_n_get(soc, vdev, 4387 DP_MOD_ID_CONFIG); 4388 if (vap_self_peer) { 4389 qdf_spin_lock_bh(&soc->ast_lock); 4390 if (vap_self_peer->self_ast_entry) { 4391 dp_peer_del_ast(soc, vap_self_peer->self_ast_entry); 4392 vap_self_peer->self_ast_entry = NULL; 4393 } 4394 qdf_spin_unlock_bh(&soc->ast_lock); 4395 4396 dp_peer_delete_wifi3((struct cdp_soc_t *)soc, vdev->vdev_id, 4397 vap_self_peer->mac_addr.raw, 0, 4398 CDP_LINK_PEER_TYPE); 4399 dp_peer_unref_delete(vap_self_peer, DP_MOD_ID_CONFIG); 4400 } 4401 4402 /* 4403 * If Target is hung, flush all peers before detaching vdev 4404 * this will free all references held due to missing 4405 * unmap commands from Target 4406 */ 4407 if (!hif_is_target_ready(HIF_GET_SOFTC(soc->hif_handle))) 4408 dp_vdev_flush_peers((struct cdp_vdev *)vdev, false, false); 4409 else if (hif_get_target_status(soc->hif_handle) == TARGET_STATUS_RESET) 4410 dp_vdev_flush_peers((struct cdp_vdev *)vdev, true, false); 4411 4412 /* indicate that the vdev needs to be deleted */ 4413 vdev->delete.pending = 1; 4414 dp_rx_vdev_detach(vdev); 4415 /* 4416 * move it after dp_rx_vdev_detach(), 4417 * as the call back done in dp_rx_vdev_detach() 4418 * still need to get vdev pointer by vdev_id. 4419 */ 4420 dp_vdev_id_map_tbl_remove(soc, vdev); 4421 4422 dp_monitor_neighbour_peer_list_remove(pdev, vdev, peer); 4423 4424 dp_txrx_reset_vdev_stats_id(cdp_soc, vdev->vdev_stats_id); 4425 4426 dp_tx_vdev_multipass_deinit(vdev); 4427 dp_tx_vdev_traffic_end_indication_detach(vdev); 4428 4429 if (vdev->vdev_dp_ext_handle) { 4430 qdf_mem_free(vdev->vdev_dp_ext_handle); 4431 vdev->vdev_dp_ext_handle = NULL; 4432 } 4433 vdev->delete.callback = callback; 4434 vdev->delete.context = cb_context; 4435 4436 if (vdev->opmode != wlan_op_mode_monitor) 4437 dp_vdev_pdev_list_remove(soc, pdev, vdev); 4438 4439 pdev->vdev_count--; 4440 /* release reference taken above for find */ 4441 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4442 4443 qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); 4444 TAILQ_INSERT_TAIL(&soc->inactive_vdev_list, vdev, inactive_list_elem); 4445 qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); 4446 4447 dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_DETACH, vdev); 4448 dp_info("detach vdev %pK id %d pending refs %d", 4449 vdev, vdev->vdev_id, qdf_atomic_read(&vdev->ref_cnt)); 4450 4451 /* release reference taken at dp_vdev_create */ 4452 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); 4453 4454 return QDF_STATUS_SUCCESS; 4455 } 4456 4457 #ifdef WLAN_FEATURE_11BE_MLO 4458 /** 4459 * is_dp_peer_can_reuse() - check if the dp_peer match condition to be reused 4460 * @vdev: Target DP vdev handle 4461 * @peer: DP peer handle to be checked 4462 * @peer_mac_addr: Target peer mac address 4463 * @peer_type: Target peer type 4464 * 4465 * Return: true - if match, false - not match 4466 */ 4467 static inline 4468 bool is_dp_peer_can_reuse(struct dp_vdev *vdev, 4469 struct dp_peer *peer, 4470 uint8_t *peer_mac_addr, 4471 enum cdp_peer_type peer_type) 4472 { 4473 if (peer->bss_peer && (peer->vdev == vdev) && 4474 (peer->peer_type == peer_type) && 4475 (qdf_mem_cmp(peer_mac_addr, peer->mac_addr.raw, 4476 QDF_MAC_ADDR_SIZE) == 0)) 4477 return true; 4478 4479 return false; 4480 } 4481 #else 4482 static inline 4483 bool is_dp_peer_can_reuse(struct dp_vdev *vdev, 4484 struct dp_peer *peer, 4485 uint8_t *peer_mac_addr, 4486 enum cdp_peer_type peer_type) 4487 { 4488 if (peer->bss_peer && (peer->vdev == vdev) && 4489 (qdf_mem_cmp(peer_mac_addr, peer->mac_addr.raw, 4490 QDF_MAC_ADDR_SIZE) == 0)) 4491 return true; 4492 4493 return false; 4494 } 4495 #endif 4496 4497 static inline struct dp_peer *dp_peer_can_reuse(struct dp_vdev *vdev, 4498 uint8_t *peer_mac_addr, 4499 enum cdp_peer_type peer_type) 4500 { 4501 struct dp_peer *peer; 4502 struct dp_soc *soc = vdev->pdev->soc; 4503 4504 qdf_spin_lock_bh(&soc->inactive_peer_list_lock); 4505 TAILQ_FOREACH(peer, &soc->inactive_peer_list, 4506 inactive_list_elem) { 4507 4508 /* reuse bss peer only when vdev matches*/ 4509 if (is_dp_peer_can_reuse(vdev, peer, 4510 peer_mac_addr, peer_type)) { 4511 /* increment ref count for cdp_peer_create*/ 4512 if (dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG) == 4513 QDF_STATUS_SUCCESS) { 4514 TAILQ_REMOVE(&soc->inactive_peer_list, peer, 4515 inactive_list_elem); 4516 qdf_spin_unlock_bh 4517 (&soc->inactive_peer_list_lock); 4518 return peer; 4519 } 4520 } 4521 } 4522 4523 qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); 4524 return NULL; 4525 } 4526 4527 #ifdef FEATURE_AST 4528 static inline void dp_peer_ast_handle_roam_del(struct dp_soc *soc, 4529 struct dp_pdev *pdev, 4530 uint8_t *peer_mac_addr) 4531 { 4532 struct dp_ast_entry *ast_entry; 4533 4534 if (soc->ast_offload_support) 4535 return; 4536 4537 qdf_spin_lock_bh(&soc->ast_lock); 4538 if (soc->ast_override_support) 4539 ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, peer_mac_addr, 4540 pdev->pdev_id); 4541 else 4542 ast_entry = dp_peer_ast_hash_find_soc(soc, peer_mac_addr); 4543 4544 if (ast_entry && ast_entry->next_hop && !ast_entry->delete_in_progress) 4545 dp_peer_del_ast(soc, ast_entry); 4546 4547 qdf_spin_unlock_bh(&soc->ast_lock); 4548 } 4549 #else 4550 static inline void dp_peer_ast_handle_roam_del(struct dp_soc *soc, 4551 struct dp_pdev *pdev, 4552 uint8_t *peer_mac_addr) 4553 { 4554 } 4555 #endif 4556 4557 #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT 4558 /** 4559 * dp_peer_hw_txrx_stats_init() - Initialize hw_txrx_stats_en in dp_peer 4560 * @soc: Datapath soc handle 4561 * @txrx_peer: Datapath peer handle 4562 * 4563 * Return: none 4564 */ 4565 static inline 4566 void dp_peer_hw_txrx_stats_init(struct dp_soc *soc, 4567 struct dp_txrx_peer *txrx_peer) 4568 { 4569 txrx_peer->hw_txrx_stats_en = 4570 wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx); 4571 } 4572 #else 4573 static inline 4574 void dp_peer_hw_txrx_stats_init(struct dp_soc *soc, 4575 struct dp_txrx_peer *txrx_peer) 4576 { 4577 txrx_peer->hw_txrx_stats_en = 0; 4578 } 4579 #endif 4580 4581 static QDF_STATUS dp_txrx_peer_detach(struct dp_soc *soc, struct dp_peer *peer) 4582 { 4583 struct dp_txrx_peer *txrx_peer; 4584 struct dp_pdev *pdev; 4585 struct cdp_txrx_peer_params_update params = {0}; 4586 4587 /* dp_txrx_peer exists for mld peer and legacy peer */ 4588 if (peer->txrx_peer) { 4589 txrx_peer = peer->txrx_peer; 4590 peer->txrx_peer = NULL; 4591 pdev = txrx_peer->vdev->pdev; 4592 4593 params.osif_vdev = (void *)peer->vdev->osif_vdev; 4594 params.peer_mac = peer->mac_addr.raw; 4595 4596 dp_wdi_event_handler(WDI_EVENT_PEER_DELETE, soc, 4597 (void *)¶ms, peer->peer_id, 4598 WDI_NO_VAL, pdev->pdev_id); 4599 4600 dp_peer_defrag_rx_tids_deinit(txrx_peer); 4601 /* 4602 * Deallocate the extended stats contenxt 4603 */ 4604 dp_peer_delay_stats_ctx_dealloc(soc, txrx_peer); 4605 dp_peer_rx_bufq_resources_deinit(txrx_peer); 4606 dp_peer_jitter_stats_ctx_dealloc(pdev, txrx_peer); 4607 dp_peer_sawf_stats_ctx_free(soc, txrx_peer); 4608 4609 qdf_mem_free(txrx_peer); 4610 } 4611 4612 return QDF_STATUS_SUCCESS; 4613 } 4614 4615 static inline 4616 uint8_t dp_txrx_peer_calculate_stats_size(struct dp_soc *soc, 4617 struct dp_peer *peer) 4618 { 4619 if ((wlan_cfg_is_peer_link_stats_enabled(soc->wlan_cfg_ctx)) && 4620 IS_MLO_DP_MLD_PEER(peer)) { 4621 return (DP_MAX_MLO_LINKS + 1); 4622 } 4623 return 1; 4624 } 4625 4626 static QDF_STATUS dp_txrx_peer_attach(struct dp_soc *soc, struct dp_peer *peer) 4627 { 4628 struct dp_txrx_peer *txrx_peer; 4629 struct dp_pdev *pdev; 4630 struct cdp_txrx_peer_params_update params = {0}; 4631 uint8_t stats_arr_size = 0; 4632 4633 stats_arr_size = dp_txrx_peer_calculate_stats_size(soc, peer); 4634 4635 txrx_peer = (struct dp_txrx_peer *)qdf_mem_malloc(sizeof(*txrx_peer) + 4636 (stats_arr_size * 4637 sizeof(struct dp_peer_stats))); 4638 4639 if (!txrx_peer) 4640 return QDF_STATUS_E_NOMEM; /* failure */ 4641 4642 txrx_peer->peer_id = HTT_INVALID_PEER; 4643 /* initialize the peer_id */ 4644 txrx_peer->vdev = peer->vdev; 4645 pdev = peer->vdev->pdev; 4646 txrx_peer->stats_arr_size = stats_arr_size; 4647 4648 DP_TXRX_PEER_STATS_INIT(txrx_peer, 4649 (txrx_peer->stats_arr_size * 4650 sizeof(struct dp_peer_stats))); 4651 4652 if (!IS_DP_LEGACY_PEER(peer)) 4653 txrx_peer->is_mld_peer = 1; 4654 4655 dp_wds_ext_peer_init(txrx_peer); 4656 dp_peer_rx_bufq_resources_init(txrx_peer); 4657 dp_peer_hw_txrx_stats_init(soc, txrx_peer); 4658 /* 4659 * Allocate peer extended stats context. Fall through in 4660 * case of failure as its not an implicit requirement to have 4661 * this object for regular statistics updates. 4662 */ 4663 if (dp_peer_delay_stats_ctx_alloc(soc, txrx_peer) != 4664 QDF_STATUS_SUCCESS) 4665 dp_warn("peer delay_stats ctx alloc failed"); 4666 4667 /* 4668 * Alloctate memory for jitter stats. Fall through in 4669 * case of failure as its not an implicit requirement to have 4670 * this object for regular statistics updates. 4671 */ 4672 if (dp_peer_jitter_stats_ctx_alloc(pdev, txrx_peer) != 4673 QDF_STATUS_SUCCESS) 4674 dp_warn("peer jitter_stats ctx alloc failed"); 4675 4676 dp_set_peer_isolation(txrx_peer, false); 4677 4678 dp_peer_defrag_rx_tids_init(txrx_peer); 4679 4680 if (dp_peer_sawf_stats_ctx_alloc(soc, txrx_peer) != QDF_STATUS_SUCCESS) 4681 dp_warn("peer sawf stats alloc failed"); 4682 4683 dp_txrx_peer_attach_add(soc, peer, txrx_peer); 4684 4685 params.peer_mac = peer->mac_addr.raw; 4686 params.osif_vdev = (void *)peer->vdev->osif_vdev; 4687 params.chip_id = dp_mlo_get_chip_id(soc); 4688 params.pdev_id = peer->vdev->pdev->pdev_id; 4689 4690 dp_wdi_event_handler(WDI_EVENT_TXRX_PEER_CREATE, soc, 4691 (void *)¶ms, peer->peer_id, 4692 WDI_NO_VAL, params.pdev_id); 4693 4694 return QDF_STATUS_SUCCESS; 4695 } 4696 4697 static inline 4698 void dp_txrx_peer_stats_clr(struct dp_txrx_peer *txrx_peer) 4699 { 4700 if (!txrx_peer) 4701 return; 4702 4703 txrx_peer->tx_failed = 0; 4704 txrx_peer->comp_pkt.num = 0; 4705 txrx_peer->comp_pkt.bytes = 0; 4706 txrx_peer->to_stack.num = 0; 4707 txrx_peer->to_stack.bytes = 0; 4708 4709 DP_TXRX_PEER_STATS_CLR(txrx_peer, 4710 (txrx_peer->stats_arr_size * 4711 sizeof(struct dp_peer_stats))); 4712 dp_peer_delay_stats_ctx_clr(txrx_peer); 4713 dp_peer_jitter_stats_ctx_clr(txrx_peer); 4714 } 4715 4716 /** 4717 * dp_peer_create_wifi3() - attach txrx peer 4718 * @soc_hdl: Datapath soc handle 4719 * @vdev_id: id of vdev 4720 * @peer_mac_addr: Peer MAC address 4721 * @peer_type: link or MLD peer type 4722 * 4723 * Return: 0 on success, -1 on failure 4724 */ 4725 static QDF_STATUS 4726 dp_peer_create_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 4727 uint8_t *peer_mac_addr, enum cdp_peer_type peer_type) 4728 { 4729 struct dp_peer *peer; 4730 int i; 4731 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 4732 struct dp_pdev *pdev; 4733 enum cdp_txrx_ast_entry_type ast_type = CDP_TXRX_AST_TYPE_STATIC; 4734 struct dp_vdev *vdev = NULL; 4735 4736 if (!peer_mac_addr) 4737 return QDF_STATUS_E_FAILURE; 4738 4739 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 4740 4741 if (!vdev) 4742 return QDF_STATUS_E_FAILURE; 4743 4744 pdev = vdev->pdev; 4745 soc = pdev->soc; 4746 4747 /* 4748 * If a peer entry with given MAC address already exists, 4749 * reuse the peer and reset the state of peer. 4750 */ 4751 peer = dp_peer_can_reuse(vdev, peer_mac_addr, peer_type); 4752 4753 if (peer) { 4754 qdf_atomic_init(&peer->is_default_route_set); 4755 dp_peer_cleanup(vdev, peer); 4756 4757 dp_peer_vdev_list_add(soc, vdev, peer); 4758 dp_peer_find_hash_add(soc, peer); 4759 4760 if (dp_peer_rx_tids_create(peer) != QDF_STATUS_SUCCESS) { 4761 dp_alert("RX tid alloc fail for peer %pK (" QDF_MAC_ADDR_FMT ")", 4762 peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 4763 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4764 return QDF_STATUS_E_FAILURE; 4765 } 4766 4767 if (IS_MLO_DP_MLD_PEER(peer)) 4768 dp_mld_peer_init_link_peers_info(peer); 4769 4770 qdf_spin_lock_bh(&soc->ast_lock); 4771 dp_peer_delete_ast_entries(soc, peer); 4772 qdf_spin_unlock_bh(&soc->ast_lock); 4773 4774 if ((vdev->opmode == wlan_op_mode_sta) && 4775 !qdf_mem_cmp(peer_mac_addr, &vdev->mac_addr.raw[0], 4776 QDF_MAC_ADDR_SIZE)) { 4777 ast_type = CDP_TXRX_AST_TYPE_SELF; 4778 } 4779 dp_peer_add_ast(soc, peer, peer_mac_addr, ast_type, 0); 4780 4781 peer->valid = 1; 4782 peer->is_tdls_peer = false; 4783 dp_local_peer_id_alloc(pdev, peer); 4784 4785 qdf_spinlock_create(&peer->peer_info_lock); 4786 4787 DP_STATS_INIT(peer); 4788 4789 /* 4790 * In tx_monitor mode, filter may be set for unassociated peer 4791 * when unassociated peer get associated peer need to 4792 * update tx_cap_enabled flag to support peer filter. 4793 */ 4794 if (!IS_MLO_DP_MLD_PEER(peer)) { 4795 dp_monitor_peer_tx_capture_filter_check(pdev, peer); 4796 dp_monitor_peer_reset_stats(soc, peer); 4797 } 4798 4799 if (peer->txrx_peer) { 4800 dp_peer_rx_bufq_resources_init(peer->txrx_peer); 4801 dp_txrx_peer_stats_clr(peer->txrx_peer); 4802 dp_set_peer_isolation(peer->txrx_peer, false); 4803 dp_wds_ext_peer_init(peer->txrx_peer); 4804 dp_peer_hw_txrx_stats_init(soc, peer->txrx_peer); 4805 } 4806 4807 dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_CREATE, 4808 peer, vdev, 1); 4809 dp_info("vdev %pK Reused peer %pK ("QDF_MAC_ADDR_FMT 4810 ") vdev_ref_cnt " 4811 "%d peer_ref_cnt: %d", 4812 vdev, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), 4813 qdf_atomic_read(&vdev->ref_cnt), 4814 qdf_atomic_read(&peer->ref_cnt)); 4815 dp_peer_update_state(soc, peer, DP_PEER_STATE_INIT); 4816 4817 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4818 return QDF_STATUS_SUCCESS; 4819 } else { 4820 /* 4821 * When a STA roams from RPTR AP to ROOT AP and vice versa, we 4822 * need to remove the AST entry which was earlier added as a WDS 4823 * entry. 4824 * If an AST entry exists, but no peer entry exists with a given 4825 * MAC addresses, we could deduce it as a WDS entry 4826 */ 4827 dp_peer_ast_handle_roam_del(soc, pdev, peer_mac_addr); 4828 } 4829 4830 #ifdef notyet 4831 peer = (struct dp_peer *)qdf_mempool_alloc(soc->osdev, 4832 soc->mempool_ol_ath_peer); 4833 #else 4834 peer = (struct dp_peer *)qdf_mem_malloc(sizeof(*peer)); 4835 #endif 4836 wlan_minidump_log(peer, 4837 sizeof(*peer), 4838 soc->ctrl_psoc, 4839 WLAN_MD_DP_PEER, "dp_peer"); 4840 if (!peer) { 4841 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4842 return QDF_STATUS_E_FAILURE; /* failure */ 4843 } 4844 4845 qdf_mem_zero(peer, sizeof(struct dp_peer)); 4846 4847 /* store provided params */ 4848 peer->vdev = vdev; 4849 4850 /* initialize the peer_id */ 4851 peer->peer_id = HTT_INVALID_PEER; 4852 4853 qdf_mem_copy( 4854 &peer->mac_addr.raw[0], peer_mac_addr, QDF_MAC_ADDR_SIZE); 4855 4856 DP_PEER_SET_TYPE(peer, peer_type); 4857 if (IS_MLO_DP_MLD_PEER(peer)) { 4858 if (dp_txrx_peer_attach(soc, peer) != 4859 QDF_STATUS_SUCCESS) 4860 goto fail; /* failure */ 4861 4862 dp_mld_peer_init_link_peers_info(peer); 4863 } else if (dp_monitor_peer_attach(soc, peer) != 4864 QDF_STATUS_SUCCESS) 4865 dp_warn("peer monitor ctx alloc failed"); 4866 4867 TAILQ_INIT(&peer->ast_entry_list); 4868 4869 /* get the vdev reference for new peer */ 4870 dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CHILD); 4871 4872 if ((vdev->opmode == wlan_op_mode_sta) && 4873 !qdf_mem_cmp(peer_mac_addr, &vdev->mac_addr.raw[0], 4874 QDF_MAC_ADDR_SIZE)) { 4875 ast_type = CDP_TXRX_AST_TYPE_SELF; 4876 } 4877 qdf_spinlock_create(&peer->peer_state_lock); 4878 dp_peer_add_ast(soc, peer, peer_mac_addr, ast_type, 0); 4879 qdf_spinlock_create(&peer->peer_info_lock); 4880 4881 /* reset the ast index to flowid table */ 4882 dp_peer_reset_flowq_map(peer); 4883 4884 qdf_atomic_init(&peer->ref_cnt); 4885 4886 for (i = 0; i < DP_MOD_ID_MAX; i++) 4887 qdf_atomic_init(&peer->mod_refs[i]); 4888 4889 /* keep one reference for attach */ 4890 qdf_atomic_inc(&peer->ref_cnt); 4891 qdf_atomic_inc(&peer->mod_refs[DP_MOD_ID_CONFIG]); 4892 4893 dp_peer_vdev_list_add(soc, vdev, peer); 4894 4895 /* TODO: See if hash based search is required */ 4896 dp_peer_find_hash_add(soc, peer); 4897 4898 /* Initialize the peer state */ 4899 peer->state = OL_TXRX_PEER_STATE_DISC; 4900 4901 dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_CREATE, 4902 peer, vdev, 0); 4903 dp_info("vdev %pK created peer %pK ("QDF_MAC_ADDR_FMT") vdev_ref_cnt " 4904 "%d peer_ref_cnt: %d", 4905 vdev, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), 4906 qdf_atomic_read(&vdev->ref_cnt), 4907 qdf_atomic_read(&peer->ref_cnt)); 4908 /* 4909 * For every peer MAp message search and set if bss_peer 4910 */ 4911 if (qdf_mem_cmp(peer->mac_addr.raw, vdev->mac_addr.raw, 4912 QDF_MAC_ADDR_SIZE) == 0 && 4913 (wlan_op_mode_sta != vdev->opmode)) { 4914 dp_info("vdev bss_peer!!"); 4915 peer->bss_peer = 1; 4916 if (peer->txrx_peer) 4917 peer->txrx_peer->bss_peer = 1; 4918 } 4919 4920 if (wlan_op_mode_sta == vdev->opmode && 4921 qdf_mem_cmp(peer->mac_addr.raw, vdev->mac_addr.raw, 4922 QDF_MAC_ADDR_SIZE) == 0) { 4923 peer->sta_self_peer = 1; 4924 } 4925 4926 if (dp_peer_rx_tids_create(peer) != QDF_STATUS_SUCCESS) { 4927 dp_alert("RX tid alloc fail for peer %pK (" QDF_MAC_ADDR_FMT ")", 4928 peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 4929 goto fail; 4930 } 4931 4932 peer->valid = 1; 4933 dp_local_peer_id_alloc(pdev, peer); 4934 DP_STATS_INIT(peer); 4935 4936 if (dp_peer_sawf_ctx_alloc(soc, peer) != QDF_STATUS_SUCCESS) 4937 dp_warn("peer sawf context alloc failed"); 4938 4939 dp_peer_update_state(soc, peer, DP_PEER_STATE_INIT); 4940 4941 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4942 4943 return QDF_STATUS_SUCCESS; 4944 fail: 4945 qdf_mem_free(peer); 4946 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 4947 4948 return QDF_STATUS_E_FAILURE; 4949 } 4950 4951 QDF_STATUS dp_peer_legacy_setup(struct dp_soc *soc, struct dp_peer *peer) 4952 { 4953 /* txrx_peer might exist already in peer reuse case */ 4954 if (peer->txrx_peer) 4955 return QDF_STATUS_SUCCESS; 4956 4957 if (dp_txrx_peer_attach(soc, peer) != 4958 QDF_STATUS_SUCCESS) { 4959 dp_err("peer txrx ctx alloc failed"); 4960 return QDF_STATUS_E_FAILURE; 4961 } 4962 4963 return QDF_STATUS_SUCCESS; 4964 } 4965 4966 #ifdef WLAN_FEATURE_11BE_MLO 4967 static QDF_STATUS dp_mld_peer_change_vdev(struct dp_soc *soc, 4968 struct dp_peer *mld_peer, 4969 uint8_t new_vdev_id) 4970 { 4971 struct dp_vdev *prev_vdev; 4972 4973 prev_vdev = mld_peer->vdev; 4974 /* release the ref to original dp_vdev */ 4975 dp_vdev_unref_delete(soc, mld_peer->vdev, 4976 DP_MOD_ID_CHILD); 4977 /* 4978 * get the ref to new dp_vdev, 4979 * increase dp_vdev ref_cnt 4980 */ 4981 mld_peer->vdev = dp_vdev_get_ref_by_id(soc, new_vdev_id, 4982 DP_MOD_ID_CHILD); 4983 mld_peer->txrx_peer->vdev = mld_peer->vdev; 4984 4985 dp_info("Change vdev for ML peer " QDF_MAC_ADDR_FMT 4986 " old vdev %pK id %d new vdev %pK id %d", 4987 QDF_MAC_ADDR_REF(mld_peer->mac_addr.raw), 4988 prev_vdev, prev_vdev->vdev_id, mld_peer->vdev, new_vdev_id); 4989 4990 dp_cfg_event_record_mlo_setup_vdev_update_evt( 4991 soc, mld_peer, prev_vdev, 4992 mld_peer->vdev); 4993 4994 return QDF_STATUS_SUCCESS; 4995 } 4996 4997 QDF_STATUS dp_peer_mlo_setup( 4998 struct dp_soc *soc, 4999 struct dp_peer *peer, 5000 uint8_t vdev_id, 5001 struct cdp_peer_setup_info *setup_info) 5002 { 5003 struct dp_peer *mld_peer = NULL; 5004 struct cdp_txrx_peer_params_update params = {0}; 5005 5006 /* Non-MLO connection */ 5007 if (!setup_info || !setup_info->mld_peer_mac) { 5008 /* To handle downgrade scenarios */ 5009 if (peer->vdev->opmode == wlan_op_mode_sta) { 5010 struct cdp_txrx_peer_params_update params = {0}; 5011 5012 params.chip_id = dp_mlo_get_chip_id(soc); 5013 params.pdev_id = peer->vdev->pdev->pdev_id; 5014 params.osif_vdev = peer->vdev->osif_vdev; 5015 5016 dp_wdi_event_handler( 5017 WDI_EVENT_STA_PRIMARY_UMAC_UPDATE, 5018 soc, 5019 (void *)¶ms, peer->peer_id, 5020 WDI_NO_VAL, params.pdev_id); 5021 } 5022 return QDF_STATUS_SUCCESS; 5023 } 5024 5025 dp_cfg_event_record_peer_setup_evt(soc, DP_CFG_EVENT_MLO_SETUP, 5026 peer, NULL, vdev_id, setup_info); 5027 dp_info("link peer: " QDF_MAC_ADDR_FMT "mld peer: " QDF_MAC_ADDR_FMT 5028 "first_link %d, primary_link %d", 5029 QDF_MAC_ADDR_REF(peer->mac_addr.raw), 5030 QDF_MAC_ADDR_REF(setup_info->mld_peer_mac), 5031 setup_info->is_first_link, 5032 setup_info->is_primary_link); 5033 5034 /* if this is the first link peer */ 5035 if (setup_info->is_first_link) 5036 /* create MLD peer */ 5037 dp_peer_create_wifi3((struct cdp_soc_t *)soc, 5038 vdev_id, 5039 setup_info->mld_peer_mac, 5040 CDP_MLD_PEER_TYPE); 5041 5042 if (peer->vdev->opmode == wlan_op_mode_sta && 5043 setup_info->is_primary_link) { 5044 struct cdp_txrx_peer_params_update params = {0}; 5045 5046 params.chip_id = dp_mlo_get_chip_id(soc); 5047 params.pdev_id = peer->vdev->pdev->pdev_id; 5048 params.osif_vdev = peer->vdev->osif_vdev; 5049 5050 dp_wdi_event_handler( 5051 WDI_EVENT_STA_PRIMARY_UMAC_UPDATE, 5052 soc, 5053 (void *)¶ms, peer->peer_id, 5054 WDI_NO_VAL, params.pdev_id); 5055 } 5056 5057 peer->first_link = setup_info->is_first_link; 5058 peer->primary_link = setup_info->is_primary_link; 5059 mld_peer = dp_mld_peer_find_hash_find(soc, 5060 setup_info->mld_peer_mac, 5061 0, vdev_id, DP_MOD_ID_CDP); 5062 if (mld_peer) { 5063 if (setup_info->is_first_link) { 5064 /* assign rx_tid to mld peer */ 5065 mld_peer->rx_tid = peer->rx_tid; 5066 /* no cdp_peer_setup for MLD peer, 5067 * set it for addba processing 5068 */ 5069 qdf_atomic_set(&mld_peer->is_default_route_set, 1); 5070 } else { 5071 /* free link peer original rx_tids mem */ 5072 dp_peer_rx_tids_destroy(peer); 5073 /* assign mld peer rx_tid to link peer */ 5074 peer->rx_tid = mld_peer->rx_tid; 5075 } 5076 5077 if (setup_info->is_primary_link && 5078 !setup_info->is_first_link) { 5079 /* 5080 * if first link is not the primary link, 5081 * then need to change mld_peer->vdev as 5082 * primary link dp_vdev is not same one 5083 * during mld peer creation. 5084 */ 5085 dp_info("Primary link is not the first link. vdev: %pK " 5086 "vdev_id %d vdev_ref_cnt %d", 5087 mld_peer->vdev, vdev_id, 5088 qdf_atomic_read(&mld_peer->vdev->ref_cnt)); 5089 5090 dp_mld_peer_change_vdev(soc, mld_peer, vdev_id); 5091 5092 params.osif_vdev = (void *)peer->vdev->osif_vdev; 5093 params.peer_mac = mld_peer->mac_addr.raw; 5094 params.chip_id = dp_mlo_get_chip_id(soc); 5095 params.pdev_id = peer->vdev->pdev->pdev_id; 5096 5097 dp_wdi_event_handler( 5098 WDI_EVENT_PEER_PRIMARY_UMAC_UPDATE, 5099 soc, (void *)¶ms, peer->peer_id, 5100 WDI_NO_VAL, params.pdev_id); 5101 } 5102 5103 /* associate mld and link peer */ 5104 dp_link_peer_add_mld_peer(peer, mld_peer); 5105 dp_mld_peer_add_link_peer(mld_peer, peer); 5106 5107 mld_peer->txrx_peer->is_mld_peer = 1; 5108 dp_peer_unref_delete(mld_peer, DP_MOD_ID_CDP); 5109 } else { 5110 peer->mld_peer = NULL; 5111 dp_err("mld peer" QDF_MAC_ADDR_FMT "not found!", 5112 QDF_MAC_ADDR_REF(setup_info->mld_peer_mac)); 5113 return QDF_STATUS_E_FAILURE; 5114 } 5115 5116 return QDF_STATUS_SUCCESS; 5117 } 5118 5119 /** 5120 * dp_mlo_peer_authorize() - authorize MLO peer 5121 * @soc: soc handle 5122 * @peer: pointer to link peer 5123 * 5124 * Return: void 5125 */ 5126 static void dp_mlo_peer_authorize(struct dp_soc *soc, 5127 struct dp_peer *peer) 5128 { 5129 int i; 5130 struct dp_peer *link_peer = NULL; 5131 struct dp_peer *mld_peer = peer->mld_peer; 5132 struct dp_mld_link_peers link_peers_info; 5133 5134 if (!mld_peer) 5135 return; 5136 5137 /* get link peers with reference */ 5138 dp_get_link_peers_ref_from_mld_peer(soc, mld_peer, 5139 &link_peers_info, 5140 DP_MOD_ID_CDP); 5141 5142 for (i = 0; i < link_peers_info.num_links; i++) { 5143 link_peer = link_peers_info.link_peers[i]; 5144 5145 if (!link_peer->authorize) { 5146 dp_release_link_peers_ref(&link_peers_info, 5147 DP_MOD_ID_CDP); 5148 mld_peer->authorize = false; 5149 return; 5150 } 5151 } 5152 5153 /* if we are here all link peers are authorized, 5154 * authorize ml_peer also 5155 */ 5156 mld_peer->authorize = true; 5157 5158 /* release link peers reference */ 5159 dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); 5160 } 5161 #endif 5162 5163 /** 5164 * dp_peer_setup_wifi3_wrapper() - initialize the peer 5165 * @soc_hdl: soc handle object 5166 * @vdev_id : vdev_id of vdev object 5167 * @peer_mac: Peer's mac address 5168 * @setup_info: peer setup info for MLO 5169 * 5170 * Return: QDF_STATUS 5171 */ 5172 static QDF_STATUS 5173 dp_peer_setup_wifi3_wrapper(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5174 uint8_t *peer_mac, 5175 struct cdp_peer_setup_info *setup_info) 5176 { 5177 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 5178 5179 return soc->arch_ops.txrx_peer_setup(soc_hdl, vdev_id, 5180 peer_mac, setup_info); 5181 } 5182 5183 /** 5184 * dp_cp_peer_del_resp_handler() - Handle the peer delete response 5185 * @soc_hdl: Datapath SOC handle 5186 * @vdev_id: id of virtual device object 5187 * @mac_addr: Mac address of the peer 5188 * 5189 * Return: QDF_STATUS 5190 */ 5191 static QDF_STATUS dp_cp_peer_del_resp_handler(struct cdp_soc_t *soc_hdl, 5192 uint8_t vdev_id, 5193 uint8_t *mac_addr) 5194 { 5195 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 5196 struct dp_ast_entry *ast_entry = NULL; 5197 txrx_ast_free_cb cb = NULL; 5198 void *cookie; 5199 5200 if (soc->ast_offload_support) 5201 return QDF_STATUS_E_INVAL; 5202 5203 qdf_spin_lock_bh(&soc->ast_lock); 5204 5205 ast_entry = 5206 dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, 5207 vdev_id); 5208 5209 /* in case of qwrap we have multiple BSS peers 5210 * with same mac address 5211 * 5212 * AST entry for this mac address will be created 5213 * only for one peer hence it will be NULL here 5214 */ 5215 if ((!ast_entry || !ast_entry->delete_in_progress) || 5216 (ast_entry->peer_id != HTT_INVALID_PEER)) { 5217 qdf_spin_unlock_bh(&soc->ast_lock); 5218 return QDF_STATUS_E_FAILURE; 5219 } 5220 5221 if (ast_entry->is_mapped) 5222 soc->ast_table[ast_entry->ast_idx] = NULL; 5223 5224 DP_STATS_INC(soc, ast.deleted, 1); 5225 dp_peer_ast_hash_remove(soc, ast_entry); 5226 5227 cb = ast_entry->callback; 5228 cookie = ast_entry->cookie; 5229 ast_entry->callback = NULL; 5230 ast_entry->cookie = NULL; 5231 5232 soc->num_ast_entries--; 5233 qdf_spin_unlock_bh(&soc->ast_lock); 5234 5235 if (cb) { 5236 cb(soc->ctrl_psoc, 5237 dp_soc_to_cdp_soc(soc), 5238 cookie, 5239 CDP_TXRX_AST_DELETED); 5240 } 5241 qdf_mem_free(ast_entry); 5242 5243 return QDF_STATUS_SUCCESS; 5244 } 5245 5246 #ifdef WLAN_SUPPORT_MSCS 5247 /** 5248 * dp_record_mscs_params() - Record MSCS parameters sent by the STA in 5249 * the MSCS Request to the AP. 5250 * @soc_hdl: Datapath soc handle 5251 * @peer_mac: STA Mac address 5252 * @vdev_id: ID of the vdev handle 5253 * @mscs_params: Structure having MSCS parameters obtained 5254 * from handshake 5255 * @active: Flag to set MSCS active/inactive 5256 * 5257 * The AP makes a note of these parameters while comparing the MSDUs 5258 * sent by the STA, to send the downlink traffic with correct User 5259 * priority. 5260 * 5261 * Return: QDF_STATUS - Success/Invalid 5262 */ 5263 static QDF_STATUS 5264 dp_record_mscs_params(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, 5265 uint8_t vdev_id, struct cdp_mscs_params *mscs_params, 5266 bool active) 5267 { 5268 struct dp_peer *peer; 5269 struct dp_peer *tgt_peer; 5270 QDF_STATUS status = QDF_STATUS_E_INVAL; 5271 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 5272 5273 peer = dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, 5274 DP_MOD_ID_CDP); 5275 5276 if (!peer) { 5277 dp_err("Peer is NULL!"); 5278 goto fail; 5279 } 5280 5281 tgt_peer = dp_get_tgt_peer_from_peer(peer); 5282 if (!tgt_peer) 5283 goto fail; 5284 5285 if (!active) { 5286 dp_info("MSCS Procedure is terminated"); 5287 tgt_peer->mscs_active = active; 5288 goto fail; 5289 } 5290 5291 if (mscs_params->classifier_type == IEEE80211_TCLAS_MASK_CLA_TYPE_4) { 5292 /* Populate entries inside IPV4 database first */ 5293 tgt_peer->mscs_ipv4_parameter.user_priority_bitmap = 5294 mscs_params->user_pri_bitmap; 5295 tgt_peer->mscs_ipv4_parameter.user_priority_limit = 5296 mscs_params->user_pri_limit; 5297 tgt_peer->mscs_ipv4_parameter.classifier_mask = 5298 mscs_params->classifier_mask; 5299 5300 /* Populate entries inside IPV6 database */ 5301 tgt_peer->mscs_ipv6_parameter.user_priority_bitmap = 5302 mscs_params->user_pri_bitmap; 5303 tgt_peer->mscs_ipv6_parameter.user_priority_limit = 5304 mscs_params->user_pri_limit; 5305 tgt_peer->mscs_ipv6_parameter.classifier_mask = 5306 mscs_params->classifier_mask; 5307 tgt_peer->mscs_active = 1; 5308 dp_info("\n\tMSCS Procedure request based parameters for "QDF_MAC_ADDR_FMT"\n" 5309 "\tClassifier_type = %d\tUser priority bitmap = %x\n" 5310 "\tUser priority limit = %x\tClassifier mask = %x", 5311 QDF_MAC_ADDR_REF(peer_mac), 5312 mscs_params->classifier_type, 5313 tgt_peer->mscs_ipv4_parameter.user_priority_bitmap, 5314 tgt_peer->mscs_ipv4_parameter.user_priority_limit, 5315 tgt_peer->mscs_ipv4_parameter.classifier_mask); 5316 } 5317 5318 status = QDF_STATUS_SUCCESS; 5319 fail: 5320 if (peer) 5321 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5322 return status; 5323 } 5324 #endif 5325 5326 /** 5327 * dp_get_sec_type() - Get the security type 5328 * @soc: soc handle 5329 * @vdev_id: id of dp handle 5330 * @peer_mac: mac of datapath PEER handle 5331 * @sec_idx: Security id (mcast, ucast) 5332 * 5333 * return sec_type: Security type 5334 */ 5335 static int dp_get_sec_type(struct cdp_soc_t *soc, uint8_t vdev_id, 5336 uint8_t *peer_mac, uint8_t sec_idx) 5337 { 5338 int sec_type = 0; 5339 struct dp_peer *peer = 5340 dp_peer_get_tgt_peer_hash_find((struct dp_soc *)soc, 5341 peer_mac, 0, vdev_id, 5342 DP_MOD_ID_CDP); 5343 5344 if (!peer) { 5345 dp_cdp_err("%pK: Peer is NULL!", (struct dp_soc *)soc); 5346 return sec_type; 5347 } 5348 5349 if (!peer->txrx_peer) { 5350 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5351 dp_peer_debug("%pK: txrx peer is NULL!", soc); 5352 return sec_type; 5353 } 5354 sec_type = peer->txrx_peer->security[sec_idx].sec_type; 5355 5356 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5357 return sec_type; 5358 } 5359 5360 /** 5361 * dp_peer_authorize() - authorize txrx peer 5362 * @soc_hdl: soc handle 5363 * @vdev_id: id of dp handle 5364 * @peer_mac: mac of datapath PEER handle 5365 * @authorize: 5366 * 5367 * Return: QDF_STATUS 5368 * 5369 */ 5370 static QDF_STATUS 5371 dp_peer_authorize(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5372 uint8_t *peer_mac, uint32_t authorize) 5373 { 5374 QDF_STATUS status = QDF_STATUS_SUCCESS; 5375 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 5376 struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 5377 0, vdev_id, 5378 DP_MOD_ID_CDP); 5379 5380 if (!peer) { 5381 dp_cdp_debug("%pK: Peer is NULL!", soc); 5382 status = QDF_STATUS_E_FAILURE; 5383 } else { 5384 peer->authorize = authorize ? 1 : 0; 5385 if (peer->txrx_peer) 5386 peer->txrx_peer->authorize = peer->authorize; 5387 5388 if (!peer->authorize) 5389 dp_peer_flush_frags(soc_hdl, vdev_id, peer_mac); 5390 5391 dp_mlo_peer_authorize(soc, peer); 5392 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5393 } 5394 5395 return status; 5396 } 5397 5398 /** 5399 * dp_peer_get_authorize() - get peer authorize status 5400 * @soc_hdl: soc handle 5401 * @vdev_id: id of dp handle 5402 * @peer_mac: mac of datapath PEER handle 5403 * 5404 * Return: true is peer is authorized, false otherwise 5405 */ 5406 static bool 5407 dp_peer_get_authorize(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5408 uint8_t *peer_mac) 5409 { 5410 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 5411 bool authorize = false; 5412 struct dp_peer *peer = dp_peer_find_hash_find(soc, peer_mac, 5413 0, vdev_id, 5414 DP_MOD_ID_CDP); 5415 5416 if (!peer) { 5417 dp_cdp_debug("%pK: Peer is NULL!", soc); 5418 return authorize; 5419 } 5420 5421 authorize = peer->authorize; 5422 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5423 5424 return authorize; 5425 } 5426 5427 void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev, 5428 enum dp_mod_id mod_id) 5429 { 5430 ol_txrx_vdev_delete_cb vdev_delete_cb = NULL; 5431 void *vdev_delete_context = NULL; 5432 uint8_t vdev_id = vdev->vdev_id; 5433 struct dp_pdev *pdev = vdev->pdev; 5434 struct dp_vdev *tmp_vdev = NULL; 5435 uint8_t found = 0; 5436 5437 QDF_ASSERT(qdf_atomic_dec_return(&vdev->mod_refs[mod_id]) >= 0); 5438 5439 /* Return if this is not the last reference*/ 5440 if (!qdf_atomic_dec_and_test(&vdev->ref_cnt)) 5441 return; 5442 5443 /* 5444 * This should be set as last reference need to released 5445 * after cdp_vdev_detach() is called 5446 * 5447 * if this assert is hit there is a ref count issue 5448 */ 5449 QDF_ASSERT(vdev->delete.pending); 5450 5451 vdev_delete_cb = vdev->delete.callback; 5452 vdev_delete_context = vdev->delete.context; 5453 5454 dp_info("deleting vdev object %pK ("QDF_MAC_ADDR_FMT")- its last peer is done", 5455 vdev, QDF_MAC_ADDR_REF(vdev->mac_addr.raw)); 5456 5457 if (wlan_op_mode_monitor == vdev->opmode) { 5458 dp_monitor_vdev_delete(soc, vdev); 5459 goto free_vdev; 5460 } 5461 5462 /* all peers are gone, go ahead and delete it */ 5463 dp_tx_flow_pool_unmap_handler(pdev, vdev_id, 5464 FLOW_TYPE_VDEV, vdev_id); 5465 dp_tx_vdev_detach(vdev); 5466 dp_monitor_vdev_detach(vdev); 5467 5468 free_vdev: 5469 qdf_spinlock_destroy(&vdev->peer_list_lock); 5470 5471 qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); 5472 TAILQ_FOREACH(tmp_vdev, &soc->inactive_vdev_list, 5473 inactive_list_elem) { 5474 if (tmp_vdev == vdev) { 5475 found = 1; 5476 break; 5477 } 5478 } 5479 if (found) 5480 TAILQ_REMOVE(&soc->inactive_vdev_list, vdev, 5481 inactive_list_elem); 5482 /* delete this peer from the list */ 5483 qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); 5484 5485 dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_UNREF_DEL, 5486 vdev); 5487 dp_info("deleting vdev object %pK ("QDF_MAC_ADDR_FMT")", 5488 vdev, QDF_MAC_ADDR_REF(vdev->mac_addr.raw)); 5489 wlan_minidump_remove(vdev, sizeof(*vdev), soc->ctrl_psoc, 5490 WLAN_MD_DP_VDEV, "dp_vdev"); 5491 qdf_mem_free(vdev); 5492 vdev = NULL; 5493 5494 if (vdev_delete_cb) 5495 vdev_delete_cb(vdev_delete_context); 5496 } 5497 5498 qdf_export_symbol(dp_vdev_unref_delete); 5499 5500 void dp_peer_unref_delete(struct dp_peer *peer, enum dp_mod_id mod_id) 5501 { 5502 struct dp_vdev *vdev = peer->vdev; 5503 struct dp_pdev *pdev = vdev->pdev; 5504 struct dp_soc *soc = pdev->soc; 5505 uint16_t peer_id; 5506 struct dp_peer *tmp_peer; 5507 bool found = false; 5508 5509 if (mod_id > DP_MOD_ID_RX) 5510 QDF_ASSERT(qdf_atomic_dec_return(&peer->mod_refs[mod_id]) >= 0); 5511 5512 /* 5513 * Hold the lock all the way from checking if the peer ref count 5514 * is zero until the peer references are removed from the hash 5515 * table and vdev list (if the peer ref count is zero). 5516 * This protects against a new HL tx operation starting to use the 5517 * peer object just after this function concludes it's done being used. 5518 * Furthermore, the lock needs to be held while checking whether the 5519 * vdev's list of peers is empty, to make sure that list is not modified 5520 * concurrently with the empty check. 5521 */ 5522 if (qdf_atomic_dec_and_test(&peer->ref_cnt)) { 5523 peer_id = peer->peer_id; 5524 5525 /* 5526 * Make sure that the reference to the peer in 5527 * peer object map is removed 5528 */ 5529 QDF_ASSERT(peer_id == HTT_INVALID_PEER); 5530 5531 dp_peer_info("Deleting peer %pK ("QDF_MAC_ADDR_FMT")", peer, 5532 QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 5533 5534 dp_peer_sawf_ctx_free(soc, peer); 5535 5536 wlan_minidump_remove(peer, sizeof(*peer), soc->ctrl_psoc, 5537 WLAN_MD_DP_PEER, "dp_peer"); 5538 5539 qdf_spin_lock_bh(&soc->inactive_peer_list_lock); 5540 TAILQ_FOREACH(tmp_peer, &soc->inactive_peer_list, 5541 inactive_list_elem) { 5542 if (tmp_peer == peer) { 5543 found = 1; 5544 break; 5545 } 5546 } 5547 if (found) 5548 TAILQ_REMOVE(&soc->inactive_peer_list, peer, 5549 inactive_list_elem); 5550 /* delete this peer from the list */ 5551 qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); 5552 DP_AST_ASSERT(TAILQ_EMPTY(&peer->ast_entry_list)); 5553 dp_peer_update_state(soc, peer, DP_PEER_STATE_FREED); 5554 5555 /* cleanup the peer data */ 5556 dp_peer_cleanup(vdev, peer); 5557 5558 if (!IS_MLO_DP_MLD_PEER(peer)) 5559 dp_monitor_peer_detach(soc, peer); 5560 5561 qdf_spinlock_destroy(&peer->peer_state_lock); 5562 5563 dp_txrx_peer_detach(soc, peer); 5564 dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_UNREF_DEL, 5565 peer, vdev, 0); 5566 qdf_mem_free(peer); 5567 5568 /* 5569 * Decrement ref count taken at peer create 5570 */ 5571 dp_peer_info("Deleted peer. Unref vdev %pK, vdev_ref_cnt %d", 5572 vdev, qdf_atomic_read(&vdev->ref_cnt)); 5573 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CHILD); 5574 } 5575 } 5576 5577 qdf_export_symbol(dp_peer_unref_delete); 5578 5579 void dp_txrx_peer_unref_delete(dp_txrx_ref_handle handle, 5580 enum dp_mod_id mod_id) 5581 { 5582 dp_peer_unref_delete((struct dp_peer *)handle, mod_id); 5583 } 5584 5585 qdf_export_symbol(dp_txrx_peer_unref_delete); 5586 5587 /** 5588 * dp_peer_delete_wifi3() - Delete txrx peer 5589 * @soc_hdl: soc handle 5590 * @vdev_id: id of dp handle 5591 * @peer_mac: mac of datapath PEER handle 5592 * @bitmap: bitmap indicating special handling of request. 5593 * @peer_type: peer type (link or MLD) 5594 * 5595 */ 5596 static QDF_STATUS dp_peer_delete_wifi3(struct cdp_soc_t *soc_hdl, 5597 uint8_t vdev_id, 5598 uint8_t *peer_mac, uint32_t bitmap, 5599 enum cdp_peer_type peer_type) 5600 { 5601 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5602 struct dp_peer *peer; 5603 struct cdp_peer_info peer_info = { 0 }; 5604 struct dp_vdev *vdev = NULL; 5605 5606 DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, 5607 false, peer_type); 5608 peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CDP); 5609 5610 /* Peer can be null for monitor vap mac address */ 5611 if (!peer) { 5612 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 5613 "%s: Invalid peer\n", __func__); 5614 return QDF_STATUS_E_FAILURE; 5615 } 5616 5617 if (!peer->valid) { 5618 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5619 dp_err("Invalid peer: "QDF_MAC_ADDR_FMT, 5620 QDF_MAC_ADDR_REF(peer_mac)); 5621 return QDF_STATUS_E_ALREADY; 5622 } 5623 5624 vdev = peer->vdev; 5625 5626 if (!vdev) { 5627 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5628 return QDF_STATUS_E_FAILURE; 5629 } 5630 5631 peer->valid = 0; 5632 5633 dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_DELETE, peer, 5634 vdev, 0); 5635 dp_init_info("%pK: peer %pK (" QDF_MAC_ADDR_FMT ") pending-refs %d", 5636 soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), 5637 qdf_atomic_read(&peer->ref_cnt)); 5638 5639 dp_peer_rx_reo_shared_qaddr_delete(soc, peer); 5640 5641 dp_local_peer_id_free(peer->vdev->pdev, peer); 5642 5643 /* Drop all rx packets before deleting peer */ 5644 dp_clear_peer_internal(soc, peer); 5645 5646 qdf_spinlock_destroy(&peer->peer_info_lock); 5647 dp_peer_multipass_list_remove(peer); 5648 5649 /* remove the reference to the peer from the hash table */ 5650 dp_peer_find_hash_remove(soc, peer); 5651 5652 dp_peer_vdev_list_remove(soc, vdev, peer); 5653 5654 dp_peer_mlo_delete(peer); 5655 5656 qdf_spin_lock_bh(&soc->inactive_peer_list_lock); 5657 TAILQ_INSERT_TAIL(&soc->inactive_peer_list, peer, 5658 inactive_list_elem); 5659 qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); 5660 5661 /* 5662 * Remove the reference added during peer_attach. 5663 * The peer will still be left allocated until the 5664 * PEER_UNMAP message arrives to remove the other 5665 * reference, added by the PEER_MAP message. 5666 */ 5667 dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); 5668 /* 5669 * Remove the reference taken above 5670 */ 5671 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5672 5673 return QDF_STATUS_SUCCESS; 5674 } 5675 5676 #ifdef DP_RX_UDP_OVER_PEER_ROAM 5677 static QDF_STATUS dp_update_roaming_peer_wifi3(struct cdp_soc_t *soc_hdl, 5678 uint8_t vdev_id, 5679 uint8_t *peer_mac, 5680 uint32_t auth_status) 5681 { 5682 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5683 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 5684 DP_MOD_ID_CDP); 5685 if (!vdev) 5686 return QDF_STATUS_E_FAILURE; 5687 5688 vdev->roaming_peer_status = auth_status; 5689 qdf_mem_copy(vdev->roaming_peer_mac.raw, peer_mac, 5690 QDF_MAC_ADDR_SIZE); 5691 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5692 5693 return QDF_STATUS_SUCCESS; 5694 } 5695 #endif 5696 /** 5697 * dp_get_vdev_mac_addr_wifi3() - Detach txrx peer 5698 * @soc_hdl: Datapath soc handle 5699 * @vdev_id: virtual interface id 5700 * 5701 * Return: MAC address on success, NULL on failure. 5702 * 5703 */ 5704 static uint8_t *dp_get_vdev_mac_addr_wifi3(struct cdp_soc_t *soc_hdl, 5705 uint8_t vdev_id) 5706 { 5707 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5708 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 5709 DP_MOD_ID_CDP); 5710 uint8_t *mac = NULL; 5711 5712 if (!vdev) 5713 return NULL; 5714 5715 mac = vdev->mac_addr.raw; 5716 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5717 5718 return mac; 5719 } 5720 5721 /** 5722 * dp_vdev_set_wds() - Enable per packet stats 5723 * @soc_hdl: DP soc handle 5724 * @vdev_id: id of DP VDEV handle 5725 * @val: value 5726 * 5727 * Return: none 5728 */ 5729 static int dp_vdev_set_wds(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 5730 uint32_t val) 5731 { 5732 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5733 struct dp_vdev *vdev = 5734 dp_vdev_get_ref_by_id((struct dp_soc *)soc, vdev_id, 5735 DP_MOD_ID_CDP); 5736 5737 if (!vdev) 5738 return QDF_STATUS_E_FAILURE; 5739 5740 vdev->wds_enabled = val; 5741 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5742 5743 return QDF_STATUS_SUCCESS; 5744 } 5745 5746 static int dp_get_opmode(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) 5747 { 5748 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5749 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 5750 DP_MOD_ID_CDP); 5751 int opmode; 5752 5753 if (!vdev) { 5754 dp_err_rl("vdev for id %d is NULL", vdev_id); 5755 return -EINVAL; 5756 } 5757 opmode = vdev->opmode; 5758 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5759 5760 return opmode; 5761 } 5762 5763 /** 5764 * dp_get_os_rx_handles_from_vdev_wifi3() - Get os rx handles for a vdev 5765 * @soc_hdl: ol_txrx_soc_handle handle 5766 * @vdev_id: vdev id for which os rx handles are needed 5767 * @stack_fn_p: pointer to stack function pointer 5768 * @osif_vdev_p: pointer to ol_osif_vdev_handle 5769 * 5770 * Return: void 5771 */ 5772 static 5773 void dp_get_os_rx_handles_from_vdev_wifi3(struct cdp_soc_t *soc_hdl, 5774 uint8_t vdev_id, 5775 ol_txrx_rx_fp *stack_fn_p, 5776 ol_osif_vdev_handle *osif_vdev_p) 5777 { 5778 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5779 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 5780 DP_MOD_ID_CDP); 5781 5782 if (qdf_unlikely(!vdev)) { 5783 *stack_fn_p = NULL; 5784 *osif_vdev_p = NULL; 5785 return; 5786 } 5787 *stack_fn_p = vdev->osif_rx_stack; 5788 *osif_vdev_p = vdev->osif_vdev; 5789 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5790 } 5791 5792 /** 5793 * dp_get_ctrl_pdev_from_vdev_wifi3() - Get control pdev of vdev 5794 * @soc_hdl: datapath soc handle 5795 * @vdev_id: virtual device/interface id 5796 * 5797 * Return: Handle to control pdev 5798 */ 5799 static struct cdp_cfg *dp_get_ctrl_pdev_from_vdev_wifi3( 5800 struct cdp_soc_t *soc_hdl, 5801 uint8_t vdev_id) 5802 { 5803 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5804 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 5805 DP_MOD_ID_CDP); 5806 struct dp_pdev *pdev; 5807 5808 if (!vdev) 5809 return NULL; 5810 5811 pdev = vdev->pdev; 5812 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5813 return pdev ? (struct cdp_cfg *)pdev->wlan_cfg_ctx : NULL; 5814 } 5815 5816 int32_t dp_get_tx_pending(struct cdp_pdev *pdev_handle) 5817 { 5818 struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle; 5819 5820 return qdf_atomic_read(&pdev->num_tx_outstanding); 5821 } 5822 5823 /** 5824 * dp_get_peer_mac_from_peer_id() - get peer mac 5825 * @soc: CDP SoC handle 5826 * @peer_id: Peer ID 5827 * @peer_mac: MAC addr of PEER 5828 * 5829 * Return: QDF_STATUS 5830 */ 5831 static QDF_STATUS dp_get_peer_mac_from_peer_id(struct cdp_soc_t *soc, 5832 uint32_t peer_id, 5833 uint8_t *peer_mac) 5834 { 5835 struct dp_peer *peer; 5836 5837 if (soc && peer_mac) { 5838 peer = dp_peer_get_ref_by_id((struct dp_soc *)soc, 5839 (uint16_t)peer_id, 5840 DP_MOD_ID_CDP); 5841 if (peer) { 5842 qdf_mem_copy(peer_mac, peer->mac_addr.raw, 5843 QDF_MAC_ADDR_SIZE); 5844 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 5845 return QDF_STATUS_SUCCESS; 5846 } 5847 } 5848 5849 return QDF_STATUS_E_FAILURE; 5850 } 5851 5852 #ifdef MESH_MODE_SUPPORT 5853 static 5854 void dp_vdev_set_mesh_mode(struct cdp_vdev *vdev_hdl, uint32_t val) 5855 { 5856 struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; 5857 5858 dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); 5859 vdev->mesh_vdev = val; 5860 if (val) 5861 vdev->skip_sw_tid_classification |= 5862 DP_TX_MESH_ENABLED; 5863 else 5864 vdev->skip_sw_tid_classification &= 5865 ~DP_TX_MESH_ENABLED; 5866 } 5867 5868 /** 5869 * dp_vdev_set_mesh_rx_filter() - to set the mesh rx filter 5870 * @vdev_hdl: virtual device object 5871 * @val: value to be set 5872 * 5873 * Return: void 5874 */ 5875 static 5876 void dp_vdev_set_mesh_rx_filter(struct cdp_vdev *vdev_hdl, uint32_t val) 5877 { 5878 struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; 5879 5880 dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); 5881 vdev->mesh_rx_filter = val; 5882 } 5883 #endif 5884 5885 /** 5886 * dp_vdev_set_hlos_tid_override() - to set hlos tid override 5887 * @vdev: virtual device object 5888 * @val: value to be set 5889 * 5890 * Return: void 5891 */ 5892 static 5893 void dp_vdev_set_hlos_tid_override(struct dp_vdev *vdev, uint32_t val) 5894 { 5895 dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); 5896 if (val) 5897 vdev->skip_sw_tid_classification |= 5898 DP_TXRX_HLOS_TID_OVERRIDE_ENABLED; 5899 else 5900 vdev->skip_sw_tid_classification &= 5901 ~DP_TXRX_HLOS_TID_OVERRIDE_ENABLED; 5902 } 5903 5904 /** 5905 * dp_vdev_get_hlos_tid_override() - to get hlos tid override flag 5906 * @vdev_hdl: virtual device object 5907 * 5908 * Return: 1 if this flag is set 5909 */ 5910 static 5911 uint8_t dp_vdev_get_hlos_tid_override(struct cdp_vdev *vdev_hdl) 5912 { 5913 struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; 5914 5915 return !!(vdev->skip_sw_tid_classification & 5916 DP_TXRX_HLOS_TID_OVERRIDE_ENABLED); 5917 } 5918 5919 #ifdef VDEV_PEER_PROTOCOL_COUNT 5920 static void dp_enable_vdev_peer_protocol_count(struct cdp_soc_t *soc_hdl, 5921 int8_t vdev_id, 5922 bool enable) 5923 { 5924 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5925 struct dp_vdev *vdev; 5926 5927 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 5928 if (!vdev) 5929 return; 5930 5931 dp_info("enable %d vdev_id %d", enable, vdev_id); 5932 vdev->peer_protocol_count_track = enable; 5933 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5934 } 5935 5936 static void dp_enable_vdev_peer_protocol_drop_mask(struct cdp_soc_t *soc_hdl, 5937 int8_t vdev_id, 5938 int drop_mask) 5939 { 5940 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5941 struct dp_vdev *vdev; 5942 5943 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 5944 if (!vdev) 5945 return; 5946 5947 dp_info("drop_mask %d vdev_id %d", drop_mask, vdev_id); 5948 vdev->peer_protocol_count_dropmask = drop_mask; 5949 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5950 } 5951 5952 static int dp_is_vdev_peer_protocol_count_enabled(struct cdp_soc_t *soc_hdl, 5953 int8_t vdev_id) 5954 { 5955 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5956 struct dp_vdev *vdev; 5957 int peer_protocol_count_track; 5958 5959 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 5960 if (!vdev) 5961 return 0; 5962 5963 dp_info("enable %d vdev_id %d", vdev->peer_protocol_count_track, 5964 vdev_id); 5965 peer_protocol_count_track = 5966 vdev->peer_protocol_count_track; 5967 5968 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5969 return peer_protocol_count_track; 5970 } 5971 5972 static int dp_get_vdev_peer_protocol_drop_mask(struct cdp_soc_t *soc_hdl, 5973 int8_t vdev_id) 5974 { 5975 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 5976 struct dp_vdev *vdev; 5977 int peer_protocol_count_dropmask; 5978 5979 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 5980 if (!vdev) 5981 return 0; 5982 5983 dp_info("drop_mask %d vdev_id %d", vdev->peer_protocol_count_dropmask, 5984 vdev_id); 5985 peer_protocol_count_dropmask = 5986 vdev->peer_protocol_count_dropmask; 5987 5988 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 5989 return peer_protocol_count_dropmask; 5990 } 5991 5992 #endif 5993 5994 bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data) 5995 { 5996 uint8_t pdev_count; 5997 5998 for (pdev_count = 0; pdev_count < MAX_PDEV_CNT; pdev_count++) { 5999 if (soc->pdev_list[pdev_count] && 6000 soc->pdev_list[pdev_count] == data) 6001 return true; 6002 } 6003 return false; 6004 } 6005 6006 void dp_aggregate_vdev_stats(struct dp_vdev *vdev, 6007 struct cdp_vdev_stats *vdev_stats) 6008 { 6009 if (!vdev || !vdev->pdev) 6010 return; 6011 6012 dp_update_vdev_ingress_stats(vdev); 6013 6014 qdf_mem_copy(vdev_stats, &vdev->stats, sizeof(vdev->stats)); 6015 6016 dp_vdev_iterate_peer(vdev, dp_update_vdev_stats, vdev_stats, 6017 DP_MOD_ID_GENERIC_STATS); 6018 6019 dp_update_vdev_rate_stats(vdev_stats, &vdev->stats); 6020 6021 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 6022 dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, vdev->pdev->soc, 6023 vdev_stats, vdev->vdev_id, 6024 UPDATE_VDEV_STATS, vdev->pdev->pdev_id); 6025 #endif 6026 } 6027 6028 void dp_aggregate_pdev_stats(struct dp_pdev *pdev) 6029 { 6030 struct dp_vdev *vdev = NULL; 6031 struct dp_soc *soc; 6032 struct cdp_vdev_stats *vdev_stats = 6033 qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); 6034 6035 if (!vdev_stats) { 6036 dp_cdp_err("%pK: DP alloc failure - unable to get alloc vdev stats", 6037 pdev->soc); 6038 return; 6039 } 6040 6041 soc = pdev->soc; 6042 6043 qdf_mem_zero(&pdev->stats.tx, sizeof(pdev->stats.tx)); 6044 qdf_mem_zero(&pdev->stats.rx, sizeof(pdev->stats.rx)); 6045 qdf_mem_zero(&pdev->stats.tx_i, sizeof(pdev->stats.tx_i)); 6046 qdf_mem_zero(&pdev->stats.rx_i, sizeof(pdev->stats.rx_i)); 6047 6048 if (dp_monitor_is_enable_mcopy_mode(pdev)) 6049 dp_monitor_invalid_peer_update_pdev_stats(soc, pdev); 6050 6051 qdf_spin_lock_bh(&pdev->vdev_list_lock); 6052 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 6053 6054 dp_aggregate_vdev_stats(vdev, vdev_stats); 6055 dp_update_pdev_stats(pdev, vdev_stats); 6056 dp_update_pdev_ingress_stats(pdev, vdev); 6057 } 6058 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 6059 qdf_mem_free(vdev_stats); 6060 6061 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 6062 dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc, &pdev->stats, 6063 pdev->pdev_id, UPDATE_PDEV_STATS, pdev->pdev_id); 6064 #endif 6065 } 6066 6067 /** 6068 * dp_vdev_getstats() - get vdev packet level stats 6069 * @vdev_handle: Datapath VDEV handle 6070 * @stats: cdp network device stats structure 6071 * 6072 * Return: QDF_STATUS 6073 */ 6074 static QDF_STATUS dp_vdev_getstats(struct cdp_vdev *vdev_handle, 6075 struct cdp_dev_stats *stats) 6076 { 6077 struct dp_vdev *vdev = (struct dp_vdev *)vdev_handle; 6078 struct dp_pdev *pdev; 6079 struct dp_soc *soc; 6080 struct cdp_vdev_stats *vdev_stats; 6081 6082 if (!vdev) 6083 return QDF_STATUS_E_FAILURE; 6084 6085 pdev = vdev->pdev; 6086 if (!pdev) 6087 return QDF_STATUS_E_FAILURE; 6088 6089 soc = pdev->soc; 6090 6091 vdev_stats = qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); 6092 6093 if (!vdev_stats) { 6094 dp_err("%pK: DP alloc failure - unable to get alloc vdev stats", 6095 soc); 6096 return QDF_STATUS_E_FAILURE; 6097 } 6098 6099 dp_aggregate_vdev_stats(vdev, vdev_stats); 6100 6101 stats->tx_packets = vdev_stats->tx.comp_pkt.num; 6102 stats->tx_bytes = vdev_stats->tx.comp_pkt.bytes; 6103 6104 stats->tx_errors = vdev_stats->tx.tx_failed; 6105 stats->tx_dropped = vdev_stats->tx_i.dropped.dropped_pkt.num + 6106 vdev_stats->tx_i.sg.dropped_host.num + 6107 vdev_stats->tx_i.mcast_en.dropped_map_error + 6108 vdev_stats->tx_i.mcast_en.dropped_self_mac + 6109 vdev_stats->tx_i.mcast_en.dropped_send_fail + 6110 vdev_stats->tx.nawds_mcast_drop; 6111 6112 if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { 6113 stats->rx_packets = vdev_stats->rx.to_stack.num; 6114 stats->rx_bytes = vdev_stats->rx.to_stack.bytes; 6115 } else { 6116 stats->rx_packets = vdev_stats->rx_i.reo_rcvd_pkt.num + 6117 vdev_stats->rx_i.null_q_desc_pkt.num + 6118 vdev_stats->rx_i.routed_eapol_pkt.num; 6119 stats->rx_bytes = vdev_stats->rx_i.reo_rcvd_pkt.bytes + 6120 vdev_stats->rx_i.null_q_desc_pkt.bytes + 6121 vdev_stats->rx_i.routed_eapol_pkt.bytes; 6122 } 6123 6124 stats->rx_errors = vdev_stats->rx.err.mic_err + 6125 vdev_stats->rx.err.decrypt_err + 6126 vdev_stats->rx.err.fcserr + 6127 vdev_stats->rx.err.pn_err + 6128 vdev_stats->rx.err.oor_err + 6129 vdev_stats->rx.err.jump_2k_err + 6130 vdev_stats->rx.err.rxdma_wifi_parse_err; 6131 6132 stats->rx_dropped = vdev_stats->rx.mec_drop.num + 6133 vdev_stats->rx.multipass_rx_pkt_drop + 6134 vdev_stats->rx.peer_unauth_rx_pkt_drop + 6135 vdev_stats->rx.policy_check_drop + 6136 vdev_stats->rx.nawds_mcast_drop + 6137 vdev_stats->rx.mcast_3addr_drop + 6138 vdev_stats->rx.ppeds_drop.num; 6139 6140 qdf_mem_free(vdev_stats); 6141 6142 return QDF_STATUS_SUCCESS; 6143 } 6144 6145 /** 6146 * dp_pdev_getstats() - get pdev packet level stats 6147 * @pdev_handle: Datapath PDEV handle 6148 * @stats: cdp network device stats structure 6149 * 6150 * Return: QDF_STATUS 6151 */ 6152 static void dp_pdev_getstats(struct cdp_pdev *pdev_handle, 6153 struct cdp_dev_stats *stats) 6154 { 6155 struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle; 6156 6157 dp_aggregate_pdev_stats(pdev); 6158 6159 stats->tx_packets = pdev->stats.tx.comp_pkt.num; 6160 stats->tx_bytes = pdev->stats.tx.comp_pkt.bytes; 6161 6162 stats->tx_errors = pdev->stats.tx.tx_failed; 6163 stats->tx_dropped = pdev->stats.tx_i.dropped.dropped_pkt.num + 6164 pdev->stats.tx_i.sg.dropped_host.num + 6165 pdev->stats.tx_i.mcast_en.dropped_map_error + 6166 pdev->stats.tx_i.mcast_en.dropped_self_mac + 6167 pdev->stats.tx_i.mcast_en.dropped_send_fail + 6168 pdev->stats.tx.nawds_mcast_drop + 6169 pdev->stats.tso_stats.dropped_host.num; 6170 6171 if (!wlan_cfg_get_vdev_stats_hw_offload_config(pdev->soc->wlan_cfg_ctx)) { 6172 stats->rx_packets = pdev->stats.rx.to_stack.num; 6173 stats->rx_bytes = pdev->stats.rx.to_stack.bytes; 6174 } else { 6175 stats->rx_packets = pdev->stats.rx_i.reo_rcvd_pkt.num + 6176 pdev->stats.rx_i.null_q_desc_pkt.num + 6177 pdev->stats.rx_i.routed_eapol_pkt.num; 6178 stats->rx_bytes = pdev->stats.rx_i.reo_rcvd_pkt.bytes + 6179 pdev->stats.rx_i.null_q_desc_pkt.bytes + 6180 pdev->stats.rx_i.routed_eapol_pkt.bytes; 6181 } 6182 6183 stats->rx_errors = pdev->stats.err.ip_csum_err + 6184 pdev->stats.err.tcp_udp_csum_err + 6185 pdev->stats.rx.err.mic_err + 6186 pdev->stats.rx.err.decrypt_err + 6187 pdev->stats.rx.err.fcserr + 6188 pdev->stats.rx.err.pn_err + 6189 pdev->stats.rx.err.oor_err + 6190 pdev->stats.rx.err.jump_2k_err + 6191 pdev->stats.rx.err.rxdma_wifi_parse_err; 6192 stats->rx_dropped = pdev->stats.dropped.msdu_not_done + 6193 pdev->stats.dropped.mec + 6194 pdev->stats.dropped.mesh_filter + 6195 pdev->stats.dropped.wifi_parse + 6196 pdev->stats.dropped.mon_rx_drop + 6197 pdev->stats.dropped.mon_radiotap_update_err + 6198 pdev->stats.rx.mec_drop.num + 6199 pdev->stats.rx.ppeds_drop.num + 6200 pdev->stats.rx.multipass_rx_pkt_drop + 6201 pdev->stats.rx.peer_unauth_rx_pkt_drop + 6202 pdev->stats.rx.policy_check_drop + 6203 pdev->stats.rx.nawds_mcast_drop + 6204 pdev->stats.rx.mcast_3addr_drop; 6205 } 6206 6207 /** 6208 * dp_get_device_stats() - get interface level packet stats 6209 * @soc_hdl: soc handle 6210 * @id: vdev_id or pdev_id based on type 6211 * @stats: cdp network device stats structure 6212 * @type: device type pdev/vdev 6213 * 6214 * Return: QDF_STATUS 6215 */ 6216 static QDF_STATUS dp_get_device_stats(struct cdp_soc_t *soc_hdl, uint8_t id, 6217 struct cdp_dev_stats *stats, 6218 uint8_t type) 6219 { 6220 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 6221 QDF_STATUS status = QDF_STATUS_E_FAILURE; 6222 struct dp_vdev *vdev; 6223 6224 switch (type) { 6225 case UPDATE_VDEV_STATS: 6226 vdev = dp_vdev_get_ref_by_id(soc, id, DP_MOD_ID_CDP); 6227 6228 if (vdev) { 6229 status = dp_vdev_getstats((struct cdp_vdev *)vdev, 6230 stats); 6231 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 6232 } 6233 return status; 6234 case UPDATE_PDEV_STATS: 6235 { 6236 struct dp_pdev *pdev = 6237 dp_get_pdev_from_soc_pdev_id_wifi3( 6238 (struct dp_soc *)soc, 6239 id); 6240 if (pdev) { 6241 dp_pdev_getstats((struct cdp_pdev *)pdev, 6242 stats); 6243 return QDF_STATUS_SUCCESS; 6244 } 6245 } 6246 break; 6247 default: 6248 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 6249 "apstats cannot be updated for this input " 6250 "type %d", type); 6251 break; 6252 } 6253 6254 return QDF_STATUS_E_FAILURE; 6255 } 6256 6257 const 6258 char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type) 6259 { 6260 switch (ring_type) { 6261 case REO_DST: 6262 return "Reo_dst"; 6263 case REO_EXCEPTION: 6264 return "Reo_exception"; 6265 case REO_CMD: 6266 return "Reo_cmd"; 6267 case REO_REINJECT: 6268 return "Reo_reinject"; 6269 case REO_STATUS: 6270 return "Reo_status"; 6271 case WBM2SW_RELEASE: 6272 return "wbm2sw_release"; 6273 case TCL_DATA: 6274 return "tcl_data"; 6275 case TCL_CMD_CREDIT: 6276 return "tcl_cmd_credit"; 6277 case TCL_STATUS: 6278 return "tcl_status"; 6279 case SW2WBM_RELEASE: 6280 return "sw2wbm_release"; 6281 case RXDMA_BUF: 6282 return "Rxdma_buf"; 6283 case RXDMA_DST: 6284 return "Rxdma_dst"; 6285 case RXDMA_MONITOR_BUF: 6286 return "Rxdma_monitor_buf"; 6287 case RXDMA_MONITOR_DESC: 6288 return "Rxdma_monitor_desc"; 6289 case RXDMA_MONITOR_STATUS: 6290 return "Rxdma_monitor_status"; 6291 case RXDMA_MONITOR_DST: 6292 return "Rxdma_monitor_destination"; 6293 case WBM_IDLE_LINK: 6294 return "WBM_hw_idle_link"; 6295 case PPE2TCL: 6296 return "PPE2TCL"; 6297 case REO2PPE: 6298 return "REO2PPE"; 6299 case TX_MONITOR_DST: 6300 return "tx_monitor_destination"; 6301 case TX_MONITOR_BUF: 6302 return "tx_monitor_buf"; 6303 default: 6304 dp_err("Invalid ring type: %u", ring_type); 6305 break; 6306 } 6307 return "Invalid"; 6308 } 6309 6310 void dp_print_napi_stats(struct dp_soc *soc) 6311 { 6312 hif_print_napi_stats(soc->hif_handle); 6313 } 6314 6315 /** 6316 * dp_txrx_host_peer_stats_clr() - Reinitialize the txrx peer stats 6317 * @soc: Datapath soc 6318 * @peer: Datatpath peer 6319 * @arg: argument to iter function 6320 * 6321 * Return: QDF_STATUS 6322 */ 6323 static inline void 6324 dp_txrx_host_peer_stats_clr(struct dp_soc *soc, 6325 struct dp_peer *peer, 6326 void *arg) 6327 { 6328 struct dp_txrx_peer *txrx_peer = NULL; 6329 struct dp_peer *tgt_peer = NULL; 6330 struct cdp_interface_peer_stats peer_stats_intf = {0}; 6331 6332 peer_stats_intf.rx_avg_snr = CDP_INVALID_SNR; 6333 6334 DP_STATS_CLR(peer); 6335 /* Clear monitor peer stats */ 6336 dp_monitor_peer_reset_stats(soc, peer); 6337 6338 /* Clear MLD peer stats only when link peer is primary */ 6339 if (dp_peer_is_primary_link_peer(peer)) { 6340 tgt_peer = dp_get_tgt_peer_from_peer(peer); 6341 if (tgt_peer) { 6342 DP_STATS_CLR(tgt_peer); 6343 txrx_peer = tgt_peer->txrx_peer; 6344 dp_txrx_peer_stats_clr(txrx_peer); 6345 } 6346 } 6347 6348 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 6349 dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, peer->vdev->pdev->soc, 6350 &peer_stats_intf, peer->peer_id, 6351 UPDATE_PEER_STATS, peer->vdev->pdev->pdev_id); 6352 #endif 6353 } 6354 6355 #ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING 6356 static inline void dp_srng_clear_ring_usage_wm_stats(struct dp_soc *soc) 6357 { 6358 int ring; 6359 6360 for (ring = 0; ring < soc->num_reo_dest_rings; ring++) 6361 hal_srng_clear_ring_usage_wm_locked(soc->hal_soc, 6362 soc->reo_dest_ring[ring].hal_srng); 6363 } 6364 #else 6365 static inline void dp_srng_clear_ring_usage_wm_stats(struct dp_soc *soc) 6366 { 6367 } 6368 #endif 6369 6370 #ifdef WLAN_SUPPORT_PPEDS 6371 static void dp_clear_tx_ppeds_stats(struct dp_soc *soc) 6372 { 6373 if (soc->arch_ops.dp_ppeds_clear_stats) 6374 soc->arch_ops.dp_ppeds_clear_stats(soc); 6375 } 6376 6377 static void dp_ppeds_clear_ring_util_stats(struct dp_soc *soc) 6378 { 6379 if (soc->arch_ops.dp_txrx_ppeds_clear_rings_stats) 6380 soc->arch_ops.dp_txrx_ppeds_clear_rings_stats(soc); 6381 } 6382 #else 6383 static void dp_clear_tx_ppeds_stats(struct dp_soc *soc) 6384 { 6385 } 6386 6387 static void dp_ppeds_clear_ring_util_stats(struct dp_soc *soc) 6388 { 6389 } 6390 #endif 6391 6392 /** 6393 * dp_txrx_host_stats_clr() - Reinitialize the txrx stats 6394 * @vdev: DP_VDEV handle 6395 * @soc: DP_SOC handle 6396 * 6397 * Return: QDF_STATUS 6398 */ 6399 static inline QDF_STATUS 6400 dp_txrx_host_stats_clr(struct dp_vdev *vdev, struct dp_soc *soc) 6401 { 6402 struct dp_vdev *var_vdev = NULL; 6403 6404 if (!vdev || !vdev->pdev) 6405 return QDF_STATUS_E_FAILURE; 6406 6407 /* 6408 * if NSS offload is enabled, then send message 6409 * to NSS FW to clear the stats. Once NSS FW clears the statistics 6410 * then clear host statistics. 6411 */ 6412 if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { 6413 if (soc->cdp_soc.ol_ops->nss_stats_clr) 6414 soc->cdp_soc.ol_ops->nss_stats_clr(soc->ctrl_psoc, 6415 vdev->vdev_id); 6416 } 6417 6418 dp_vdev_stats_hw_offload_target_clear(soc, vdev->pdev->pdev_id, 6419 (1 << vdev->vdev_id)); 6420 6421 DP_STATS_CLR(vdev->pdev); 6422 DP_STATS_CLR(vdev->pdev->soc); 6423 6424 dp_clear_tx_ppeds_stats(soc); 6425 dp_ppeds_clear_ring_util_stats(soc); 6426 6427 hif_clear_napi_stats(vdev->pdev->soc->hif_handle); 6428 6429 TAILQ_FOREACH(var_vdev, &vdev->pdev->vdev_list, vdev_list_elem) { 6430 DP_STATS_CLR(var_vdev); 6431 dp_vdev_iterate_peer(var_vdev, dp_txrx_host_peer_stats_clr, 6432 NULL, DP_MOD_ID_GENERIC_STATS); 6433 } 6434 6435 dp_srng_clear_ring_usage_wm_stats(soc); 6436 6437 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 6438 dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, vdev->pdev->soc, 6439 &vdev->stats, vdev->vdev_id, 6440 UPDATE_VDEV_STATS, vdev->pdev->pdev_id); 6441 #endif 6442 return QDF_STATUS_SUCCESS; 6443 } 6444 6445 /** 6446 * dp_get_peer_calibr_stats()- Get peer calibrated stats 6447 * @peer: Datapath peer 6448 * @peer_stats: buffer for peer stats 6449 * 6450 * Return: none 6451 */ 6452 static inline 6453 void dp_get_peer_calibr_stats(struct dp_peer *peer, 6454 struct cdp_peer_stats *peer_stats) 6455 { 6456 struct dp_peer *tgt_peer; 6457 6458 tgt_peer = dp_get_tgt_peer_from_peer(peer); 6459 if (!tgt_peer) 6460 return; 6461 6462 peer_stats->tx.last_per = tgt_peer->stats.tx.last_per; 6463 peer_stats->tx.tx_bytes_success_last = 6464 tgt_peer->stats.tx.tx_bytes_success_last; 6465 peer_stats->tx.tx_data_success_last = 6466 tgt_peer->stats.tx.tx_data_success_last; 6467 peer_stats->tx.tx_byte_rate = tgt_peer->stats.tx.tx_byte_rate; 6468 peer_stats->tx.tx_data_rate = tgt_peer->stats.tx.tx_data_rate; 6469 peer_stats->tx.tx_data_ucast_last = 6470 tgt_peer->stats.tx.tx_data_ucast_last; 6471 peer_stats->tx.tx_data_ucast_rate = 6472 tgt_peer->stats.tx.tx_data_ucast_rate; 6473 peer_stats->tx.inactive_time = tgt_peer->stats.tx.inactive_time; 6474 peer_stats->rx.rx_bytes_success_last = 6475 tgt_peer->stats.rx.rx_bytes_success_last; 6476 peer_stats->rx.rx_data_success_last = 6477 tgt_peer->stats.rx.rx_data_success_last; 6478 peer_stats->rx.rx_byte_rate = tgt_peer->stats.rx.rx_byte_rate; 6479 peer_stats->rx.rx_data_rate = tgt_peer->stats.rx.rx_data_rate; 6480 } 6481 6482 /** 6483 * dp_get_peer_basic_stats()- Get peer basic stats 6484 * @peer: Datapath peer 6485 * @peer_stats: buffer for peer stats 6486 * 6487 * Return: none 6488 */ 6489 static inline 6490 void dp_get_peer_basic_stats(struct dp_peer *peer, 6491 struct cdp_peer_stats *peer_stats) 6492 { 6493 struct dp_txrx_peer *txrx_peer; 6494 6495 txrx_peer = dp_get_txrx_peer(peer); 6496 if (!txrx_peer) 6497 return; 6498 6499 peer_stats->tx.comp_pkt.num += txrx_peer->comp_pkt.num; 6500 peer_stats->tx.comp_pkt.bytes += txrx_peer->comp_pkt.bytes; 6501 peer_stats->tx.tx_failed += txrx_peer->tx_failed; 6502 peer_stats->rx.to_stack.num += txrx_peer->to_stack.num; 6503 peer_stats->rx.to_stack.bytes += txrx_peer->to_stack.bytes; 6504 } 6505 6506 #ifdef QCA_ENHANCED_STATS_SUPPORT 6507 /** 6508 * dp_get_peer_per_pkt_stats()- Get peer per pkt stats 6509 * @peer: Datapath peer 6510 * @peer_stats: buffer for peer stats 6511 * 6512 * Return: none 6513 */ 6514 static inline 6515 void dp_get_peer_per_pkt_stats(struct dp_peer *peer, 6516 struct cdp_peer_stats *peer_stats) 6517 { 6518 struct dp_txrx_peer *txrx_peer; 6519 struct dp_peer_per_pkt_stats *per_pkt_stats; 6520 uint8_t inx = 0, link_id = 0; 6521 struct dp_pdev *pdev; 6522 struct dp_soc *soc; 6523 uint8_t stats_arr_size; 6524 6525 txrx_peer = dp_get_txrx_peer(peer); 6526 pdev = peer->vdev->pdev; 6527 6528 if (!txrx_peer) 6529 return; 6530 6531 if (!IS_MLO_DP_LINK_PEER(peer)) { 6532 stats_arr_size = txrx_peer->stats_arr_size; 6533 for (inx = 0; inx < stats_arr_size; inx++) { 6534 per_pkt_stats = &txrx_peer->stats[inx].per_pkt_stats; 6535 DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); 6536 } 6537 } else { 6538 soc = pdev->soc; 6539 link_id = dp_get_peer_hw_link_id(soc, pdev); 6540 per_pkt_stats = 6541 &txrx_peer->stats[link_id].per_pkt_stats; 6542 DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); 6543 } 6544 } 6545 6546 #ifdef WLAN_FEATURE_11BE_MLO 6547 /** 6548 * dp_get_peer_extd_stats()- Get peer extd stats 6549 * @peer: Datapath peer 6550 * @peer_stats: buffer for peer stats 6551 * 6552 * Return: none 6553 */ 6554 static inline 6555 void dp_get_peer_extd_stats(struct dp_peer *peer, 6556 struct cdp_peer_stats *peer_stats) 6557 { 6558 struct dp_soc *soc = peer->vdev->pdev->soc; 6559 6560 if (IS_MLO_DP_MLD_PEER(peer)) { 6561 uint8_t i; 6562 struct dp_peer *link_peer; 6563 struct dp_soc *link_peer_soc; 6564 struct dp_mld_link_peers link_peers_info; 6565 6566 dp_get_link_peers_ref_from_mld_peer(soc, peer, 6567 &link_peers_info, 6568 DP_MOD_ID_CDP); 6569 for (i = 0; i < link_peers_info.num_links; i++) { 6570 link_peer = link_peers_info.link_peers[i]; 6571 link_peer_soc = link_peer->vdev->pdev->soc; 6572 dp_monitor_peer_get_stats(link_peer_soc, link_peer, 6573 peer_stats, 6574 UPDATE_PEER_STATS); 6575 } 6576 dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); 6577 } else { 6578 dp_monitor_peer_get_stats(soc, peer, peer_stats, 6579 UPDATE_PEER_STATS); 6580 } 6581 } 6582 #else 6583 static inline 6584 void dp_get_peer_extd_stats(struct dp_peer *peer, 6585 struct cdp_peer_stats *peer_stats) 6586 { 6587 struct dp_soc *soc = peer->vdev->pdev->soc; 6588 6589 dp_monitor_peer_get_stats(soc, peer, peer_stats, UPDATE_PEER_STATS); 6590 } 6591 #endif 6592 #else 6593 #if defined WLAN_FEATURE_11BE_MLO && defined DP_MLO_LINK_STATS_SUPPORT 6594 /** 6595 * dp_get_peer_link_id() - Get Link peer Link ID 6596 * @peer: Datapath peer 6597 * 6598 * Return: Link peer Link ID 6599 */ 6600 static inline 6601 uint8_t dp_get_peer_link_id(struct dp_peer *peer) 6602 { 6603 uint8_t link_id; 6604 6605 link_id = IS_MLO_DP_LINK_PEER(peer) ? peer->link_id + 1 : 0; 6606 if (link_id < 1 || link_id > DP_MAX_MLO_LINKS) 6607 link_id = 0; 6608 6609 return link_id; 6610 } 6611 6612 static inline 6613 void dp_get_peer_per_pkt_stats(struct dp_peer *peer, 6614 struct cdp_peer_stats *peer_stats) 6615 { 6616 uint8_t i, index; 6617 struct dp_mld_link_peers link_peers_info; 6618 struct dp_txrx_peer *txrx_peer; 6619 struct dp_peer_per_pkt_stats *per_pkt_stats; 6620 struct dp_soc *soc = peer->vdev->pdev->soc; 6621 6622 txrx_peer = dp_get_txrx_peer(peer); 6623 if (!txrx_peer) 6624 return; 6625 6626 if (IS_MLO_DP_MLD_PEER(peer)) { 6627 dp_get_link_peers_ref_from_mld_peer(soc, peer, 6628 &link_peers_info, 6629 DP_MOD_ID_GENERIC_STATS); 6630 for (i = 0; i < link_peers_info.num_links; i++) { 6631 if (i > txrx_peer->stats_arr_size) 6632 break; 6633 per_pkt_stats = &txrx_peer->stats[i].per_pkt_stats; 6634 DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); 6635 } 6636 dp_release_link_peers_ref(&link_peers_info, 6637 DP_MOD_ID_GENERIC_STATS); 6638 } else { 6639 index = dp_get_peer_link_id(peer); 6640 per_pkt_stats = &txrx_peer->stats[index].per_pkt_stats; 6641 DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); 6642 qdf_mem_copy(&peer_stats->mac_addr, 6643 &peer->mac_addr.raw[0], 6644 QDF_MAC_ADDR_SIZE); 6645 } 6646 } 6647 6648 static inline 6649 void dp_get_peer_extd_stats(struct dp_peer *peer, 6650 struct cdp_peer_stats *peer_stats) 6651 { 6652 uint8_t i, index; 6653 struct dp_mld_link_peers link_peers_info; 6654 struct dp_txrx_peer *txrx_peer; 6655 struct dp_peer_extd_stats *extd_stats; 6656 struct dp_soc *soc = peer->vdev->pdev->soc; 6657 6658 txrx_peer = dp_get_txrx_peer(peer); 6659 if (qdf_unlikely(!txrx_peer)) { 6660 dp_err_rl("txrx_peer NULL for peer MAC: " QDF_MAC_ADDR_FMT, 6661 QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 6662 return; 6663 } 6664 6665 if (IS_MLO_DP_MLD_PEER(peer)) { 6666 dp_get_link_peers_ref_from_mld_peer(soc, peer, 6667 &link_peers_info, 6668 DP_MOD_ID_GENERIC_STATS); 6669 for (i = 0; i < link_peers_info.num_links; i++) { 6670 if (i > txrx_peer->stats_arr_size) 6671 break; 6672 extd_stats = &txrx_peer->stats[i].extd_stats; 6673 /* Return aggregated stats for MLD peer */ 6674 DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); 6675 } 6676 dp_release_link_peers_ref(&link_peers_info, 6677 DP_MOD_ID_GENERIC_STATS); 6678 } else { 6679 index = dp_get_peer_link_id(peer); 6680 extd_stats = &txrx_peer->stats[index].extd_stats; 6681 DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); 6682 qdf_mem_copy(&peer_stats->mac_addr, 6683 &peer->mac_addr.raw[0], 6684 QDF_MAC_ADDR_SIZE); 6685 } 6686 } 6687 #else 6688 static inline 6689 void dp_get_peer_per_pkt_stats(struct dp_peer *peer, 6690 struct cdp_peer_stats *peer_stats) 6691 { 6692 struct dp_txrx_peer *txrx_peer; 6693 struct dp_peer_per_pkt_stats *per_pkt_stats; 6694 6695 txrx_peer = dp_get_txrx_peer(peer); 6696 if (!txrx_peer) 6697 return; 6698 6699 per_pkt_stats = &txrx_peer->stats[0].per_pkt_stats; 6700 DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); 6701 } 6702 6703 static inline 6704 void dp_get_peer_extd_stats(struct dp_peer *peer, 6705 struct cdp_peer_stats *peer_stats) 6706 { 6707 struct dp_txrx_peer *txrx_peer; 6708 struct dp_peer_extd_stats *extd_stats; 6709 6710 txrx_peer = dp_get_txrx_peer(peer); 6711 if (qdf_unlikely(!txrx_peer)) { 6712 dp_err_rl("txrx_peer NULL"); 6713 return; 6714 } 6715 6716 extd_stats = &txrx_peer->stats[0].extd_stats; 6717 DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); 6718 } 6719 #endif 6720 #endif 6721 6722 /** 6723 * dp_get_peer_tx_per()- Get peer packet error ratio 6724 * @peer_stats: buffer for peer stats 6725 * 6726 * Return: none 6727 */ 6728 static inline 6729 void dp_get_peer_tx_per(struct cdp_peer_stats *peer_stats) 6730 { 6731 if (peer_stats->tx.tx_success.num + peer_stats->tx.retries > 0) 6732 peer_stats->tx.per = qdf_do_div((peer_stats->tx.retries * 100), 6733 (peer_stats->tx.tx_success.num + 6734 peer_stats->tx.retries)); 6735 else 6736 peer_stats->tx.per = 0; 6737 } 6738 6739 void dp_get_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) 6740 { 6741 dp_get_peer_calibr_stats(peer, peer_stats); 6742 6743 dp_get_peer_basic_stats(peer, peer_stats); 6744 6745 dp_get_peer_per_pkt_stats(peer, peer_stats); 6746 6747 dp_get_peer_extd_stats(peer, peer_stats); 6748 6749 dp_get_peer_tx_per(peer_stats); 6750 } 6751 6752 /** 6753 * dp_get_host_peer_stats()- function to print peer stats 6754 * @soc: dp_soc handle 6755 * @mac_addr: mac address of the peer 6756 * 6757 * Return: QDF_STATUS 6758 */ 6759 static QDF_STATUS 6760 dp_get_host_peer_stats(struct cdp_soc_t *soc, uint8_t *mac_addr) 6761 { 6762 struct dp_peer *peer = NULL; 6763 struct cdp_peer_stats *peer_stats = NULL; 6764 struct cdp_peer_info peer_info = { 0 }; 6765 6766 if (!mac_addr) { 6767 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 6768 "%s: NULL peer mac addr\n", __func__); 6769 return QDF_STATUS_E_FAILURE; 6770 } 6771 6772 DP_PEER_INFO_PARAMS_INIT(&peer_info, DP_VDEV_ALL, mac_addr, false, 6773 CDP_WILD_PEER_TYPE); 6774 6775 peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, 6776 DP_MOD_ID_CDP); 6777 if (!peer) { 6778 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 6779 "%s: Invalid peer\n", __func__); 6780 return QDF_STATUS_E_FAILURE; 6781 } 6782 6783 peer_stats = qdf_mem_malloc(sizeof(struct cdp_peer_stats)); 6784 if (!peer_stats) { 6785 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 6786 "%s: Memory allocation failed for cdp_peer_stats\n", 6787 __func__); 6788 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 6789 return QDF_STATUS_E_NOMEM; 6790 } 6791 6792 qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); 6793 6794 dp_get_peer_stats(peer, peer_stats); 6795 dp_print_peer_stats(peer, peer_stats); 6796 6797 dp_peer_rxtid_stats(dp_get_tgt_peer_from_peer(peer), 6798 dp_rx_tid_stats_cb, NULL); 6799 6800 qdf_mem_free(peer_stats); 6801 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 6802 6803 return QDF_STATUS_SUCCESS; 6804 } 6805 6806 /** 6807 * dp_txrx_stats_help() - Helper function for Txrx_Stats 6808 * 6809 * Return: None 6810 */ 6811 static void dp_txrx_stats_help(void) 6812 { 6813 dp_info("Command: iwpriv wlan0 txrx_stats <stats_option> <mac_id>"); 6814 dp_info("stats_option:"); 6815 dp_info(" 1 -- HTT Tx Statistics"); 6816 dp_info(" 2 -- HTT Rx Statistics"); 6817 dp_info(" 3 -- HTT Tx HW Queue Statistics"); 6818 dp_info(" 4 -- HTT Tx HW Sched Statistics"); 6819 dp_info(" 5 -- HTT Error Statistics"); 6820 dp_info(" 6 -- HTT TQM Statistics"); 6821 dp_info(" 7 -- HTT TQM CMDQ Statistics"); 6822 dp_info(" 8 -- HTT TX_DE_CMN Statistics"); 6823 dp_info(" 9 -- HTT Tx Rate Statistics"); 6824 dp_info(" 10 -- HTT Rx Rate Statistics"); 6825 dp_info(" 11 -- HTT Peer Statistics"); 6826 dp_info(" 12 -- HTT Tx SelfGen Statistics"); 6827 dp_info(" 13 -- HTT Tx MU HWQ Statistics"); 6828 dp_info(" 14 -- HTT RING_IF_INFO Statistics"); 6829 dp_info(" 15 -- HTT SRNG Statistics"); 6830 dp_info(" 16 -- HTT SFM Info Statistics"); 6831 dp_info(" 17 -- HTT PDEV_TX_MU_MIMO_SCHED INFO Statistics"); 6832 dp_info(" 18 -- HTT Peer List Details"); 6833 dp_info(" 20 -- Clear Host Statistics"); 6834 dp_info(" 21 -- Host Rx Rate Statistics"); 6835 dp_info(" 22 -- Host Tx Rate Statistics"); 6836 dp_info(" 23 -- Host Tx Statistics"); 6837 dp_info(" 24 -- Host Rx Statistics"); 6838 dp_info(" 25 -- Host AST Statistics"); 6839 dp_info(" 26 -- Host SRNG PTR Statistics"); 6840 dp_info(" 27 -- Host Mon Statistics"); 6841 dp_info(" 28 -- Host REO Queue Statistics"); 6842 dp_info(" 29 -- Host Soc cfg param Statistics"); 6843 dp_info(" 30 -- Host pdev cfg param Statistics"); 6844 dp_info(" 31 -- Host NAPI stats"); 6845 dp_info(" 32 -- Host Interrupt stats"); 6846 dp_info(" 33 -- Host FISA stats"); 6847 dp_info(" 34 -- Host Register Work stats"); 6848 dp_info(" 35 -- HW REO Queue stats"); 6849 dp_info(" 36 -- Host WBM IDLE link desc ring HP/TP"); 6850 dp_info(" 37 -- Host SRNG usage watermark stats"); 6851 } 6852 6853 #ifdef DP_UMAC_HW_RESET_SUPPORT 6854 /** 6855 * dp_umac_rst_skel_enable_update() - Update skel dbg flag for umac reset 6856 * @soc: dp soc handle 6857 * @en: ebable/disable 6858 * 6859 * Return: void 6860 */ 6861 static void dp_umac_rst_skel_enable_update(struct dp_soc *soc, bool en) 6862 { 6863 soc->umac_reset_ctx.skel_enable = en; 6864 dp_cdp_debug("UMAC HW reset debug skeleton code enabled :%u", 6865 soc->umac_reset_ctx.skel_enable); 6866 } 6867 6868 /** 6869 * dp_umac_rst_skel_enable_get() - Get skel dbg flag for umac reset 6870 * @soc: dp soc handle 6871 * 6872 * Return: enable/disable flag 6873 */ 6874 static bool dp_umac_rst_skel_enable_get(struct dp_soc *soc) 6875 { 6876 return soc->umac_reset_ctx.skel_enable; 6877 } 6878 #else 6879 static void dp_umac_rst_skel_enable_update(struct dp_soc *soc, bool en) 6880 { 6881 } 6882 6883 static bool dp_umac_rst_skel_enable_get(struct dp_soc *soc) 6884 { 6885 return false; 6886 } 6887 #endif 6888 6889 #ifndef WLAN_SOFTUMAC_SUPPORT 6890 static void dp_print_reg_write_stats(struct dp_soc *soc) 6891 { 6892 hal_dump_reg_write_stats(soc->hal_soc); 6893 hal_dump_reg_write_srng_stats(soc->hal_soc); 6894 } 6895 #else 6896 static void dp_print_reg_write_stats(struct dp_soc *soc) 6897 { 6898 hif_print_reg_write_stats(soc->hif_handle); 6899 } 6900 #endif 6901 6902 /** 6903 * dp_print_host_stats()- Function to print the stats aggregated at host 6904 * @vdev: DP_VDEV handle 6905 * @req: host stats type 6906 * @soc: dp soc handler 6907 * 6908 * Return: 0 on success, print error message in case of failure 6909 */ 6910 static int 6911 dp_print_host_stats(struct dp_vdev *vdev, 6912 struct cdp_txrx_stats_req *req, 6913 struct dp_soc *soc) 6914 { 6915 struct dp_pdev *pdev = (struct dp_pdev *)vdev->pdev; 6916 enum cdp_host_txrx_stats type = 6917 dp_stats_mapping_table[req->stats][STATS_HOST]; 6918 6919 dp_aggregate_pdev_stats(pdev); 6920 6921 switch (type) { 6922 case TXRX_CLEAR_STATS: 6923 dp_txrx_host_stats_clr(vdev, soc); 6924 break; 6925 case TXRX_RX_RATE_STATS: 6926 dp_print_rx_rates(vdev); 6927 break; 6928 case TXRX_TX_RATE_STATS: 6929 dp_print_tx_rates(vdev); 6930 break; 6931 case TXRX_TX_HOST_STATS: 6932 dp_print_pdev_tx_stats(pdev); 6933 dp_print_soc_tx_stats(pdev->soc); 6934 dp_print_global_desc_count(); 6935 break; 6936 case TXRX_RX_HOST_STATS: 6937 dp_print_pdev_rx_stats(pdev); 6938 dp_print_soc_rx_stats(pdev->soc); 6939 break; 6940 case TXRX_AST_STATS: 6941 dp_print_ast_stats(pdev->soc); 6942 dp_print_mec_stats(pdev->soc); 6943 dp_print_peer_table(vdev); 6944 break; 6945 case TXRX_SRNG_PTR_STATS: 6946 dp_print_ring_stats(pdev); 6947 break; 6948 case TXRX_RX_MON_STATS: 6949 dp_monitor_print_pdev_rx_mon_stats(pdev); 6950 break; 6951 case TXRX_REO_QUEUE_STATS: 6952 dp_get_host_peer_stats((struct cdp_soc_t *)pdev->soc, 6953 req->peer_addr); 6954 break; 6955 case TXRX_SOC_CFG_PARAMS: 6956 dp_print_soc_cfg_params(pdev->soc); 6957 break; 6958 case TXRX_PDEV_CFG_PARAMS: 6959 dp_print_pdev_cfg_params(pdev); 6960 break; 6961 case TXRX_NAPI_STATS: 6962 dp_print_napi_stats(pdev->soc); 6963 break; 6964 case TXRX_SOC_INTERRUPT_STATS: 6965 dp_print_soc_interrupt_stats(pdev->soc); 6966 break; 6967 case TXRX_SOC_FSE_STATS: 6968 if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) 6969 soc->cdp_soc.ol_ops->dp_print_fisa_stats( 6970 CDP_FISA_STATS_ID_DUMP_HW_FST); 6971 break; 6972 case TXRX_HAL_REG_WRITE_STATS: 6973 dp_print_reg_write_stats(pdev->soc); 6974 break; 6975 case TXRX_SOC_REO_HW_DESC_DUMP: 6976 dp_get_rx_reo_queue_info((struct cdp_soc_t *)pdev->soc, 6977 vdev->vdev_id); 6978 break; 6979 case TXRX_SOC_WBM_IDLE_HPTP_DUMP: 6980 dp_dump_wbm_idle_hptp(pdev->soc, pdev); 6981 break; 6982 case TXRX_SRNG_USAGE_WM_STATS: 6983 /* Dump usage watermark stats for all SRNGs */ 6984 dp_dump_srng_high_wm_stats(soc, 0xFF); 6985 break; 6986 case TXRX_PEER_STATS: 6987 dp_print_per_link_stats((struct cdp_soc_t *)pdev->soc, 6988 vdev->vdev_id); 6989 break; 6990 default: 6991 dp_info("Wrong Input For TxRx Host Stats"); 6992 dp_txrx_stats_help(); 6993 break; 6994 } 6995 return 0; 6996 } 6997 6998 /** 6999 * dp_pdev_tid_stats_ingress_inc() - increment ingress_stack counter 7000 * @pdev: pdev handle 7001 * @val: increase in value 7002 * 7003 * Return: void 7004 */ 7005 static void 7006 dp_pdev_tid_stats_ingress_inc(struct dp_pdev *pdev, uint32_t val) 7007 { 7008 pdev->stats.tid_stats.ingress_stack += val; 7009 } 7010 7011 /** 7012 * dp_pdev_tid_stats_osif_drop() - increment osif_drop counter 7013 * @pdev: pdev handle 7014 * @val: increase in value 7015 * 7016 * Return: void 7017 */ 7018 static void 7019 dp_pdev_tid_stats_osif_drop(struct dp_pdev *pdev, uint32_t val) 7020 { 7021 pdev->stats.tid_stats.osif_drop += val; 7022 } 7023 7024 /** 7025 * dp_get_fw_peer_stats()- function to print peer stats 7026 * @soc: soc handle 7027 * @pdev_id: id of the pdev handle 7028 * @mac_addr: mac address of the peer 7029 * @cap: Type of htt stats requested 7030 * @is_wait: if set, wait on completion from firmware response 7031 * 7032 * Currently Supporting only MAC ID based requests Only 7033 * 1: HTT_PEER_STATS_REQ_MODE_NO_QUERY 7034 * 2: HTT_PEER_STATS_REQ_MODE_QUERY_TQM 7035 * 3: HTT_PEER_STATS_REQ_MODE_FLUSH_TQM 7036 * 7037 * Return: QDF_STATUS 7038 */ 7039 static QDF_STATUS 7040 dp_get_fw_peer_stats(struct cdp_soc_t *soc, uint8_t pdev_id, 7041 uint8_t *mac_addr, 7042 uint32_t cap, uint32_t is_wait) 7043 { 7044 int i; 7045 uint32_t config_param0 = 0; 7046 uint32_t config_param1 = 0; 7047 uint32_t config_param2 = 0; 7048 uint32_t config_param3 = 0; 7049 struct dp_pdev *pdev = 7050 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 7051 pdev_id); 7052 7053 if (!pdev) 7054 return QDF_STATUS_E_FAILURE; 7055 7056 HTT_DBG_EXT_STATS_PEER_INFO_IS_MAC_ADDR_SET(config_param0, 1); 7057 config_param0 |= (1 << (cap + 1)); 7058 7059 for (i = 0; i < HTT_PEER_STATS_MAX_TLV; i++) { 7060 config_param1 |= (1 << i); 7061 } 7062 7063 config_param2 |= (mac_addr[0] & 0x000000ff); 7064 config_param2 |= ((mac_addr[1] << 8) & 0x0000ff00); 7065 config_param2 |= ((mac_addr[2] << 16) & 0x00ff0000); 7066 config_param2 |= ((mac_addr[3] << 24) & 0xff000000); 7067 7068 config_param3 |= (mac_addr[4] & 0x000000ff); 7069 config_param3 |= ((mac_addr[5] << 8) & 0x0000ff00); 7070 7071 if (is_wait) { 7072 qdf_event_reset(&pdev->fw_peer_stats_event); 7073 dp_h2t_ext_stats_msg_send(pdev, HTT_DBG_EXT_STATS_PEER_INFO, 7074 config_param0, config_param1, 7075 config_param2, config_param3, 7076 0, DBG_STATS_COOKIE_DP_STATS, 0); 7077 qdf_wait_single_event(&pdev->fw_peer_stats_event, 7078 DP_FW_PEER_STATS_CMP_TIMEOUT_MSEC); 7079 } else { 7080 dp_h2t_ext_stats_msg_send(pdev, HTT_DBG_EXT_STATS_PEER_INFO, 7081 config_param0, config_param1, 7082 config_param2, config_param3, 7083 0, DBG_STATS_COOKIE_DEFAULT, 0); 7084 } 7085 7086 return QDF_STATUS_SUCCESS; 7087 7088 } 7089 7090 /* This struct definition will be removed from here 7091 * once it get added in FW headers*/ 7092 struct httstats_cmd_req { 7093 uint32_t config_param0; 7094 uint32_t config_param1; 7095 uint32_t config_param2; 7096 uint32_t config_param3; 7097 int cookie; 7098 u_int8_t stats_id; 7099 }; 7100 7101 /** 7102 * dp_get_htt_stats: function to process the httstas request 7103 * @soc: DP soc handle 7104 * @pdev_id: id of pdev handle 7105 * @data: pointer to request data 7106 * @data_len: length for request data 7107 * 7108 * Return: QDF_STATUS 7109 */ 7110 static QDF_STATUS 7111 dp_get_htt_stats(struct cdp_soc_t *soc, uint8_t pdev_id, void *data, 7112 uint32_t data_len) 7113 { 7114 struct httstats_cmd_req *req = (struct httstats_cmd_req *)data; 7115 struct dp_pdev *pdev = 7116 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 7117 pdev_id); 7118 7119 if (!pdev) 7120 return QDF_STATUS_E_FAILURE; 7121 7122 QDF_ASSERT(data_len == sizeof(struct httstats_cmd_req)); 7123 dp_h2t_ext_stats_msg_send(pdev, req->stats_id, 7124 req->config_param0, req->config_param1, 7125 req->config_param2, req->config_param3, 7126 req->cookie, DBG_STATS_COOKIE_DEFAULT, 0); 7127 7128 return QDF_STATUS_SUCCESS; 7129 } 7130 7131 /** 7132 * dp_set_pdev_tidmap_prty_wifi3() - update tidmap priority in pdev 7133 * @pdev: DP_PDEV handle 7134 * @prio: tidmap priority value passed by the user 7135 * 7136 * Return: QDF_STATUS_SUCCESS on success 7137 */ 7138 static QDF_STATUS dp_set_pdev_tidmap_prty_wifi3(struct dp_pdev *pdev, 7139 uint8_t prio) 7140 { 7141 struct dp_soc *soc = pdev->soc; 7142 7143 soc->tidmap_prty = prio; 7144 7145 hal_tx_set_tidmap_prty(soc->hal_soc, prio); 7146 return QDF_STATUS_SUCCESS; 7147 } 7148 7149 /** 7150 * dp_get_peer_param: function to get parameters in peer 7151 * @cdp_soc: DP soc handle 7152 * @vdev_id: id of vdev handle 7153 * @peer_mac: peer mac address 7154 * @param: parameter type to be set 7155 * @val: address of buffer 7156 * 7157 * Return: val 7158 */ 7159 static QDF_STATUS dp_get_peer_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7160 uint8_t *peer_mac, 7161 enum cdp_peer_param_type param, 7162 cdp_config_param_type *val) 7163 { 7164 return QDF_STATUS_SUCCESS; 7165 } 7166 7167 /** 7168 * dp_set_peer_param: function to set parameters in peer 7169 * @cdp_soc: DP soc handle 7170 * @vdev_id: id of vdev handle 7171 * @peer_mac: peer mac address 7172 * @param: parameter type to be set 7173 * @val: value of parameter to be set 7174 * 7175 * Return: 0 for success. nonzero for failure. 7176 */ 7177 static QDF_STATUS dp_set_peer_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7178 uint8_t *peer_mac, 7179 enum cdp_peer_param_type param, 7180 cdp_config_param_type val) 7181 { 7182 struct dp_peer *peer = 7183 dp_peer_get_tgt_peer_hash_find((struct dp_soc *)cdp_soc, 7184 peer_mac, 0, vdev_id, 7185 DP_MOD_ID_CDP); 7186 struct dp_txrx_peer *txrx_peer; 7187 7188 if (!peer) 7189 return QDF_STATUS_E_FAILURE; 7190 7191 txrx_peer = peer->txrx_peer; 7192 if (!txrx_peer) { 7193 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7194 return QDF_STATUS_E_FAILURE; 7195 } 7196 7197 switch (param) { 7198 case CDP_CONFIG_NAWDS: 7199 txrx_peer->nawds_enabled = val.cdp_peer_param_nawds; 7200 break; 7201 case CDP_CONFIG_ISOLATION: 7202 dp_info("Peer " QDF_MAC_ADDR_FMT " vdev_id %d, isolation %d", 7203 QDF_MAC_ADDR_REF(peer_mac), vdev_id, 7204 val.cdp_peer_param_isolation); 7205 dp_set_peer_isolation(txrx_peer, val.cdp_peer_param_isolation); 7206 break; 7207 case CDP_CONFIG_IN_TWT: 7208 txrx_peer->in_twt = !!(val.cdp_peer_param_in_twt); 7209 break; 7210 default: 7211 break; 7212 } 7213 7214 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7215 7216 return QDF_STATUS_SUCCESS; 7217 } 7218 7219 #ifdef WLAN_FEATURE_11BE_MLO 7220 /** 7221 * dp_set_mld_peer_param: function to set parameters in MLD peer 7222 * @cdp_soc: DP soc handle 7223 * @vdev_id: id of vdev handle 7224 * @peer_mac: peer mac address 7225 * @param: parameter type to be set 7226 * @val: value of parameter to be set 7227 * 7228 * Return: 0 for success. nonzero for failure. 7229 */ 7230 static QDF_STATUS dp_set_mld_peer_param(struct cdp_soc_t *cdp_soc, 7231 uint8_t vdev_id, 7232 uint8_t *peer_mac, 7233 enum cdp_peer_param_type param, 7234 cdp_config_param_type val) 7235 { 7236 struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); 7237 struct dp_peer *peer; 7238 struct dp_txrx_peer *txrx_peer; 7239 QDF_STATUS status = QDF_STATUS_SUCCESS; 7240 7241 peer = dp_mld_peer_find_hash_find(soc, peer_mac, 0, vdev_id, 7242 DP_MOD_ID_CDP); 7243 if (!peer) 7244 return QDF_STATUS_E_FAILURE; 7245 7246 txrx_peer = peer->txrx_peer; 7247 if (!txrx_peer) { 7248 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7249 return QDF_STATUS_E_FAILURE; 7250 } 7251 7252 switch (param) { 7253 case CDP_CONFIG_MLD_PEER_VDEV: 7254 status = dp_mld_peer_change_vdev(soc, peer, val.new_vdev_id); 7255 break; 7256 default: 7257 break; 7258 } 7259 7260 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7261 7262 return status; 7263 } 7264 7265 /** 7266 * dp_set_peer_param_wrapper: wrapper function to set parameters in 7267 * legacy/link/MLD peer 7268 * @cdp_soc: DP soc handle 7269 * @vdev_id: id of vdev handle 7270 * @peer_mac: peer mac address 7271 * @param: parameter type to be set 7272 * @val: value of parameter to be set 7273 * 7274 * Return: 0 for success. nonzero for failure. 7275 */ 7276 static QDF_STATUS 7277 dp_set_peer_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7278 uint8_t *peer_mac, enum cdp_peer_param_type param, 7279 cdp_config_param_type val) 7280 { 7281 QDF_STATUS status; 7282 7283 switch (param) { 7284 case CDP_CONFIG_MLD_PEER_VDEV: 7285 status = dp_set_mld_peer_param(cdp_soc, vdev_id, peer_mac, 7286 param, val); 7287 break; 7288 default: 7289 status = dp_set_peer_param(cdp_soc, vdev_id, peer_mac, 7290 param, val); 7291 break; 7292 } 7293 7294 return status; 7295 } 7296 #endif 7297 7298 /** 7299 * dp_get_pdev_param() - function to get parameters from pdev 7300 * @cdp_soc: DP soc handle 7301 * @pdev_id: id of pdev handle 7302 * @param: parameter type to be get 7303 * @val: buffer for value 7304 * 7305 * Return: status 7306 */ 7307 static QDF_STATUS dp_get_pdev_param(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, 7308 enum cdp_pdev_param_type param, 7309 cdp_config_param_type *val) 7310 { 7311 struct cdp_pdev *pdev = (struct cdp_pdev *) 7312 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, 7313 pdev_id); 7314 if (!pdev) 7315 return QDF_STATUS_E_FAILURE; 7316 7317 switch (param) { 7318 case CDP_CONFIG_VOW: 7319 val->cdp_pdev_param_cfg_vow = 7320 ((struct dp_pdev *)pdev)->delay_stats_flag; 7321 break; 7322 case CDP_TX_PENDING: 7323 val->cdp_pdev_param_tx_pending = dp_get_tx_pending(pdev); 7324 break; 7325 case CDP_FILTER_MCAST_DATA: 7326 val->cdp_pdev_param_fltr_mcast = 7327 dp_monitor_pdev_get_filter_mcast_data(pdev); 7328 break; 7329 case CDP_FILTER_NO_DATA: 7330 val->cdp_pdev_param_fltr_none = 7331 dp_monitor_pdev_get_filter_non_data(pdev); 7332 break; 7333 case CDP_FILTER_UCAST_DATA: 7334 val->cdp_pdev_param_fltr_ucast = 7335 dp_monitor_pdev_get_filter_ucast_data(pdev); 7336 break; 7337 case CDP_MONITOR_CHANNEL: 7338 val->cdp_pdev_param_monitor_chan = 7339 dp_monitor_get_chan_num((struct dp_pdev *)pdev); 7340 break; 7341 case CDP_MONITOR_FREQUENCY: 7342 val->cdp_pdev_param_mon_freq = 7343 dp_monitor_get_chan_freq((struct dp_pdev *)pdev); 7344 break; 7345 case CDP_CONFIG_RXDMA_BUF_RING_SIZE: 7346 val->cdp_rxdma_buf_ring_size = 7347 wlan_cfg_get_rx_dma_buf_ring_size(((struct dp_pdev *)pdev)->wlan_cfg_ctx); 7348 break; 7349 default: 7350 return QDF_STATUS_E_FAILURE; 7351 } 7352 7353 return QDF_STATUS_SUCCESS; 7354 } 7355 7356 /** 7357 * dp_set_pdev_param() - function to set parameters in pdev 7358 * @cdp_soc: DP soc handle 7359 * @pdev_id: id of pdev handle 7360 * @param: parameter type to be set 7361 * @val: value of parameter to be set 7362 * 7363 * Return: 0 for success. nonzero for failure. 7364 */ 7365 static QDF_STATUS dp_set_pdev_param(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, 7366 enum cdp_pdev_param_type param, 7367 cdp_config_param_type val) 7368 { 7369 int target_type; 7370 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 7371 struct dp_pdev *pdev = 7372 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, 7373 pdev_id); 7374 enum reg_wifi_band chan_band; 7375 7376 if (!pdev) 7377 return QDF_STATUS_E_FAILURE; 7378 7379 target_type = hal_get_target_type(soc->hal_soc); 7380 switch (target_type) { 7381 case TARGET_TYPE_QCA6750: 7382 case TARGET_TYPE_WCN6450: 7383 pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC0_LMAC_ID; 7384 pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; 7385 pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; 7386 break; 7387 case TARGET_TYPE_KIWI: 7388 case TARGET_TYPE_MANGO: 7389 case TARGET_TYPE_PEACH: 7390 pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC0_LMAC_ID; 7391 pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; 7392 pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; 7393 break; 7394 default: 7395 pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC1_LMAC_ID; 7396 pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; 7397 pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; 7398 break; 7399 } 7400 7401 switch (param) { 7402 case CDP_CONFIG_TX_CAPTURE: 7403 return dp_monitor_config_debug_sniffer(pdev, 7404 val.cdp_pdev_param_tx_capture); 7405 case CDP_CONFIG_DEBUG_SNIFFER: 7406 return dp_monitor_config_debug_sniffer(pdev, 7407 val.cdp_pdev_param_dbg_snf); 7408 case CDP_CONFIG_BPR_ENABLE: 7409 return dp_monitor_set_bpr_enable(pdev, 7410 val.cdp_pdev_param_bpr_enable); 7411 case CDP_CONFIG_PRIMARY_RADIO: 7412 pdev->is_primary = val.cdp_pdev_param_primary_radio; 7413 break; 7414 case CDP_CONFIG_CAPTURE_LATENCY: 7415 pdev->latency_capture_enable = val.cdp_pdev_param_cptr_latcy; 7416 break; 7417 case CDP_INGRESS_STATS: 7418 dp_pdev_tid_stats_ingress_inc(pdev, 7419 val.cdp_pdev_param_ingrs_stats); 7420 break; 7421 case CDP_OSIF_DROP: 7422 dp_pdev_tid_stats_osif_drop(pdev, 7423 val.cdp_pdev_param_osif_drop); 7424 break; 7425 case CDP_CONFIG_ENH_RX_CAPTURE: 7426 return dp_monitor_config_enh_rx_capture(pdev, 7427 val.cdp_pdev_param_en_rx_cap); 7428 case CDP_CONFIG_ENH_TX_CAPTURE: 7429 return dp_monitor_config_enh_tx_capture(pdev, 7430 val.cdp_pdev_param_en_tx_cap); 7431 case CDP_CONFIG_HMMC_TID_OVERRIDE: 7432 pdev->hmmc_tid_override_en = val.cdp_pdev_param_hmmc_tid_ovrd; 7433 break; 7434 case CDP_CONFIG_HMMC_TID_VALUE: 7435 pdev->hmmc_tid = val.cdp_pdev_param_hmmc_tid; 7436 break; 7437 case CDP_CHAN_NOISE_FLOOR: 7438 pdev->chan_noise_floor = val.cdp_pdev_param_chn_noise_flr; 7439 break; 7440 case CDP_TIDMAP_PRTY: 7441 dp_set_pdev_tidmap_prty_wifi3(pdev, 7442 val.cdp_pdev_param_tidmap_prty); 7443 break; 7444 case CDP_FILTER_NEIGH_PEERS: 7445 dp_monitor_set_filter_neigh_peers(pdev, 7446 val.cdp_pdev_param_fltr_neigh_peers); 7447 break; 7448 case CDP_MONITOR_CHANNEL: 7449 dp_monitor_set_chan_num(pdev, val.cdp_pdev_param_monitor_chan); 7450 break; 7451 case CDP_MONITOR_FREQUENCY: 7452 chan_band = wlan_reg_freq_to_band(val.cdp_pdev_param_mon_freq); 7453 dp_monitor_set_chan_freq(pdev, val.cdp_pdev_param_mon_freq); 7454 dp_monitor_set_chan_band(pdev, chan_band); 7455 break; 7456 case CDP_CONFIG_BSS_COLOR: 7457 dp_monitor_set_bsscolor(pdev, val.cdp_pdev_param_bss_color); 7458 break; 7459 case CDP_SET_ATF_STATS_ENABLE: 7460 dp_monitor_set_atf_stats_enable(pdev, 7461 val.cdp_pdev_param_atf_stats_enable); 7462 break; 7463 case CDP_CONFIG_SPECIAL_VAP: 7464 dp_monitor_pdev_config_scan_spcl_vap(pdev, 7465 val.cdp_pdev_param_config_special_vap); 7466 dp_monitor_vdev_set_monitor_mode_buf_rings(pdev); 7467 break; 7468 case CDP_RESET_SCAN_SPCL_VAP_STATS_ENABLE: 7469 dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(pdev, 7470 val.cdp_pdev_param_reset_scan_spcl_vap_stats_enable); 7471 break; 7472 case CDP_CONFIG_ENHANCED_STATS_ENABLE: 7473 pdev->enhanced_stats_en = val.cdp_pdev_param_enhanced_stats_enable; 7474 break; 7475 case CDP_ISOLATION: 7476 pdev->isolation = val.cdp_pdev_param_isolation; 7477 break; 7478 case CDP_CONFIG_UNDECODED_METADATA_CAPTURE_ENABLE: 7479 return dp_monitor_config_undecoded_metadata_capture(pdev, 7480 val.cdp_pdev_param_undecoded_metadata_enable); 7481 break; 7482 case CDP_CONFIG_RXDMA_BUF_RING_SIZE: 7483 wlan_cfg_set_rx_dma_buf_ring_size(pdev->wlan_cfg_ctx, 7484 val.cdp_rxdma_buf_ring_size); 7485 break; 7486 default: 7487 return QDF_STATUS_E_INVAL; 7488 } 7489 return QDF_STATUS_SUCCESS; 7490 } 7491 7492 #ifdef QCA_UNDECODED_METADATA_SUPPORT 7493 static 7494 QDF_STATUS dp_set_pdev_phyrx_error_mask(struct cdp_soc_t *cdp_soc, 7495 uint8_t pdev_id, uint32_t mask, 7496 uint32_t mask_cont) 7497 { 7498 struct dp_pdev *pdev = 7499 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, 7500 pdev_id); 7501 7502 if (!pdev) 7503 return QDF_STATUS_E_FAILURE; 7504 7505 return dp_monitor_config_undecoded_metadata_phyrx_error_mask(pdev, 7506 mask, mask_cont); 7507 } 7508 7509 static 7510 QDF_STATUS dp_get_pdev_phyrx_error_mask(struct cdp_soc_t *cdp_soc, 7511 uint8_t pdev_id, uint32_t *mask, 7512 uint32_t *mask_cont) 7513 { 7514 struct dp_pdev *pdev = 7515 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, 7516 pdev_id); 7517 7518 if (!pdev) 7519 return QDF_STATUS_E_FAILURE; 7520 7521 return dp_monitor_get_undecoded_metadata_phyrx_error_mask(pdev, 7522 mask, mask_cont); 7523 } 7524 #endif 7525 7526 #ifdef QCA_PEER_EXT_STATS 7527 static void dp_rx_update_peer_delay_stats(struct dp_soc *soc, 7528 qdf_nbuf_t nbuf) 7529 { 7530 struct dp_peer *peer = NULL; 7531 uint16_t peer_id, ring_id; 7532 uint8_t tid = qdf_nbuf_get_tid_val(nbuf); 7533 struct dp_peer_delay_stats *delay_stats = NULL; 7534 7535 peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf); 7536 if (peer_id > soc->max_peer_id) 7537 return; 7538 7539 peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_CDP); 7540 if (qdf_unlikely(!peer)) 7541 return; 7542 7543 if (qdf_unlikely(!peer->txrx_peer)) { 7544 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7545 return; 7546 } 7547 7548 if (qdf_likely(peer->txrx_peer->delay_stats)) { 7549 delay_stats = peer->txrx_peer->delay_stats; 7550 ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf); 7551 dp_rx_compute_tid_delay(&delay_stats->delay_tid_stats[tid][ring_id], 7552 nbuf); 7553 } 7554 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 7555 } 7556 #else 7557 static inline void dp_rx_update_peer_delay_stats(struct dp_soc *soc, 7558 qdf_nbuf_t nbuf) 7559 { 7560 } 7561 #endif 7562 7563 /** 7564 * dp_calculate_delay_stats() - function to get rx delay stats 7565 * @cdp_soc: DP soc handle 7566 * @vdev_id: id of DP vdev handle 7567 * @nbuf: skb 7568 * 7569 * Return: QDF_STATUS 7570 */ 7571 static QDF_STATUS 7572 dp_calculate_delay_stats(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7573 qdf_nbuf_t nbuf) 7574 { 7575 struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); 7576 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 7577 DP_MOD_ID_CDP); 7578 7579 if (!vdev) 7580 return QDF_STATUS_SUCCESS; 7581 7582 if (vdev->pdev->delay_stats_flag) 7583 dp_rx_compute_delay(vdev, nbuf); 7584 else 7585 dp_rx_update_peer_delay_stats(soc, nbuf); 7586 7587 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 7588 return QDF_STATUS_SUCCESS; 7589 } 7590 7591 /** 7592 * dp_get_vdev_param() - function to get parameters from vdev 7593 * @cdp_soc: DP soc handle 7594 * @vdev_id: id of DP vdev handle 7595 * @param: parameter type to get value 7596 * @val: buffer address 7597 * 7598 * Return: status 7599 */ 7600 static QDF_STATUS dp_get_vdev_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7601 enum cdp_vdev_param_type param, 7602 cdp_config_param_type *val) 7603 { 7604 struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); 7605 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 7606 DP_MOD_ID_CDP); 7607 7608 if (!vdev) 7609 return QDF_STATUS_E_FAILURE; 7610 7611 switch (param) { 7612 case CDP_ENABLE_WDS: 7613 val->cdp_vdev_param_wds = vdev->wds_enabled; 7614 break; 7615 case CDP_ENABLE_MEC: 7616 val->cdp_vdev_param_mec = vdev->mec_enabled; 7617 break; 7618 case CDP_ENABLE_DA_WAR: 7619 val->cdp_vdev_param_da_war = vdev->pdev->soc->da_war_enabled; 7620 break; 7621 case CDP_ENABLE_IGMP_MCAST_EN: 7622 val->cdp_vdev_param_igmp_mcast_en = vdev->igmp_mcast_enhanc_en; 7623 break; 7624 case CDP_ENABLE_MCAST_EN: 7625 val->cdp_vdev_param_mcast_en = vdev->mcast_enhancement_en; 7626 break; 7627 case CDP_ENABLE_HLOS_TID_OVERRIDE: 7628 val->cdp_vdev_param_hlos_tid_override = 7629 dp_vdev_get_hlos_tid_override((struct cdp_vdev *)vdev); 7630 break; 7631 case CDP_ENABLE_PEER_AUTHORIZE: 7632 val->cdp_vdev_param_peer_authorize = 7633 vdev->peer_authorize; 7634 break; 7635 case CDP_TX_ENCAP_TYPE: 7636 val->cdp_vdev_param_tx_encap = vdev->tx_encap_type; 7637 break; 7638 case CDP_ENABLE_CIPHER: 7639 val->cdp_vdev_param_cipher_en = vdev->sec_type; 7640 break; 7641 #ifdef WLAN_SUPPORT_MESH_LATENCY 7642 case CDP_ENABLE_PEER_TID_LATENCY: 7643 val->cdp_vdev_param_peer_tid_latency_enable = 7644 vdev->peer_tid_latency_enabled; 7645 break; 7646 case CDP_SET_VAP_MESH_TID: 7647 val->cdp_vdev_param_mesh_tid = 7648 vdev->mesh_tid_latency_config.latency_tid; 7649 break; 7650 #endif 7651 case CDP_DROP_3ADDR_MCAST: 7652 val->cdp_drop_3addr_mcast = vdev->drop_3addr_mcast; 7653 break; 7654 case CDP_SET_MCAST_VDEV: 7655 soc->arch_ops.txrx_get_vdev_mcast_param(soc, vdev, val); 7656 break; 7657 #ifdef QCA_SUPPORT_WDS_EXTENDED 7658 case CDP_DROP_TX_MCAST: 7659 val->cdp_drop_tx_mcast = vdev->drop_tx_mcast; 7660 break; 7661 #endif 7662 7663 #ifdef MESH_MODE_SUPPORT 7664 case CDP_MESH_RX_FILTER: 7665 val->cdp_vdev_param_mesh_rx_filter = vdev->mesh_rx_filter; 7666 break; 7667 case CDP_MESH_MODE: 7668 val->cdp_vdev_param_mesh_mode = vdev->mesh_vdev; 7669 break; 7670 #endif 7671 case CDP_ENABLE_NAWDS: 7672 val->cdp_vdev_param_nawds = vdev->nawds_enabled; 7673 break; 7674 7675 case CDP_ENABLE_WRAP: 7676 val->cdp_vdev_param_wrap = vdev->wrap_vdev; 7677 break; 7678 7679 #ifdef DP_TRAFFIC_END_INDICATION 7680 case CDP_ENABLE_TRAFFIC_END_INDICATION: 7681 val->cdp_vdev_param_traffic_end_ind = vdev->traffic_end_ind_en; 7682 break; 7683 #endif 7684 7685 default: 7686 dp_cdp_err("%pK: param value %d is wrong", 7687 soc, param); 7688 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 7689 return QDF_STATUS_E_FAILURE; 7690 } 7691 7692 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 7693 return QDF_STATUS_SUCCESS; 7694 } 7695 7696 /** 7697 * dp_set_vdev_param() - function to set parameters in vdev 7698 * @cdp_soc: DP soc handle 7699 * @vdev_id: id of DP vdev handle 7700 * @param: parameter type to get value 7701 * @val: value 7702 * 7703 * Return: QDF_STATUS 7704 */ 7705 static QDF_STATUS 7706 dp_set_vdev_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7707 enum cdp_vdev_param_type param, cdp_config_param_type val) 7708 { 7709 struct dp_soc *dsoc = (struct dp_soc *)cdp_soc; 7710 struct dp_vdev *vdev = 7711 dp_vdev_get_ref_by_id(dsoc, vdev_id, DP_MOD_ID_CDP); 7712 uint32_t var = 0; 7713 7714 if (!vdev) 7715 return QDF_STATUS_E_FAILURE; 7716 7717 switch (param) { 7718 case CDP_ENABLE_WDS: 7719 dp_cdp_err("%pK: wds_enable %d for vdev(%pK) id(%d)", 7720 dsoc, val.cdp_vdev_param_wds, vdev, vdev->vdev_id); 7721 vdev->wds_enabled = val.cdp_vdev_param_wds; 7722 break; 7723 case CDP_ENABLE_MEC: 7724 dp_cdp_err("%pK: mec_enable %d for vdev(%pK) id(%d)", 7725 dsoc, val.cdp_vdev_param_mec, vdev, vdev->vdev_id); 7726 vdev->mec_enabled = val.cdp_vdev_param_mec; 7727 break; 7728 case CDP_ENABLE_DA_WAR: 7729 dp_cdp_err("%pK: da_war_enable %d for vdev(%pK) id(%d)", 7730 dsoc, val.cdp_vdev_param_da_war, vdev, vdev->vdev_id); 7731 vdev->pdev->soc->da_war_enabled = val.cdp_vdev_param_da_war; 7732 dp_wds_flush_ast_table_wifi3(((struct cdp_soc_t *) 7733 vdev->pdev->soc)); 7734 break; 7735 case CDP_ENABLE_NAWDS: 7736 vdev->nawds_enabled = val.cdp_vdev_param_nawds; 7737 break; 7738 case CDP_ENABLE_MCAST_EN: 7739 vdev->mcast_enhancement_en = val.cdp_vdev_param_mcast_en; 7740 break; 7741 case CDP_ENABLE_IGMP_MCAST_EN: 7742 vdev->igmp_mcast_enhanc_en = val.cdp_vdev_param_igmp_mcast_en; 7743 break; 7744 case CDP_ENABLE_PROXYSTA: 7745 vdev->proxysta_vdev = val.cdp_vdev_param_proxysta; 7746 break; 7747 case CDP_UPDATE_TDLS_FLAGS: 7748 vdev->tdls_link_connected = val.cdp_vdev_param_tdls_flags; 7749 break; 7750 case CDP_CFG_WDS_AGING_TIMER: 7751 var = val.cdp_vdev_param_aging_tmr; 7752 if (!var) 7753 qdf_timer_stop(&vdev->pdev->soc->ast_aging_timer); 7754 else if (var != vdev->wds_aging_timer_val) 7755 qdf_timer_mod(&vdev->pdev->soc->ast_aging_timer, var); 7756 7757 vdev->wds_aging_timer_val = var; 7758 break; 7759 case CDP_ENABLE_AP_BRIDGE: 7760 if (wlan_op_mode_sta != vdev->opmode) 7761 vdev->ap_bridge_enabled = val.cdp_vdev_param_ap_brdg_en; 7762 else 7763 vdev->ap_bridge_enabled = false; 7764 break; 7765 case CDP_ENABLE_CIPHER: 7766 vdev->sec_type = val.cdp_vdev_param_cipher_en; 7767 break; 7768 case CDP_ENABLE_QWRAP_ISOLATION: 7769 vdev->isolation_vdev = val.cdp_vdev_param_qwrap_isolation; 7770 break; 7771 case CDP_UPDATE_MULTIPASS: 7772 vdev->multipass_en = val.cdp_vdev_param_update_multipass; 7773 dp_info("vdev %d Multipass enable %d", vdev_id, 7774 vdev->multipass_en); 7775 break; 7776 case CDP_TX_ENCAP_TYPE: 7777 vdev->tx_encap_type = val.cdp_vdev_param_tx_encap; 7778 break; 7779 case CDP_RX_DECAP_TYPE: 7780 vdev->rx_decap_type = val.cdp_vdev_param_rx_decap; 7781 break; 7782 case CDP_TID_VDEV_PRTY: 7783 vdev->tidmap_prty = val.cdp_vdev_param_tidmap_prty; 7784 break; 7785 case CDP_TIDMAP_TBL_ID: 7786 vdev->tidmap_tbl_id = val.cdp_vdev_param_tidmap_tbl_id; 7787 break; 7788 #ifdef MESH_MODE_SUPPORT 7789 case CDP_MESH_RX_FILTER: 7790 dp_vdev_set_mesh_rx_filter((struct cdp_vdev *)vdev, 7791 val.cdp_vdev_param_mesh_rx_filter); 7792 break; 7793 case CDP_MESH_MODE: 7794 dp_vdev_set_mesh_mode((struct cdp_vdev *)vdev, 7795 val.cdp_vdev_param_mesh_mode); 7796 break; 7797 #endif 7798 case CDP_ENABLE_HLOS_TID_OVERRIDE: 7799 dp_info("vdev_id %d enable hlod tid override %d", vdev_id, 7800 val.cdp_vdev_param_hlos_tid_override); 7801 dp_vdev_set_hlos_tid_override(vdev, 7802 val.cdp_vdev_param_hlos_tid_override); 7803 break; 7804 #ifdef QCA_SUPPORT_WDS_EXTENDED 7805 case CDP_CFG_WDS_EXT: 7806 if (vdev->opmode == wlan_op_mode_ap) 7807 vdev->wds_ext_enabled = val.cdp_vdev_param_wds_ext; 7808 break; 7809 case CDP_DROP_TX_MCAST: 7810 dp_info("vdev_id %d drop tx mcast :%d", vdev_id, 7811 val.cdp_drop_tx_mcast); 7812 vdev->drop_tx_mcast = val.cdp_drop_tx_mcast; 7813 break; 7814 #endif 7815 case CDP_ENABLE_PEER_AUTHORIZE: 7816 vdev->peer_authorize = val.cdp_vdev_param_peer_authorize; 7817 break; 7818 #ifdef WLAN_SUPPORT_MESH_LATENCY 7819 case CDP_ENABLE_PEER_TID_LATENCY: 7820 dp_info("vdev_id %d enable peer tid latency %d", vdev_id, 7821 val.cdp_vdev_param_peer_tid_latency_enable); 7822 vdev->peer_tid_latency_enabled = 7823 val.cdp_vdev_param_peer_tid_latency_enable; 7824 break; 7825 case CDP_SET_VAP_MESH_TID: 7826 dp_info("vdev_id %d enable peer tid latency %d", vdev_id, 7827 val.cdp_vdev_param_mesh_tid); 7828 vdev->mesh_tid_latency_config.latency_tid 7829 = val.cdp_vdev_param_mesh_tid; 7830 break; 7831 #endif 7832 #ifdef WLAN_VENDOR_SPECIFIC_BAR_UPDATE 7833 case CDP_SKIP_BAR_UPDATE_AP: 7834 dp_info("vdev_id %d skip BAR update: %u", vdev_id, 7835 val.cdp_skip_bar_update); 7836 vdev->skip_bar_update = val.cdp_skip_bar_update; 7837 vdev->skip_bar_update_last_ts = 0; 7838 break; 7839 #endif 7840 case CDP_DROP_3ADDR_MCAST: 7841 dp_info("vdev_id %d drop 3 addr mcast :%d", vdev_id, 7842 val.cdp_drop_3addr_mcast); 7843 vdev->drop_3addr_mcast = val.cdp_drop_3addr_mcast; 7844 break; 7845 case CDP_ENABLE_WRAP: 7846 vdev->wrap_vdev = val.cdp_vdev_param_wrap; 7847 break; 7848 #ifdef DP_TRAFFIC_END_INDICATION 7849 case CDP_ENABLE_TRAFFIC_END_INDICATION: 7850 vdev->traffic_end_ind_en = val.cdp_vdev_param_traffic_end_ind; 7851 break; 7852 #endif 7853 #ifdef FEATURE_DIRECT_LINK 7854 case CDP_VDEV_TX_TO_FW: 7855 dp_info("vdev_id %d to_fw :%d", vdev_id, val.cdp_vdev_tx_to_fw); 7856 vdev->to_fw = val.cdp_vdev_tx_to_fw; 7857 break; 7858 #endif 7859 case CDP_VDEV_SET_MAC_ADDR: 7860 dp_info("set mac addr, old mac addr" QDF_MAC_ADDR_FMT 7861 " new mac addr: " QDF_MAC_ADDR_FMT " for vdev %d", 7862 QDF_MAC_ADDR_REF(vdev->mac_addr.raw), 7863 QDF_MAC_ADDR_REF(val.mac_addr), vdev->vdev_id); 7864 qdf_mem_copy(&vdev->mac_addr.raw[0], val.mac_addr, 7865 QDF_MAC_ADDR_SIZE); 7866 break; 7867 default: 7868 break; 7869 } 7870 7871 dp_tx_vdev_update_search_flags((struct dp_vdev *)vdev); 7872 dsoc->arch_ops.txrx_set_vdev_param(dsoc, vdev, param, val); 7873 7874 /* Update PDEV flags as VDEV flags are updated */ 7875 dp_pdev_update_fast_rx_flag(dsoc, vdev->pdev); 7876 dp_vdev_unref_delete(dsoc, vdev, DP_MOD_ID_CDP); 7877 7878 return QDF_STATUS_SUCCESS; 7879 } 7880 7881 #if defined(FEATURE_WLAN_TDLS) && defined(WLAN_FEATURE_11BE_MLO) 7882 /** 7883 * dp_update_mlo_vdev_for_tdls() - update mlo vdev configuration 7884 * for TDLS 7885 * @cdp_soc: DP soc handle 7886 * @vdev_id: id of DP vdev handle 7887 * @param: parameter type for vdev 7888 * @val: value 7889 * 7890 * If TDLS connection is from secondary vdev, then copy osif_vdev from 7891 * primary vdev to support RX, update TX bank register info for primary 7892 * vdev as well. 7893 * If TDLS connection is from primary vdev, same as before. 7894 * 7895 * Return: None 7896 */ 7897 static void 7898 dp_update_mlo_vdev_for_tdls(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7899 enum cdp_vdev_param_type param, 7900 cdp_config_param_type val) 7901 { 7902 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 7903 struct dp_peer *peer; 7904 struct dp_peer *tmp_peer; 7905 struct dp_peer *mld_peer; 7906 struct dp_vdev *vdev = NULL; 7907 struct dp_vdev *pri_vdev = NULL; 7908 uint8_t pri_vdev_id = CDP_INVALID_VDEV_ID; 7909 7910 if (param != CDP_UPDATE_TDLS_FLAGS) 7911 return; 7912 7913 dp_info("update TDLS flag for vdev_id %d, val %d", 7914 vdev_id, val.cdp_vdev_param_tdls_flags); 7915 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_MISC); 7916 /* only check for STA mode vdev */ 7917 if (!vdev || vdev->opmode != wlan_op_mode_sta) { 7918 dp_info("vdev is not as expected for TDLS"); 7919 goto comp_ret; 7920 } 7921 7922 /* Find primary vdev_id */ 7923 qdf_spin_lock_bh(&vdev->peer_list_lock); 7924 TAILQ_FOREACH_SAFE(peer, &vdev->peer_list, 7925 peer_list_elem, 7926 tmp_peer) { 7927 if (dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG) == 7928 QDF_STATUS_SUCCESS) { 7929 /* do check only if MLO link peer exist */ 7930 if (IS_MLO_DP_LINK_PEER(peer)) { 7931 mld_peer = DP_GET_MLD_PEER_FROM_PEER(peer); 7932 pri_vdev_id = mld_peer->vdev->vdev_id; 7933 dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); 7934 break; 7935 } 7936 dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); 7937 } 7938 } 7939 qdf_spin_unlock_bh(&vdev->peer_list_lock); 7940 7941 if (pri_vdev_id != CDP_INVALID_VDEV_ID) 7942 pri_vdev = dp_vdev_get_ref_by_id(soc, pri_vdev_id, 7943 DP_MOD_ID_MISC); 7944 7945 /* If current vdev is not same as primary vdev */ 7946 if (pri_vdev && pri_vdev != vdev) { 7947 dp_info("primary vdev [%d] %pK different with vdev [%d] %pK", 7948 pri_vdev->vdev_id, pri_vdev, 7949 vdev->vdev_id, vdev); 7950 /* update osif_vdev to support RX for vdev */ 7951 vdev->osif_vdev = pri_vdev->osif_vdev; 7952 dp_set_vdev_param(cdp_soc, pri_vdev->vdev_id, 7953 CDP_UPDATE_TDLS_FLAGS, val); 7954 } 7955 7956 comp_ret: 7957 if (pri_vdev) 7958 dp_vdev_unref_delete(soc, pri_vdev, DP_MOD_ID_MISC); 7959 if (vdev) 7960 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_MISC); 7961 } 7962 7963 static QDF_STATUS 7964 dp_set_vdev_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7965 enum cdp_vdev_param_type param, 7966 cdp_config_param_type val) 7967 { 7968 dp_update_mlo_vdev_for_tdls(cdp_soc, vdev_id, param, val); 7969 7970 return dp_set_vdev_param(cdp_soc, vdev_id, param, val); 7971 } 7972 #else 7973 static QDF_STATUS 7974 dp_set_vdev_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, 7975 enum cdp_vdev_param_type param, 7976 cdp_config_param_type val) 7977 { 7978 return dp_set_vdev_param(cdp_soc, vdev_id, param, val); 7979 } 7980 #endif 7981 7982 /** 7983 * dp_rx_peer_metadata_ver_update() - update rx peer metadata version and 7984 * corresponding filed shift and mask 7985 * @soc: Handle to DP Soc structure 7986 * @peer_md_ver: RX peer metadata version value 7987 * 7988 * Return: None 7989 */ 7990 static void 7991 dp_rx_peer_metadata_ver_update(struct dp_soc *soc, uint8_t peer_md_ver) 7992 { 7993 dp_info("rx_peer_metadata version %d", peer_md_ver); 7994 7995 switch (peer_md_ver) { 7996 case 0: /* htt_rx_peer_metadata_v0 */ 7997 soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V0_PEER_ID_S; 7998 soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V0_PEER_ID_M; 7999 soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V0_VDEV_ID_S; 8000 soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V0_VDEV_ID_M; 8001 break; 8002 case 1: /* htt_rx_peer_metadata_v1 */ 8003 soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1_PEER_ID_S; 8004 soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1_PEER_ID_M; 8005 soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1_VDEV_ID_S; 8006 soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1_VDEV_ID_M; 8007 soc->htt_mld_peer_valid_s = 8008 HTT_RX_PEER_META_DATA_V1_ML_PEER_VALID_S; 8009 soc->htt_mld_peer_valid_m = 8010 HTT_RX_PEER_META_DATA_V1_ML_PEER_VALID_M; 8011 break; 8012 case 2: /* htt_rx_peer_metadata_v1a */ 8013 soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1A_PEER_ID_S; 8014 soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1A_PEER_ID_M; 8015 soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1A_VDEV_ID_S; 8016 soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1A_VDEV_ID_M; 8017 soc->htt_mld_peer_valid_s = 8018 HTT_RX_PEER_META_DATA_V1A_ML_PEER_VALID_S; 8019 soc->htt_mld_peer_valid_m = 8020 HTT_RX_PEER_META_DATA_V1A_ML_PEER_VALID_M; 8021 break; 8022 case 3: /* htt_rx_peer_metadata_v1b */ 8023 soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1B_PEER_ID_S; 8024 soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1B_PEER_ID_M; 8025 soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1B_VDEV_ID_S; 8026 soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1B_VDEV_ID_M; 8027 soc->htt_mld_peer_valid_s = 8028 HTT_RX_PEER_META_DATA_V1B_ML_PEER_VALID_S; 8029 soc->htt_mld_peer_valid_m = 8030 HTT_RX_PEER_META_DATA_V1B_ML_PEER_VALID_M; 8031 break; 8032 default: 8033 dp_err("invliad rx_peer_metadata version %d", peer_md_ver); 8034 break; 8035 } 8036 8037 soc->rx_peer_metadata_ver = peer_md_ver; 8038 } 8039 8040 /** 8041 * dp_set_psoc_param: function to set parameters in psoc 8042 * @cdp_soc: DP soc handle 8043 * @param: parameter type to be set 8044 * @val: value of parameter to be set 8045 * 8046 * Return: QDF_STATUS 8047 */ 8048 static QDF_STATUS 8049 dp_set_psoc_param(struct cdp_soc_t *cdp_soc, 8050 enum cdp_psoc_param_type param, cdp_config_param_type val) 8051 { 8052 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 8053 struct wlan_cfg_dp_soc_ctxt *wlan_cfg_ctx = soc->wlan_cfg_ctx; 8054 8055 switch (param) { 8056 case CDP_ENABLE_RATE_STATS: 8057 soc->peerstats_enabled = val.cdp_psoc_param_en_rate_stats; 8058 break; 8059 case CDP_SET_NSS_CFG: 8060 wlan_cfg_set_dp_soc_nss_cfg(wlan_cfg_ctx, 8061 val.cdp_psoc_param_en_nss_cfg); 8062 /* 8063 * TODO: masked out based on the per offloaded radio 8064 */ 8065 switch (val.cdp_psoc_param_en_nss_cfg) { 8066 case dp_nss_cfg_default: 8067 break; 8068 case dp_nss_cfg_first_radio: 8069 /* 8070 * This configuration is valid for single band radio which 8071 * is also NSS offload. 8072 */ 8073 case dp_nss_cfg_dbdc: 8074 case dp_nss_cfg_dbtc: 8075 wlan_cfg_set_num_tx_desc_pool(wlan_cfg_ctx, 0); 8076 wlan_cfg_set_num_tx_ext_desc_pool(wlan_cfg_ctx, 0); 8077 wlan_cfg_set_num_tx_desc(wlan_cfg_ctx, 0); 8078 wlan_cfg_set_num_tx_ext_desc(wlan_cfg_ctx, 0); 8079 break; 8080 default: 8081 dp_cdp_err("%pK: Invalid offload config %d", 8082 soc, val.cdp_psoc_param_en_nss_cfg); 8083 } 8084 8085 dp_cdp_err("%pK: nss-wifi<0> nss config is enabled" 8086 , soc); 8087 break; 8088 case CDP_SET_PREFERRED_HW_MODE: 8089 soc->preferred_hw_mode = val.cdp_psoc_param_preferred_hw_mode; 8090 break; 8091 case CDP_IPA_ENABLE: 8092 soc->wlan_cfg_ctx->ipa_enabled = val.cdp_ipa_enabled; 8093 break; 8094 case CDP_CFG_VDEV_STATS_HW_OFFLOAD: 8095 wlan_cfg_set_vdev_stats_hw_offload_config(wlan_cfg_ctx, 8096 val.cdp_psoc_param_vdev_stats_hw_offload); 8097 break; 8098 case CDP_SAWF_ENABLE: 8099 wlan_cfg_set_sawf_config(wlan_cfg_ctx, val.cdp_sawf_enabled); 8100 break; 8101 case CDP_UMAC_RST_SKEL_ENABLE: 8102 dp_umac_rst_skel_enable_update(soc, val.cdp_umac_rst_skel); 8103 break; 8104 case CDP_UMAC_RESET_STATS: 8105 dp_umac_reset_stats_print(soc); 8106 break; 8107 case CDP_SAWF_STATS: 8108 wlan_cfg_set_sawf_stats_config(wlan_cfg_ctx, 8109 val.cdp_sawf_stats); 8110 break; 8111 case CDP_CFG_RX_PEER_METADATA_VER: 8112 dp_rx_peer_metadata_ver_update( 8113 soc, val.cdp_peer_metadata_ver); 8114 break; 8115 case CDP_CFG_TX_DESC_NUM: 8116 wlan_cfg_set_num_tx_desc(wlan_cfg_ctx, 8117 val.cdp_tx_desc_num); 8118 break; 8119 case CDP_CFG_TX_EXT_DESC_NUM: 8120 wlan_cfg_set_num_tx_ext_desc(wlan_cfg_ctx, 8121 val.cdp_tx_ext_desc_num); 8122 break; 8123 case CDP_CFG_TX_RING_SIZE: 8124 wlan_cfg_set_tx_ring_size(wlan_cfg_ctx, 8125 val.cdp_tx_ring_size); 8126 break; 8127 case CDP_CFG_TX_COMPL_RING_SIZE: 8128 wlan_cfg_set_tx_comp_ring_size(wlan_cfg_ctx, 8129 val.cdp_tx_comp_ring_size); 8130 break; 8131 case CDP_CFG_RX_SW_DESC_NUM: 8132 wlan_cfg_set_dp_soc_rx_sw_desc_num(wlan_cfg_ctx, 8133 val.cdp_rx_sw_desc_num); 8134 break; 8135 case CDP_CFG_REO_DST_RING_SIZE: 8136 wlan_cfg_set_reo_dst_ring_size(wlan_cfg_ctx, 8137 val.cdp_reo_dst_ring_size); 8138 break; 8139 case CDP_CFG_RXDMA_REFILL_RING_SIZE: 8140 wlan_cfg_set_dp_soc_rxdma_refill_ring_size(wlan_cfg_ctx, 8141 val.cdp_rxdma_refill_ring_size); 8142 break; 8143 #ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL 8144 case CDP_CFG_RX_REFILL_POOL_NUM: 8145 wlan_cfg_set_rx_refill_buf_pool_size(wlan_cfg_ctx, 8146 val.cdp_rx_refill_buf_pool_size); 8147 break; 8148 #endif 8149 case CDP_CFG_AST_INDICATION_DISABLE: 8150 wlan_cfg_set_ast_indication_disable 8151 (wlan_cfg_ctx, val.cdp_ast_indication_disable); 8152 break; 8153 default: 8154 break; 8155 } 8156 8157 return QDF_STATUS_SUCCESS; 8158 } 8159 8160 /** 8161 * dp_get_psoc_param: function to get parameters in soc 8162 * @cdp_soc: DP soc handle 8163 * @param: parameter type to be get 8164 * @val: address of buffer 8165 * 8166 * Return: status 8167 */ 8168 static QDF_STATUS dp_get_psoc_param(struct cdp_soc_t *cdp_soc, 8169 enum cdp_psoc_param_type param, 8170 cdp_config_param_type *val) 8171 { 8172 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 8173 struct wlan_cfg_dp_soc_ctxt *wlan_cfg_ctx; 8174 8175 if (!soc) 8176 return QDF_STATUS_E_FAILURE; 8177 8178 wlan_cfg_ctx = soc->wlan_cfg_ctx; 8179 8180 switch (param) { 8181 case CDP_CFG_PEER_EXT_STATS: 8182 val->cdp_psoc_param_pext_stats = 8183 wlan_cfg_is_peer_ext_stats_enabled(wlan_cfg_ctx); 8184 break; 8185 case CDP_CFG_VDEV_STATS_HW_OFFLOAD: 8186 val->cdp_psoc_param_vdev_stats_hw_offload = 8187 wlan_cfg_get_vdev_stats_hw_offload_config(wlan_cfg_ctx); 8188 break; 8189 case CDP_UMAC_RST_SKEL_ENABLE: 8190 val->cdp_umac_rst_skel = dp_umac_rst_skel_enable_get(soc); 8191 break; 8192 case CDP_TXRX_HAL_SOC_HDL: 8193 val->hal_soc_hdl = soc->hal_soc; 8194 break; 8195 case CDP_CFG_TX_DESC_NUM: 8196 val->cdp_tx_desc_num = wlan_cfg_get_num_tx_desc(wlan_cfg_ctx); 8197 break; 8198 case CDP_CFG_TX_EXT_DESC_NUM: 8199 val->cdp_tx_ext_desc_num = 8200 wlan_cfg_get_num_tx_ext_desc(wlan_cfg_ctx); 8201 break; 8202 case CDP_CFG_TX_RING_SIZE: 8203 val->cdp_tx_ring_size = wlan_cfg_tx_ring_size(wlan_cfg_ctx); 8204 break; 8205 case CDP_CFG_TX_COMPL_RING_SIZE: 8206 val->cdp_tx_comp_ring_size = 8207 wlan_cfg_tx_comp_ring_size(wlan_cfg_ctx); 8208 break; 8209 case CDP_CFG_RX_SW_DESC_NUM: 8210 val->cdp_rx_sw_desc_num = 8211 wlan_cfg_get_dp_soc_rx_sw_desc_num(wlan_cfg_ctx); 8212 break; 8213 case CDP_CFG_REO_DST_RING_SIZE: 8214 val->cdp_reo_dst_ring_size = 8215 wlan_cfg_get_reo_dst_ring_size(wlan_cfg_ctx); 8216 break; 8217 case CDP_CFG_RXDMA_REFILL_RING_SIZE: 8218 val->cdp_rxdma_refill_ring_size = 8219 wlan_cfg_get_dp_soc_rxdma_refill_ring_size(wlan_cfg_ctx); 8220 break; 8221 #ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL 8222 case CDP_CFG_RX_REFILL_POOL_NUM: 8223 val->cdp_rx_refill_buf_pool_size = 8224 wlan_cfg_get_rx_refill_buf_pool_size(wlan_cfg_ctx); 8225 break; 8226 #endif 8227 case CDP_CFG_FISA_PARAMS: 8228 val->fisa_params.fisa_fst_size = wlan_cfg_get_rx_flow_search_table_size(soc->wlan_cfg_ctx); 8229 val->fisa_params.rx_flow_max_search = 8230 wlan_cfg_rx_fst_get_max_search(soc->wlan_cfg_ctx); 8231 val->fisa_params.rx_toeplitz_hash_key = 8232 wlan_cfg_rx_fst_get_hash_key(soc->wlan_cfg_ctx); 8233 break; 8234 case CDP_RX_PKT_TLV_SIZE: 8235 val->rx_pkt_tlv_size = soc->rx_pkt_tlv_size; 8236 break; 8237 default: 8238 dp_warn("Invalid param: %u", param); 8239 break; 8240 } 8241 8242 return QDF_STATUS_SUCCESS; 8243 } 8244 8245 /** 8246 * dp_set_vdev_dscp_tid_map_wifi3() - Update Map ID selected for particular vdev 8247 * @cdp_soc: CDP SOC handle 8248 * @vdev_id: id of DP_VDEV handle 8249 * @map_id:ID of map that needs to be updated 8250 * 8251 * Return: QDF_STATUS 8252 */ 8253 static QDF_STATUS dp_set_vdev_dscp_tid_map_wifi3(ol_txrx_soc_handle cdp_soc, 8254 uint8_t vdev_id, 8255 uint8_t map_id) 8256 { 8257 cdp_config_param_type val; 8258 struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); 8259 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 8260 DP_MOD_ID_CDP); 8261 if (vdev) { 8262 vdev->dscp_tid_map_id = map_id; 8263 val.cdp_vdev_param_dscp_tid_map_id = map_id; 8264 soc->arch_ops.txrx_set_vdev_param(soc, 8265 vdev, 8266 CDP_UPDATE_DSCP_TO_TID_MAP, 8267 val); 8268 /* Update flag for transmit tid classification */ 8269 if (vdev->dscp_tid_map_id < soc->num_hw_dscp_tid_map) 8270 vdev->skip_sw_tid_classification |= 8271 DP_TX_HW_DSCP_TID_MAP_VALID; 8272 else 8273 vdev->skip_sw_tid_classification &= 8274 ~DP_TX_HW_DSCP_TID_MAP_VALID; 8275 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 8276 return QDF_STATUS_SUCCESS; 8277 } 8278 8279 return QDF_STATUS_E_FAILURE; 8280 } 8281 8282 #ifdef DP_RATETABLE_SUPPORT 8283 static int dp_txrx_get_ratekbps(int preamb, int mcs, 8284 int htflag, int gintval) 8285 { 8286 uint32_t rix; 8287 uint16_t ratecode; 8288 enum cdp_punctured_modes punc_mode = NO_PUNCTURE; 8289 8290 return dp_getrateindex((uint32_t)gintval, (uint16_t)mcs, 1, 8291 (uint8_t)preamb, 1, punc_mode, 8292 &rix, &ratecode); 8293 } 8294 #else 8295 static int dp_txrx_get_ratekbps(int preamb, int mcs, 8296 int htflag, int gintval) 8297 { 8298 return 0; 8299 } 8300 #endif 8301 8302 /** 8303 * dp_txrx_get_pdev_stats() - Returns cdp_pdev_stats 8304 * @soc: DP soc handle 8305 * @pdev_id: id of DP pdev handle 8306 * @pdev_stats: buffer to copy to 8307 * 8308 * Return: status success/failure 8309 */ 8310 static QDF_STATUS 8311 dp_txrx_get_pdev_stats(struct cdp_soc_t *soc, uint8_t pdev_id, 8312 struct cdp_pdev_stats *pdev_stats) 8313 { 8314 struct dp_pdev *pdev = 8315 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 8316 pdev_id); 8317 if (!pdev) 8318 return QDF_STATUS_E_FAILURE; 8319 8320 dp_aggregate_pdev_stats(pdev); 8321 8322 qdf_mem_copy(pdev_stats, &pdev->stats, sizeof(struct cdp_pdev_stats)); 8323 return QDF_STATUS_SUCCESS; 8324 } 8325 8326 /** 8327 * dp_txrx_update_vdev_me_stats() - Update vdev ME stats sent from CDP 8328 * @vdev: DP vdev handle 8329 * @buf: buffer containing specific stats structure 8330 * 8331 * Return: void 8332 */ 8333 static void dp_txrx_update_vdev_me_stats(struct dp_vdev *vdev, 8334 void *buf) 8335 { 8336 struct cdp_tx_ingress_stats *host_stats = NULL; 8337 8338 if (!buf) { 8339 dp_cdp_err("%pK: Invalid host stats buf", vdev->pdev->soc); 8340 return; 8341 } 8342 host_stats = (struct cdp_tx_ingress_stats *)buf; 8343 8344 DP_STATS_INC_PKT(vdev, tx_i.mcast_en.mcast_pkt, 8345 host_stats->mcast_en.mcast_pkt.num, 8346 host_stats->mcast_en.mcast_pkt.bytes); 8347 DP_STATS_INC(vdev, tx_i.mcast_en.dropped_map_error, 8348 host_stats->mcast_en.dropped_map_error); 8349 DP_STATS_INC(vdev, tx_i.mcast_en.dropped_self_mac, 8350 host_stats->mcast_en.dropped_self_mac); 8351 DP_STATS_INC(vdev, tx_i.mcast_en.dropped_send_fail, 8352 host_stats->mcast_en.dropped_send_fail); 8353 DP_STATS_INC(vdev, tx_i.mcast_en.ucast, 8354 host_stats->mcast_en.ucast); 8355 DP_STATS_INC(vdev, tx_i.mcast_en.fail_seg_alloc, 8356 host_stats->mcast_en.fail_seg_alloc); 8357 DP_STATS_INC(vdev, tx_i.mcast_en.clone_fail, 8358 host_stats->mcast_en.clone_fail); 8359 } 8360 8361 /** 8362 * dp_txrx_update_vdev_igmp_me_stats() - Update vdev IGMP ME stats sent from CDP 8363 * @vdev: DP vdev handle 8364 * @buf: buffer containing specific stats structure 8365 * 8366 * Return: void 8367 */ 8368 static void dp_txrx_update_vdev_igmp_me_stats(struct dp_vdev *vdev, 8369 void *buf) 8370 { 8371 struct cdp_tx_ingress_stats *host_stats = NULL; 8372 8373 if (!buf) { 8374 dp_cdp_err("%pK: Invalid host stats buf", vdev->pdev->soc); 8375 return; 8376 } 8377 host_stats = (struct cdp_tx_ingress_stats *)buf; 8378 8379 DP_STATS_INC(vdev, tx_i.igmp_mcast_en.igmp_rcvd, 8380 host_stats->igmp_mcast_en.igmp_rcvd); 8381 DP_STATS_INC(vdev, tx_i.igmp_mcast_en.igmp_ucast_converted, 8382 host_stats->igmp_mcast_en.igmp_ucast_converted); 8383 } 8384 8385 /** 8386 * dp_txrx_update_vdev_host_stats() - Update stats sent through CDP 8387 * @soc_hdl: DP soc handle 8388 * @vdev_id: id of DP vdev handle 8389 * @buf: buffer containing specific stats structure 8390 * @stats_id: stats type 8391 * 8392 * Return: QDF_STATUS 8393 */ 8394 static QDF_STATUS dp_txrx_update_vdev_host_stats(struct cdp_soc_t *soc_hdl, 8395 uint8_t vdev_id, 8396 void *buf, 8397 uint16_t stats_id) 8398 { 8399 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 8400 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 8401 DP_MOD_ID_CDP); 8402 8403 if (!vdev) { 8404 dp_cdp_err("%pK: Invalid vdev handle", soc); 8405 return QDF_STATUS_E_FAILURE; 8406 } 8407 8408 switch (stats_id) { 8409 case DP_VDEV_STATS_PKT_CNT_ONLY: 8410 break; 8411 case DP_VDEV_STATS_TX_ME: 8412 dp_txrx_update_vdev_me_stats(vdev, buf); 8413 dp_txrx_update_vdev_igmp_me_stats(vdev, buf); 8414 break; 8415 default: 8416 qdf_info("Invalid stats_id %d", stats_id); 8417 break; 8418 } 8419 8420 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 8421 return QDF_STATUS_SUCCESS; 8422 } 8423 8424 /** 8425 * dp_txrx_get_peer_stats() - will return cdp_peer_stats 8426 * @soc: soc handle 8427 * @vdev_id: id of vdev handle 8428 * @peer_mac: mac of DP_PEER handle 8429 * @peer_stats: buffer to copy to 8430 * 8431 * Return: status success/failure 8432 */ 8433 static QDF_STATUS 8434 dp_txrx_get_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, 8435 uint8_t *peer_mac, struct cdp_peer_stats *peer_stats) 8436 { 8437 struct dp_peer *peer = NULL; 8438 struct cdp_peer_info peer_info = { 0 }; 8439 8440 DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, 8441 CDP_WILD_PEER_TYPE); 8442 8443 peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, 8444 DP_MOD_ID_CDP); 8445 8446 qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); 8447 8448 if (!peer) 8449 return QDF_STATUS_E_FAILURE; 8450 8451 dp_get_peer_stats(peer, peer_stats); 8452 8453 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 8454 8455 return QDF_STATUS_SUCCESS; 8456 } 8457 8458 #if defined WLAN_FEATURE_11BE_MLO && defined DP_MLO_LINK_STATS_SUPPORT 8459 /** 8460 * dp_get_per_link_peer_stats() - Get per link stats 8461 * @peer: DP peer 8462 * @peer_stats: buffer to copy to 8463 * @peer_type: Peer type 8464 * @num_link: Number of ML links 8465 * 8466 * Return: status success/failure 8467 */ 8468 QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer, 8469 struct cdp_peer_stats *peer_stats, 8470 enum cdp_peer_type peer_type, 8471 uint8_t num_link) 8472 { 8473 uint8_t i, index = 0; 8474 struct dp_peer *link_peer; 8475 struct dp_mld_link_peers link_peers_info; 8476 struct cdp_peer_stats *stats; 8477 struct dp_soc *soc = peer->vdev->pdev->soc; 8478 8479 dp_get_peer_calibr_stats(peer, peer_stats); 8480 dp_get_peer_basic_stats(peer, peer_stats); 8481 dp_get_peer_tx_per(peer_stats); 8482 8483 if (IS_MLO_DP_MLD_PEER(peer)) { 8484 dp_get_link_peers_ref_from_mld_peer(soc, peer, 8485 &link_peers_info, 8486 DP_MOD_ID_GENERIC_STATS); 8487 for (i = 0; i < link_peers_info.num_links; i++) { 8488 link_peer = link_peers_info.link_peers[i]; 8489 if (qdf_unlikely(!link_peer)) 8490 continue; 8491 if (index > num_link) { 8492 dp_err("Request stats for %d link(s) is less than total link(s) %d", 8493 num_link, link_peers_info.num_links); 8494 break; 8495 } 8496 stats = &peer_stats[index]; 8497 dp_get_peer_per_pkt_stats(link_peer, stats); 8498 dp_get_peer_extd_stats(link_peer, stats); 8499 index++; 8500 } 8501 dp_release_link_peers_ref(&link_peers_info, 8502 DP_MOD_ID_GENERIC_STATS); 8503 } else { 8504 dp_get_peer_per_pkt_stats(peer, peer_stats); 8505 dp_get_peer_extd_stats(peer, peer_stats); 8506 } 8507 return QDF_STATUS_SUCCESS; 8508 } 8509 #else 8510 QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer, 8511 struct cdp_peer_stats *peer_stats, 8512 enum cdp_peer_type peer_type, 8513 uint8_t num_link) 8514 { 8515 dp_err("Per link stats not supported"); 8516 return QDF_STATUS_E_INVAL; 8517 } 8518 #endif 8519 8520 /** 8521 * dp_txrx_get_per_link_peer_stats() - Get per link peer stats 8522 * @soc: soc handle 8523 * @vdev_id: id of vdev handle 8524 * @peer_mac: peer mac address 8525 * @peer_stats: buffer to copy to 8526 * @peer_type: Peer type 8527 * @num_link: Number of ML links 8528 * 8529 * NOTE: For peer_type = CDP_MLD_PEER_TYPE peer_stats should point to 8530 * buffer of size = (sizeof(*peer_stats) * num_link) 8531 * 8532 * Return: status success/failure 8533 */ 8534 static QDF_STATUS 8535 dp_txrx_get_per_link_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, 8536 uint8_t *peer_mac, 8537 struct cdp_peer_stats *peer_stats, 8538 enum cdp_peer_type peer_type, uint8_t num_link) 8539 { 8540 QDF_STATUS status; 8541 struct dp_peer *peer = NULL; 8542 struct cdp_peer_info peer_info = { 0 }; 8543 8544 DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, 8545 peer_type); 8546 8547 peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, 8548 DP_MOD_ID_GENERIC_STATS); 8549 if (!peer) 8550 return QDF_STATUS_E_FAILURE; 8551 8552 qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); 8553 8554 status = dp_get_per_link_peer_stats(peer, peer_stats, peer_type, 8555 num_link); 8556 8557 dp_peer_unref_delete(peer, DP_MOD_ID_GENERIC_STATS); 8558 8559 return status; 8560 } 8561 8562 /** 8563 * dp_txrx_get_peer_stats_param() - will return specified cdp_peer_stats 8564 * @soc: soc handle 8565 * @vdev_id: vdev_id of vdev object 8566 * @peer_mac: mac address of the peer 8567 * @type: enum of required stats 8568 * @buf: buffer to hold the value 8569 * 8570 * Return: status success/failure 8571 */ 8572 static QDF_STATUS 8573 dp_txrx_get_peer_stats_param(struct cdp_soc_t *soc, uint8_t vdev_id, 8574 uint8_t *peer_mac, enum cdp_peer_stats_type type, 8575 cdp_peer_stats_param_t *buf) 8576 { 8577 QDF_STATUS ret; 8578 struct dp_peer *peer = NULL; 8579 struct cdp_peer_info peer_info = { 0 }; 8580 8581 DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, 8582 CDP_WILD_PEER_TYPE); 8583 8584 peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, 8585 DP_MOD_ID_CDP); 8586 8587 if (!peer) { 8588 dp_peer_err("%pK: Invalid Peer for Mac " QDF_MAC_ADDR_FMT, 8589 soc, QDF_MAC_ADDR_REF(peer_mac)); 8590 return QDF_STATUS_E_FAILURE; 8591 } 8592 8593 if (type >= cdp_peer_per_pkt_stats_min && 8594 type < cdp_peer_per_pkt_stats_max) { 8595 ret = dp_txrx_get_peer_per_pkt_stats_param(peer, type, buf); 8596 } else if (type >= cdp_peer_extd_stats_min && 8597 type < cdp_peer_extd_stats_max) { 8598 ret = dp_txrx_get_peer_extd_stats_param(peer, type, buf); 8599 } else { 8600 dp_err("%pK: Invalid stat type requested", soc); 8601 ret = QDF_STATUS_E_FAILURE; 8602 } 8603 8604 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 8605 8606 return ret; 8607 } 8608 8609 /** 8610 * dp_txrx_reset_peer_stats() - reset cdp_peer_stats for particular peer 8611 * @soc_hdl: soc handle 8612 * @vdev_id: id of vdev handle 8613 * @peer_mac: mac of DP_PEER handle 8614 * 8615 * Return: QDF_STATUS 8616 */ 8617 #ifdef WLAN_FEATURE_11BE_MLO 8618 static QDF_STATUS 8619 dp_txrx_reset_peer_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 8620 uint8_t *peer_mac) 8621 { 8622 QDF_STATUS status = QDF_STATUS_SUCCESS; 8623 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 8624 struct dp_peer *peer = 8625 dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 0, 8626 vdev_id, DP_MOD_ID_CDP); 8627 8628 if (!peer) 8629 return QDF_STATUS_E_FAILURE; 8630 8631 DP_STATS_CLR(peer); 8632 dp_txrx_peer_stats_clr(peer->txrx_peer); 8633 8634 if (IS_MLO_DP_MLD_PEER(peer)) { 8635 uint8_t i; 8636 struct dp_peer *link_peer; 8637 struct dp_soc *link_peer_soc; 8638 struct dp_mld_link_peers link_peers_info; 8639 8640 dp_get_link_peers_ref_from_mld_peer(soc, peer, 8641 &link_peers_info, 8642 DP_MOD_ID_CDP); 8643 for (i = 0; i < link_peers_info.num_links; i++) { 8644 link_peer = link_peers_info.link_peers[i]; 8645 link_peer_soc = link_peer->vdev->pdev->soc; 8646 8647 DP_STATS_CLR(link_peer); 8648 dp_monitor_peer_reset_stats(link_peer_soc, link_peer); 8649 } 8650 8651 dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); 8652 } else { 8653 dp_monitor_peer_reset_stats(soc, peer); 8654 } 8655 8656 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 8657 8658 return status; 8659 } 8660 #else 8661 static QDF_STATUS 8662 dp_txrx_reset_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, 8663 uint8_t *peer_mac) 8664 { 8665 QDF_STATUS status = QDF_STATUS_SUCCESS; 8666 struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, 8667 peer_mac, 0, vdev_id, 8668 DP_MOD_ID_CDP); 8669 8670 if (!peer) 8671 return QDF_STATUS_E_FAILURE; 8672 8673 DP_STATS_CLR(peer); 8674 dp_txrx_peer_stats_clr(peer->txrx_peer); 8675 dp_monitor_peer_reset_stats((struct dp_soc *)soc, peer); 8676 8677 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 8678 8679 return status; 8680 } 8681 #endif 8682 8683 /** 8684 * dp_txrx_get_vdev_stats() - Update buffer with cdp_vdev_stats 8685 * @soc_hdl: CDP SoC handle 8686 * @vdev_id: vdev Id 8687 * @buf: buffer for vdev stats 8688 * @is_aggregate: are aggregate stats being collected 8689 * 8690 * Return: QDF_STATUS 8691 */ 8692 QDF_STATUS 8693 dp_txrx_get_vdev_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 8694 void *buf, bool is_aggregate) 8695 { 8696 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 8697 struct cdp_vdev_stats *vdev_stats; 8698 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 8699 DP_MOD_ID_CDP); 8700 8701 if (!vdev) 8702 return QDF_STATUS_E_RESOURCES; 8703 8704 vdev_stats = (struct cdp_vdev_stats *)buf; 8705 8706 if (is_aggregate) { 8707 dp_aggregate_vdev_stats(vdev, buf); 8708 } else { 8709 qdf_mem_copy(vdev_stats, &vdev->stats, sizeof(vdev->stats)); 8710 } 8711 8712 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 8713 return QDF_STATUS_SUCCESS; 8714 } 8715 8716 /** 8717 * dp_get_total_per() - get total per 8718 * @soc: DP soc handle 8719 * @pdev_id: id of DP_PDEV handle 8720 * 8721 * Return: % error rate using retries per packet and success packets 8722 */ 8723 static int dp_get_total_per(struct cdp_soc_t *soc, uint8_t pdev_id) 8724 { 8725 struct dp_pdev *pdev = 8726 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 8727 pdev_id); 8728 8729 if (!pdev) 8730 return 0; 8731 8732 dp_aggregate_pdev_stats(pdev); 8733 if ((pdev->stats.tx.tx_success.num + pdev->stats.tx.retries) == 0) 8734 return 0; 8735 return qdf_do_div((pdev->stats.tx.retries * 100), 8736 ((pdev->stats.tx.tx_success.num) + (pdev->stats.tx.retries))); 8737 } 8738 8739 /** 8740 * dp_txrx_stats_publish() - publish pdev stats into a buffer 8741 * @soc: DP soc handle 8742 * @pdev_id: id of DP_PDEV handle 8743 * @buf: to hold pdev_stats 8744 * 8745 * Return: int 8746 */ 8747 static int 8748 dp_txrx_stats_publish(struct cdp_soc_t *soc, uint8_t pdev_id, 8749 struct cdp_stats_extd *buf) 8750 { 8751 struct cdp_txrx_stats_req req = {0,}; 8752 QDF_STATUS status; 8753 struct dp_pdev *pdev = 8754 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 8755 pdev_id); 8756 8757 if (!pdev) 8758 return TXRX_STATS_LEVEL_OFF; 8759 8760 if (pdev->pending_fw_stats_response) 8761 return TXRX_STATS_LEVEL_OFF; 8762 8763 dp_aggregate_pdev_stats(pdev); 8764 8765 pdev->pending_fw_stats_response = true; 8766 req.stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_TX; 8767 req.cookie_val = DBG_STATS_COOKIE_DP_STATS; 8768 pdev->fw_stats_tlv_bitmap_rcvd = 0; 8769 qdf_event_reset(&pdev->fw_stats_event); 8770 dp_h2t_ext_stats_msg_send(pdev, req.stats, req.param0, 8771 req.param1, req.param2, req.param3, 0, 8772 req.cookie_val, 0); 8773 8774 req.stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_RX; 8775 req.cookie_val = DBG_STATS_COOKIE_DP_STATS; 8776 dp_h2t_ext_stats_msg_send(pdev, req.stats, req.param0, 8777 req.param1, req.param2, req.param3, 0, 8778 req.cookie_val, 0); 8779 8780 status = 8781 qdf_wait_single_event(&pdev->fw_stats_event, DP_MAX_SLEEP_TIME); 8782 8783 if (status != QDF_STATUS_SUCCESS) { 8784 if (status == QDF_STATUS_E_TIMEOUT) 8785 qdf_debug("TIMEOUT_OCCURS"); 8786 pdev->pending_fw_stats_response = false; 8787 return TXRX_STATS_LEVEL_OFF; 8788 } 8789 qdf_mem_copy(buf, &pdev->stats, sizeof(struct cdp_pdev_stats)); 8790 pdev->pending_fw_stats_response = false; 8791 8792 return TXRX_STATS_LEVEL; 8793 } 8794 8795 /** 8796 * dp_get_obss_stats() - Get Pdev OBSS stats from Fw 8797 * @soc: DP soc handle 8798 * @pdev_id: id of DP_PDEV handle 8799 * @buf: to hold pdev obss stats 8800 * @req: Pointer to CDP TxRx stats 8801 * 8802 * Return: status 8803 */ 8804 static QDF_STATUS 8805 dp_get_obss_stats(struct cdp_soc_t *soc, uint8_t pdev_id, 8806 struct cdp_pdev_obss_pd_stats_tlv *buf, 8807 struct cdp_txrx_stats_req *req) 8808 { 8809 QDF_STATUS status; 8810 struct dp_pdev *pdev = 8811 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 8812 pdev_id); 8813 8814 if (!pdev) 8815 return QDF_STATUS_E_INVAL; 8816 8817 if (pdev->pending_fw_obss_stats_response) 8818 return QDF_STATUS_E_AGAIN; 8819 8820 pdev->pending_fw_obss_stats_response = true; 8821 req->stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_OBSS_PD_STATS; 8822 req->cookie_val = DBG_STATS_COOKIE_HTT_OBSS; 8823 qdf_event_reset(&pdev->fw_obss_stats_event); 8824 status = dp_h2t_ext_stats_msg_send(pdev, req->stats, req->param0, 8825 req->param1, req->param2, 8826 req->param3, 0, req->cookie_val, 8827 req->mac_id); 8828 if (QDF_IS_STATUS_ERROR(status)) { 8829 pdev->pending_fw_obss_stats_response = false; 8830 return status; 8831 } 8832 status = 8833 qdf_wait_single_event(&pdev->fw_obss_stats_event, 8834 DP_MAX_SLEEP_TIME); 8835 8836 if (status != QDF_STATUS_SUCCESS) { 8837 if (status == QDF_STATUS_E_TIMEOUT) 8838 qdf_debug("TIMEOUT_OCCURS"); 8839 pdev->pending_fw_obss_stats_response = false; 8840 return QDF_STATUS_E_TIMEOUT; 8841 } 8842 qdf_mem_copy(buf, &pdev->stats.htt_tx_pdev_stats.obss_pd_stats_tlv, 8843 sizeof(struct cdp_pdev_obss_pd_stats_tlv)); 8844 pdev->pending_fw_obss_stats_response = false; 8845 return status; 8846 } 8847 8848 /** 8849 * dp_clear_pdev_obss_pd_stats() - Clear pdev obss stats 8850 * @soc: DP soc handle 8851 * @pdev_id: id of DP_PDEV handle 8852 * @req: Pointer to CDP TxRx stats request mac_id will be 8853 * pre-filled and should not be overwritten 8854 * 8855 * Return: status 8856 */ 8857 static QDF_STATUS 8858 dp_clear_pdev_obss_pd_stats(struct cdp_soc_t *soc, uint8_t pdev_id, 8859 struct cdp_txrx_stats_req *req) 8860 { 8861 struct dp_pdev *pdev = 8862 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 8863 pdev_id); 8864 uint32_t cookie_val = DBG_STATS_COOKIE_DEFAULT; 8865 8866 if (!pdev) 8867 return QDF_STATUS_E_INVAL; 8868 8869 /* 8870 * For HTT_DBG_EXT_STATS_RESET command, FW need to config 8871 * from param0 to param3 according to below rule: 8872 * 8873 * PARAM: 8874 * - config_param0 : start_offset (stats type) 8875 * - config_param1 : stats bmask from start offset 8876 * - config_param2 : stats bmask from start offset + 32 8877 * - config_param3 : stats bmask from start offset + 64 8878 */ 8879 req->stats = (enum cdp_stats)HTT_DBG_EXT_STATS_RESET; 8880 req->param0 = HTT_DBG_EXT_STATS_PDEV_OBSS_PD_STATS; 8881 req->param1 = 0x00000001; 8882 8883 return dp_h2t_ext_stats_msg_send(pdev, req->stats, req->param0, 8884 req->param1, req->param2, req->param3, 0, 8885 cookie_val, req->mac_id); 8886 } 8887 8888 /** 8889 * dp_set_pdev_dscp_tid_map_wifi3() - update dscp tid map in pdev 8890 * @soc_handle: soc handle 8891 * @pdev_id: id of DP_PDEV handle 8892 * @map_id: ID of map that needs to be updated 8893 * @tos: index value in map 8894 * @tid: tid value passed by the user 8895 * 8896 * Return: QDF_STATUS 8897 */ 8898 static QDF_STATUS 8899 dp_set_pdev_dscp_tid_map_wifi3(struct cdp_soc_t *soc_handle, 8900 uint8_t pdev_id, 8901 uint8_t map_id, 8902 uint8_t tos, uint8_t tid) 8903 { 8904 uint8_t dscp; 8905 struct dp_soc *soc = (struct dp_soc *)soc_handle; 8906 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 8907 8908 if (!pdev) 8909 return QDF_STATUS_E_FAILURE; 8910 8911 dscp = (tos >> DP_IP_DSCP_SHIFT) & DP_IP_DSCP_MASK; 8912 pdev->dscp_tid_map[map_id][dscp] = tid; 8913 8914 if (map_id < soc->num_hw_dscp_tid_map) 8915 hal_tx_update_dscp_tid(soc->hal_soc, tid, 8916 map_id, dscp); 8917 else 8918 return QDF_STATUS_E_FAILURE; 8919 8920 return QDF_STATUS_SUCCESS; 8921 } 8922 8923 #ifdef WLAN_SYSFS_DP_STATS 8924 /** 8925 * dp_sysfs_event_trigger() - Trigger event to wait for firmware 8926 * stats request response. 8927 * @soc: soc handle 8928 * @cookie_val: cookie value 8929 * 8930 * Return: QDF_STATUS 8931 */ 8932 static QDF_STATUS 8933 dp_sysfs_event_trigger(struct dp_soc *soc, uint32_t cookie_val) 8934 { 8935 QDF_STATUS status = QDF_STATUS_SUCCESS; 8936 /* wait for firmware response for sysfs stats request */ 8937 if (cookie_val == DBG_SYSFS_STATS_COOKIE) { 8938 if (!soc) { 8939 dp_cdp_err("soc is NULL"); 8940 return QDF_STATUS_E_FAILURE; 8941 } 8942 /* wait for event completion */ 8943 status = qdf_wait_single_event(&soc->sysfs_config->sysfs_txrx_fw_request_done, 8944 WLAN_SYSFS_STAT_REQ_WAIT_MS); 8945 if (status == QDF_STATUS_SUCCESS) 8946 dp_cdp_info("sysfs_txrx_fw_request_done event completed"); 8947 else if (status == QDF_STATUS_E_TIMEOUT) 8948 dp_cdp_warn("sysfs_txrx_fw_request_done event expired"); 8949 else 8950 dp_cdp_warn("sysfs_txrx_fw_request_done event error code %d", status); 8951 } 8952 8953 return status; 8954 } 8955 #else /* WLAN_SYSFS_DP_STATS */ 8956 static QDF_STATUS 8957 dp_sysfs_event_trigger(struct dp_soc *soc, uint32_t cookie_val) 8958 { 8959 return QDF_STATUS_SUCCESS; 8960 } 8961 #endif /* WLAN_SYSFS_DP_STATS */ 8962 8963 /** 8964 * dp_fw_stats_process() - Process TXRX FW stats request. 8965 * @vdev: DP VDEV handle 8966 * @req: stats request 8967 * 8968 * Return: QDF_STATUS 8969 */ 8970 static QDF_STATUS 8971 dp_fw_stats_process(struct dp_vdev *vdev, 8972 struct cdp_txrx_stats_req *req) 8973 { 8974 struct dp_pdev *pdev = NULL; 8975 struct dp_soc *soc = NULL; 8976 uint32_t stats = req->stats; 8977 uint8_t mac_id = req->mac_id; 8978 uint32_t cookie_val = DBG_STATS_COOKIE_DEFAULT; 8979 8980 if (!vdev) { 8981 DP_TRACE(NONE, "VDEV not found"); 8982 return QDF_STATUS_E_FAILURE; 8983 } 8984 8985 pdev = vdev->pdev; 8986 if (!pdev) { 8987 DP_TRACE(NONE, "PDEV not found"); 8988 return QDF_STATUS_E_FAILURE; 8989 } 8990 8991 soc = pdev->soc; 8992 if (!soc) { 8993 DP_TRACE(NONE, "soc not found"); 8994 return QDF_STATUS_E_FAILURE; 8995 } 8996 8997 /* In case request is from host sysfs for displaying stats on console */ 8998 if (req->cookie_val == DBG_SYSFS_STATS_COOKIE) 8999 cookie_val = DBG_SYSFS_STATS_COOKIE; 9000 9001 /* 9002 * For HTT_DBG_EXT_STATS_RESET command, FW need to config 9003 * from param0 to param3 according to below rule: 9004 * 9005 * PARAM: 9006 * - config_param0 : start_offset (stats type) 9007 * - config_param1 : stats bmask from start offset 9008 * - config_param2 : stats bmask from start offset + 32 9009 * - config_param3 : stats bmask from start offset + 64 9010 */ 9011 if (req->stats == CDP_TXRX_STATS_0) { 9012 req->param0 = HTT_DBG_EXT_STATS_PDEV_TX; 9013 req->param1 = 0xFFFFFFFF; 9014 req->param2 = 0xFFFFFFFF; 9015 req->param3 = 0xFFFFFFFF; 9016 } else if (req->stats == (uint8_t)HTT_DBG_EXT_STATS_PDEV_TX_MU) { 9017 req->param0 = HTT_DBG_EXT_STATS_SET_VDEV_MASK(vdev->vdev_id); 9018 } 9019 9020 if (req->stats == (uint8_t)HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT) { 9021 dp_h2t_ext_stats_msg_send(pdev, 9022 HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, 9023 req->param0, req->param1, req->param2, 9024 req->param3, 0, cookie_val, 9025 mac_id); 9026 } else { 9027 dp_h2t_ext_stats_msg_send(pdev, stats, req->param0, 9028 req->param1, req->param2, req->param3, 9029 0, cookie_val, mac_id); 9030 } 9031 9032 dp_sysfs_event_trigger(soc, cookie_val); 9033 9034 return QDF_STATUS_SUCCESS; 9035 } 9036 9037 /** 9038 * dp_txrx_stats_request - function to map to firmware and host stats 9039 * @soc_handle: soc handle 9040 * @vdev_id: virtual device ID 9041 * @req: stats request 9042 * 9043 * Return: QDF_STATUS 9044 */ 9045 static 9046 QDF_STATUS dp_txrx_stats_request(struct cdp_soc_t *soc_handle, 9047 uint8_t vdev_id, 9048 struct cdp_txrx_stats_req *req) 9049 { 9050 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_handle); 9051 int host_stats; 9052 int fw_stats; 9053 enum cdp_stats stats; 9054 int num_stats; 9055 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 9056 DP_MOD_ID_CDP); 9057 QDF_STATUS status = QDF_STATUS_E_INVAL; 9058 9059 if (!vdev || !req) { 9060 dp_cdp_err("%pK: Invalid vdev/req instance", soc); 9061 status = QDF_STATUS_E_INVAL; 9062 goto fail0; 9063 } 9064 9065 if (req->mac_id >= WLAN_CFG_MAC_PER_TARGET) { 9066 dp_err("Invalid mac_id: %u request", req->mac_id); 9067 status = QDF_STATUS_E_INVAL; 9068 goto fail0; 9069 } 9070 9071 stats = req->stats; 9072 if (stats >= CDP_TXRX_MAX_STATS) { 9073 status = QDF_STATUS_E_INVAL; 9074 goto fail0; 9075 } 9076 9077 /* 9078 * DP_CURR_FW_STATS_AVAIL: no of FW stats currently available 9079 * has to be updated if new FW HTT stats added 9080 */ 9081 if (stats > CDP_TXRX_STATS_HTT_MAX) 9082 stats = stats + DP_CURR_FW_STATS_AVAIL - DP_HTT_DBG_EXT_STATS_MAX; 9083 9084 num_stats = QDF_ARRAY_SIZE(dp_stats_mapping_table); 9085 9086 if (stats >= num_stats) { 9087 dp_cdp_err("%pK : Invalid stats option: %d", soc, stats); 9088 status = QDF_STATUS_E_INVAL; 9089 goto fail0; 9090 } 9091 9092 req->stats = stats; 9093 fw_stats = dp_stats_mapping_table[stats][STATS_FW]; 9094 host_stats = dp_stats_mapping_table[stats][STATS_HOST]; 9095 9096 dp_info("stats: %u fw_stats_type: %d host_stats: %d", 9097 stats, fw_stats, host_stats); 9098 9099 if (fw_stats != TXRX_FW_STATS_INVALID) { 9100 /* update request with FW stats type */ 9101 req->stats = fw_stats; 9102 status = dp_fw_stats_process(vdev, req); 9103 } else if ((host_stats != TXRX_HOST_STATS_INVALID) && 9104 (host_stats <= TXRX_HOST_STATS_MAX)) 9105 status = dp_print_host_stats(vdev, req, soc); 9106 else 9107 dp_cdp_info("%pK: Wrong Input for TxRx Stats", soc); 9108 fail0: 9109 if (vdev) 9110 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9111 return status; 9112 } 9113 9114 /** 9115 * dp_soc_notify_asserted_soc() - API to notify asserted soc info 9116 * @psoc: CDP soc handle 9117 * 9118 * Return: QDF_STATUS 9119 */ 9120 static QDF_STATUS dp_soc_notify_asserted_soc(struct cdp_soc_t *psoc) 9121 { 9122 struct dp_soc *soc = (struct dp_soc *)psoc; 9123 9124 if (!soc) { 9125 dp_cdp_err("%pK: soc is NULL", soc); 9126 return QDF_STATUS_E_INVAL; 9127 } 9128 9129 return dp_umac_reset_notify_asserted_soc(soc); 9130 } 9131 9132 /** 9133 * dp_txrx_dump_stats() - Dump statistics 9134 * @psoc: CDP soc handle 9135 * @value: Statistics option 9136 * @level: verbosity level 9137 */ 9138 static QDF_STATUS dp_txrx_dump_stats(struct cdp_soc_t *psoc, uint16_t value, 9139 enum qdf_stats_verbosity_level level) 9140 { 9141 struct dp_soc *soc = 9142 (struct dp_soc *)psoc; 9143 QDF_STATUS status = QDF_STATUS_SUCCESS; 9144 9145 if (!soc) { 9146 dp_cdp_err("%pK: soc is NULL", soc); 9147 return QDF_STATUS_E_INVAL; 9148 } 9149 9150 switch (value) { 9151 case CDP_TXRX_PATH_STATS: 9152 dp_txrx_path_stats(soc); 9153 dp_print_soc_interrupt_stats(soc); 9154 dp_print_reg_write_stats(soc); 9155 dp_pdev_print_tx_delay_stats(soc); 9156 /* Dump usage watermark stats for core TX/RX SRNGs */ 9157 dp_dump_srng_high_wm_stats(soc, (1 << REO_DST)); 9158 if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) 9159 soc->cdp_soc.ol_ops->dp_print_fisa_stats( 9160 CDP_FISA_STATS_ID_ERR_STATS); 9161 break; 9162 9163 case CDP_RX_RING_STATS: 9164 dp_print_per_ring_stats(soc); 9165 break; 9166 9167 case CDP_TXRX_TSO_STATS: 9168 dp_print_tso_stats(soc, level); 9169 break; 9170 9171 case CDP_DUMP_TX_FLOW_POOL_INFO: 9172 if (level == QDF_STATS_VERBOSITY_LEVEL_HIGH) 9173 cdp_dump_flow_pool_info((struct cdp_soc_t *)soc); 9174 else 9175 dp_tx_dump_flow_pool_info_compact(soc); 9176 break; 9177 9178 case CDP_DP_NAPI_STATS: 9179 dp_print_napi_stats(soc); 9180 break; 9181 9182 case CDP_TXRX_DESC_STATS: 9183 /* TODO: NOT IMPLEMENTED */ 9184 break; 9185 9186 case CDP_DP_RX_FISA_STATS: 9187 if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) 9188 soc->cdp_soc.ol_ops->dp_print_fisa_stats( 9189 CDP_FISA_STATS_ID_DUMP_SW_FST); 9190 break; 9191 9192 case CDP_DP_SWLM_STATS: 9193 dp_print_swlm_stats(soc); 9194 break; 9195 9196 case CDP_DP_TX_HW_LATENCY_STATS: 9197 dp_pdev_print_tx_delay_stats(soc); 9198 break; 9199 9200 default: 9201 status = QDF_STATUS_E_INVAL; 9202 break; 9203 } 9204 9205 return status; 9206 9207 } 9208 9209 #ifdef WLAN_SYSFS_DP_STATS 9210 static 9211 void dp_sysfs_get_stat_type(struct dp_soc *soc, uint32_t *mac_id, 9212 uint32_t *stat_type) 9213 { 9214 qdf_spinlock_acquire(&soc->sysfs_config->rw_stats_lock); 9215 *stat_type = soc->sysfs_config->stat_type_requested; 9216 *mac_id = soc->sysfs_config->mac_id; 9217 9218 qdf_spinlock_release(&soc->sysfs_config->rw_stats_lock); 9219 } 9220 9221 static 9222 void dp_sysfs_update_config_buf_params(struct dp_soc *soc, 9223 uint32_t curr_len, 9224 uint32_t max_buf_len, 9225 char *buf) 9226 { 9227 qdf_spinlock_acquire(&soc->sysfs_config->sysfs_write_user_buffer); 9228 /* set sysfs_config parameters */ 9229 soc->sysfs_config->buf = buf; 9230 soc->sysfs_config->curr_buffer_length = curr_len; 9231 soc->sysfs_config->max_buffer_length = max_buf_len; 9232 qdf_spinlock_release(&soc->sysfs_config->sysfs_write_user_buffer); 9233 } 9234 9235 static 9236 QDF_STATUS dp_sysfs_fill_stats(ol_txrx_soc_handle soc_hdl, 9237 char *buf, uint32_t buf_size) 9238 { 9239 uint32_t mac_id = 0; 9240 uint32_t stat_type = 0; 9241 uint32_t fw_stats = 0; 9242 uint32_t host_stats = 0; 9243 enum cdp_stats stats; 9244 struct cdp_txrx_stats_req req; 9245 uint32_t num_stats; 9246 struct dp_soc *soc = NULL; 9247 9248 if (!soc_hdl) { 9249 dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); 9250 return QDF_STATUS_E_INVAL; 9251 } 9252 9253 soc = cdp_soc_t_to_dp_soc(soc_hdl); 9254 9255 if (!soc) { 9256 dp_cdp_err("%pK: soc is NULL", soc); 9257 return QDF_STATUS_E_INVAL; 9258 } 9259 9260 dp_sysfs_get_stat_type(soc, &mac_id, &stat_type); 9261 9262 stats = stat_type; 9263 if (stats >= CDP_TXRX_MAX_STATS) { 9264 dp_cdp_info("sysfs stat type requested is invalid"); 9265 return QDF_STATUS_E_INVAL; 9266 } 9267 /* 9268 * DP_CURR_FW_STATS_AVAIL: no of FW stats currently available 9269 * has to be updated if new FW HTT stats added 9270 */ 9271 if (stats > CDP_TXRX_MAX_STATS) 9272 stats = stats + DP_CURR_FW_STATS_AVAIL - DP_HTT_DBG_EXT_STATS_MAX; 9273 9274 num_stats = QDF_ARRAY_SIZE(dp_stats_mapping_table); 9275 9276 if (stats >= num_stats) { 9277 dp_cdp_err("%pK : Invalid stats option: %d, max num stats: %d", 9278 soc, stats, num_stats); 9279 return QDF_STATUS_E_INVAL; 9280 } 9281 9282 /* build request */ 9283 fw_stats = dp_stats_mapping_table[stats][STATS_FW]; 9284 host_stats = dp_stats_mapping_table[stats][STATS_HOST]; 9285 9286 req.stats = stat_type; 9287 req.mac_id = mac_id; 9288 /* request stats to be printed */ 9289 qdf_mutex_acquire(&soc->sysfs_config->sysfs_read_lock); 9290 9291 if (fw_stats != TXRX_FW_STATS_INVALID) { 9292 /* update request with FW stats type */ 9293 req.cookie_val = DBG_SYSFS_STATS_COOKIE; 9294 } else if ((host_stats != TXRX_HOST_STATS_INVALID) && 9295 (host_stats <= TXRX_HOST_STATS_MAX)) { 9296 req.cookie_val = DBG_STATS_COOKIE_DEFAULT; 9297 soc->sysfs_config->process_id = qdf_get_current_pid(); 9298 soc->sysfs_config->printing_mode = PRINTING_MODE_ENABLED; 9299 } 9300 9301 dp_sysfs_update_config_buf_params(soc, 0, buf_size, buf); 9302 9303 dp_txrx_stats_request(soc_hdl, mac_id, &req); 9304 soc->sysfs_config->process_id = 0; 9305 soc->sysfs_config->printing_mode = PRINTING_MODE_DISABLED; 9306 9307 dp_sysfs_update_config_buf_params(soc, 0, 0, NULL); 9308 9309 qdf_mutex_release(&soc->sysfs_config->sysfs_read_lock); 9310 return QDF_STATUS_SUCCESS; 9311 } 9312 9313 static 9314 QDF_STATUS dp_sysfs_set_stat_type(ol_txrx_soc_handle soc_hdl, 9315 uint32_t stat_type, uint32_t mac_id) 9316 { 9317 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9318 9319 if (!soc_hdl) { 9320 dp_cdp_err("%pK: soc is NULL", soc); 9321 return QDF_STATUS_E_INVAL; 9322 } 9323 9324 qdf_spinlock_acquire(&soc->sysfs_config->rw_stats_lock); 9325 9326 soc->sysfs_config->stat_type_requested = stat_type; 9327 soc->sysfs_config->mac_id = mac_id; 9328 9329 qdf_spinlock_release(&soc->sysfs_config->rw_stats_lock); 9330 9331 return QDF_STATUS_SUCCESS; 9332 } 9333 9334 static 9335 QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl) 9336 { 9337 struct dp_soc *soc; 9338 QDF_STATUS status; 9339 9340 if (!soc_hdl) { 9341 dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); 9342 return QDF_STATUS_E_INVAL; 9343 } 9344 9345 soc = soc_hdl; 9346 9347 soc->sysfs_config = qdf_mem_malloc(sizeof(struct sysfs_stats_config)); 9348 if (!soc->sysfs_config) { 9349 dp_cdp_err("failed to allocate memory for sysfs_config no memory"); 9350 return QDF_STATUS_E_NOMEM; 9351 } 9352 9353 status = qdf_event_create(&soc->sysfs_config->sysfs_txrx_fw_request_done); 9354 /* create event for fw stats request from sysfs */ 9355 if (status != QDF_STATUS_SUCCESS) { 9356 dp_cdp_err("failed to create event sysfs_txrx_fw_request_done"); 9357 qdf_mem_free(soc->sysfs_config); 9358 soc->sysfs_config = NULL; 9359 return QDF_STATUS_E_FAILURE; 9360 } 9361 9362 qdf_spinlock_create(&soc->sysfs_config->rw_stats_lock); 9363 qdf_mutex_create(&soc->sysfs_config->sysfs_read_lock); 9364 qdf_spinlock_create(&soc->sysfs_config->sysfs_write_user_buffer); 9365 9366 return QDF_STATUS_SUCCESS; 9367 } 9368 9369 static 9370 QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl) 9371 { 9372 struct dp_soc *soc; 9373 QDF_STATUS status; 9374 9375 if (!soc_hdl) { 9376 dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); 9377 return QDF_STATUS_E_INVAL; 9378 } 9379 9380 soc = soc_hdl; 9381 if (!soc->sysfs_config) { 9382 dp_cdp_err("soc->sysfs_config is NULL"); 9383 return QDF_STATUS_E_FAILURE; 9384 } 9385 9386 status = qdf_event_destroy(&soc->sysfs_config->sysfs_txrx_fw_request_done); 9387 if (status != QDF_STATUS_SUCCESS) 9388 dp_cdp_err("Failed to destroy event sysfs_txrx_fw_request_done"); 9389 9390 qdf_mutex_destroy(&soc->sysfs_config->sysfs_read_lock); 9391 qdf_spinlock_destroy(&soc->sysfs_config->rw_stats_lock); 9392 qdf_spinlock_destroy(&soc->sysfs_config->sysfs_write_user_buffer); 9393 9394 qdf_mem_free(soc->sysfs_config); 9395 9396 return QDF_STATUS_SUCCESS; 9397 } 9398 9399 #else /* WLAN_SYSFS_DP_STATS */ 9400 9401 static 9402 QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl) 9403 { 9404 return QDF_STATUS_SUCCESS; 9405 } 9406 9407 static 9408 QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl) 9409 { 9410 return QDF_STATUS_SUCCESS; 9411 } 9412 #endif /* WLAN_SYSFS_DP_STATS */ 9413 9414 /** 9415 * dp_txrx_clear_dump_stats() - clear dumpStats 9416 * @soc_hdl: soc handle 9417 * @pdev_id: pdev ID 9418 * @value: stats option 9419 * 9420 * Return: 0 - Success, non-zero - failure 9421 */ 9422 static 9423 QDF_STATUS dp_txrx_clear_dump_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 9424 uint8_t value) 9425 { 9426 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9427 QDF_STATUS status = QDF_STATUS_SUCCESS; 9428 9429 if (!soc) { 9430 dp_err("soc is NULL"); 9431 return QDF_STATUS_E_INVAL; 9432 } 9433 9434 switch (value) { 9435 case CDP_TXRX_TSO_STATS: 9436 dp_txrx_clear_tso_stats(soc); 9437 break; 9438 9439 case CDP_DP_TX_HW_LATENCY_STATS: 9440 dp_pdev_clear_tx_delay_stats(soc); 9441 break; 9442 9443 default: 9444 status = QDF_STATUS_E_INVAL; 9445 break; 9446 } 9447 9448 return status; 9449 } 9450 9451 static QDF_STATUS 9452 dp_txrx_get_interface_stats(struct cdp_soc_t *soc_hdl, 9453 uint8_t vdev_id, 9454 void *buf, 9455 bool is_aggregate) 9456 { 9457 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9458 9459 if (soc && soc->arch_ops.dp_get_interface_stats) 9460 return soc->arch_ops.dp_get_interface_stats(soc_hdl, 9461 vdev_id, 9462 buf, 9463 is_aggregate); 9464 return QDF_STATUS_E_FAILURE; 9465 } 9466 9467 #ifdef QCA_LL_TX_FLOW_CONTROL_V2 9468 /** 9469 * dp_update_flow_control_parameters() - API to store datapath 9470 * config parameters 9471 * @soc: soc handle 9472 * @params: ini parameter handle 9473 * 9474 * Return: void 9475 */ 9476 static inline 9477 void dp_update_flow_control_parameters(struct dp_soc *soc, 9478 struct cdp_config_params *params) 9479 { 9480 soc->wlan_cfg_ctx->tx_flow_stop_queue_threshold = 9481 params->tx_flow_stop_queue_threshold; 9482 soc->wlan_cfg_ctx->tx_flow_start_queue_offset = 9483 params->tx_flow_start_queue_offset; 9484 } 9485 #else 9486 static inline 9487 void dp_update_flow_control_parameters(struct dp_soc *soc, 9488 struct cdp_config_params *params) 9489 { 9490 } 9491 #endif 9492 9493 #ifdef WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT 9494 /* Max packet limit for TX Comp packet loop (dp_tx_comp_handler) */ 9495 #define DP_TX_COMP_LOOP_PKT_LIMIT_MAX 1024 9496 9497 /* Max packet limit for RX REAP Loop (dp_rx_process) */ 9498 #define DP_RX_REAP_LOOP_PKT_LIMIT_MAX 1024 9499 9500 static 9501 void dp_update_rx_soft_irq_limit_params(struct dp_soc *soc, 9502 struct cdp_config_params *params) 9503 { 9504 soc->wlan_cfg_ctx->tx_comp_loop_pkt_limit = 9505 params->tx_comp_loop_pkt_limit; 9506 9507 if (params->tx_comp_loop_pkt_limit < DP_TX_COMP_LOOP_PKT_LIMIT_MAX) 9508 soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check = true; 9509 else 9510 soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check = false; 9511 9512 soc->wlan_cfg_ctx->rx_reap_loop_pkt_limit = 9513 params->rx_reap_loop_pkt_limit; 9514 9515 if (params->rx_reap_loop_pkt_limit < DP_RX_REAP_LOOP_PKT_LIMIT_MAX) 9516 soc->wlan_cfg_ctx->rx_enable_eol_data_check = true; 9517 else 9518 soc->wlan_cfg_ctx->rx_enable_eol_data_check = false; 9519 9520 soc->wlan_cfg_ctx->rx_hp_oos_update_limit = 9521 params->rx_hp_oos_update_limit; 9522 9523 dp_info("tx_comp_loop_pkt_limit %u tx_comp_enable_eol_data_check %u rx_reap_loop_pkt_limit %u rx_enable_eol_data_check %u rx_hp_oos_update_limit %u", 9524 soc->wlan_cfg_ctx->tx_comp_loop_pkt_limit, 9525 soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check, 9526 soc->wlan_cfg_ctx->rx_reap_loop_pkt_limit, 9527 soc->wlan_cfg_ctx->rx_enable_eol_data_check, 9528 soc->wlan_cfg_ctx->rx_hp_oos_update_limit); 9529 } 9530 9531 #else 9532 static inline 9533 void dp_update_rx_soft_irq_limit_params(struct dp_soc *soc, 9534 struct cdp_config_params *params) 9535 { } 9536 9537 #endif /* WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT */ 9538 9539 /** 9540 * dp_update_config_parameters() - API to store datapath 9541 * config parameters 9542 * @psoc: soc handle 9543 * @params: ini parameter handle 9544 * 9545 * Return: status 9546 */ 9547 static 9548 QDF_STATUS dp_update_config_parameters(struct cdp_soc *psoc, 9549 struct cdp_config_params *params) 9550 { 9551 struct dp_soc *soc = (struct dp_soc *)psoc; 9552 9553 if (!(soc)) { 9554 dp_cdp_err("%pK: Invalid handle", soc); 9555 return QDF_STATUS_E_INVAL; 9556 } 9557 9558 soc->wlan_cfg_ctx->tso_enabled = params->tso_enable; 9559 soc->wlan_cfg_ctx->lro_enabled = params->lro_enable; 9560 soc->wlan_cfg_ctx->rx_hash = params->flow_steering_enable; 9561 soc->wlan_cfg_ctx->p2p_tcp_udp_checksumoffload = 9562 params->p2p_tcp_udp_checksumoffload; 9563 soc->wlan_cfg_ctx->nan_tcp_udp_checksumoffload = 9564 params->nan_tcp_udp_checksumoffload; 9565 soc->wlan_cfg_ctx->tcp_udp_checksumoffload = 9566 params->tcp_udp_checksumoffload; 9567 soc->wlan_cfg_ctx->napi_enabled = params->napi_enable; 9568 soc->wlan_cfg_ctx->ipa_enabled = params->ipa_enable; 9569 soc->wlan_cfg_ctx->gro_enabled = params->gro_enable; 9570 9571 dp_update_rx_soft_irq_limit_params(soc, params); 9572 dp_update_flow_control_parameters(soc, params); 9573 9574 return QDF_STATUS_SUCCESS; 9575 } 9576 9577 static struct cdp_wds_ops dp_ops_wds = { 9578 .vdev_set_wds = dp_vdev_set_wds, 9579 #ifdef WDS_VENDOR_EXTENSION 9580 .txrx_set_wds_rx_policy = dp_txrx_set_wds_rx_policy, 9581 .txrx_wds_peer_tx_policy_update = dp_txrx_peer_wds_tx_policy_update, 9582 #endif 9583 }; 9584 9585 /** 9586 * dp_txrx_data_tx_cb_set() - set the callback for non standard tx 9587 * @soc_hdl: datapath soc handle 9588 * @vdev_id: virtual interface id 9589 * @callback: callback function 9590 * @ctxt: callback context 9591 * 9592 */ 9593 static void 9594 dp_txrx_data_tx_cb_set(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 9595 ol_txrx_data_tx_cb callback, void *ctxt) 9596 { 9597 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9598 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 9599 DP_MOD_ID_CDP); 9600 9601 if (!vdev) 9602 return; 9603 9604 vdev->tx_non_std_data_callback.func = callback; 9605 vdev->tx_non_std_data_callback.ctxt = ctxt; 9606 9607 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9608 } 9609 9610 /** 9611 * dp_pdev_get_dp_txrx_handle() - get dp handle from pdev 9612 * @soc: datapath soc handle 9613 * @pdev_id: id of datapath pdev handle 9614 * 9615 * Return: opaque pointer to dp txrx handle 9616 */ 9617 static void *dp_pdev_get_dp_txrx_handle(struct cdp_soc_t *soc, uint8_t pdev_id) 9618 { 9619 struct dp_pdev *pdev = 9620 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 9621 pdev_id); 9622 if (qdf_unlikely(!pdev)) 9623 return NULL; 9624 9625 return pdev->dp_txrx_handle; 9626 } 9627 9628 /** 9629 * dp_pdev_set_dp_txrx_handle() - set dp handle in pdev 9630 * @soc: datapath soc handle 9631 * @pdev_id: id of datapath pdev handle 9632 * @dp_txrx_hdl: opaque pointer for dp_txrx_handle 9633 * 9634 * Return: void 9635 */ 9636 static void 9637 dp_pdev_set_dp_txrx_handle(struct cdp_soc_t *soc, uint8_t pdev_id, 9638 void *dp_txrx_hdl) 9639 { 9640 struct dp_pdev *pdev = 9641 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 9642 pdev_id); 9643 9644 if (!pdev) 9645 return; 9646 9647 pdev->dp_txrx_handle = dp_txrx_hdl; 9648 } 9649 9650 /** 9651 * dp_vdev_get_dp_ext_handle() - get dp handle from vdev 9652 * @soc_hdl: datapath soc handle 9653 * @vdev_id: vdev id 9654 * 9655 * Return: opaque pointer to dp txrx handle 9656 */ 9657 static void *dp_vdev_get_dp_ext_handle(ol_txrx_soc_handle soc_hdl, 9658 uint8_t vdev_id) 9659 { 9660 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9661 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 9662 DP_MOD_ID_CDP); 9663 void *dp_ext_handle; 9664 9665 if (!vdev) 9666 return NULL; 9667 dp_ext_handle = vdev->vdev_dp_ext_handle; 9668 9669 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9670 return dp_ext_handle; 9671 } 9672 9673 /** 9674 * dp_vdev_set_dp_ext_handle() - set dp handle in vdev 9675 * @soc_hdl: datapath soc handle 9676 * @vdev_id: vdev id 9677 * @size: size of advance dp handle 9678 * 9679 * Return: QDF_STATUS 9680 */ 9681 static QDF_STATUS 9682 dp_vdev_set_dp_ext_handle(ol_txrx_soc_handle soc_hdl, uint8_t vdev_id, 9683 uint16_t size) 9684 { 9685 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9686 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 9687 DP_MOD_ID_CDP); 9688 void *dp_ext_handle; 9689 9690 if (!vdev) 9691 return QDF_STATUS_E_FAILURE; 9692 9693 dp_ext_handle = qdf_mem_malloc(size); 9694 9695 if (!dp_ext_handle) { 9696 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9697 return QDF_STATUS_E_FAILURE; 9698 } 9699 9700 vdev->vdev_dp_ext_handle = dp_ext_handle; 9701 9702 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9703 return QDF_STATUS_SUCCESS; 9704 } 9705 9706 /** 9707 * dp_vdev_inform_ll_conn() - Inform vdev to add/delete a latency critical 9708 * connection for this vdev 9709 * @soc_hdl: CDP soc handle 9710 * @vdev_id: vdev ID 9711 * @action: Add/Delete action 9712 * 9713 * Return: QDF_STATUS. 9714 */ 9715 static QDF_STATUS 9716 dp_vdev_inform_ll_conn(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 9717 enum vdev_ll_conn_actions action) 9718 { 9719 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9720 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 9721 DP_MOD_ID_CDP); 9722 9723 if (!vdev) { 9724 dp_err("LL connection action for invalid vdev %d", vdev_id); 9725 return QDF_STATUS_E_FAILURE; 9726 } 9727 9728 switch (action) { 9729 case CDP_VDEV_LL_CONN_ADD: 9730 vdev->num_latency_critical_conn++; 9731 break; 9732 9733 case CDP_VDEV_LL_CONN_DEL: 9734 vdev->num_latency_critical_conn--; 9735 break; 9736 9737 default: 9738 dp_err("LL connection action invalid %d", action); 9739 break; 9740 } 9741 9742 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 9743 return QDF_STATUS_SUCCESS; 9744 } 9745 9746 #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR 9747 /** 9748 * dp_soc_set_swlm_enable() - Enable/Disable SWLM if initialized. 9749 * @soc_hdl: CDP Soc handle 9750 * @value: Enable/Disable value 9751 * 9752 * Return: QDF_STATUS 9753 */ 9754 static QDF_STATUS dp_soc_set_swlm_enable(struct cdp_soc_t *soc_hdl, 9755 uint8_t value) 9756 { 9757 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9758 9759 if (!soc->swlm.is_init) { 9760 dp_err("SWLM is not initialized"); 9761 return QDF_STATUS_E_FAILURE; 9762 } 9763 9764 soc->swlm.is_enabled = !!value; 9765 9766 return QDF_STATUS_SUCCESS; 9767 } 9768 9769 /** 9770 * dp_soc_is_swlm_enabled() - Check if SWLM is enabled. 9771 * @soc_hdl: CDP Soc handle 9772 * 9773 * Return: QDF_STATUS 9774 */ 9775 static uint8_t dp_soc_is_swlm_enabled(struct cdp_soc_t *soc_hdl) 9776 { 9777 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 9778 9779 return soc->swlm.is_enabled; 9780 } 9781 #endif 9782 9783 /** 9784 * dp_soc_get_dp_txrx_handle() - get context for external-dp from dp soc 9785 * @soc_handle: datapath soc handle 9786 * 9787 * Return: opaque pointer to external dp (non-core DP) 9788 */ 9789 static void *dp_soc_get_dp_txrx_handle(struct cdp_soc *soc_handle) 9790 { 9791 struct dp_soc *soc = (struct dp_soc *)soc_handle; 9792 9793 return soc->external_txrx_handle; 9794 } 9795 9796 /** 9797 * dp_soc_set_dp_txrx_handle() - set external dp handle in soc 9798 * @soc_handle: datapath soc handle 9799 * @txrx_handle: opaque pointer to external dp (non-core DP) 9800 * 9801 * Return: void 9802 */ 9803 static void 9804 dp_soc_set_dp_txrx_handle(struct cdp_soc *soc_handle, void *txrx_handle) 9805 { 9806 struct dp_soc *soc = (struct dp_soc *)soc_handle; 9807 9808 soc->external_txrx_handle = txrx_handle; 9809 } 9810 9811 /** 9812 * dp_soc_map_pdev_to_lmac() - Save pdev_id to lmac_id mapping 9813 * @soc_hdl: datapath soc handle 9814 * @pdev_id: id of the datapath pdev handle 9815 * @lmac_id: lmac id 9816 * 9817 * Return: QDF_STATUS 9818 */ 9819 static QDF_STATUS 9820 dp_soc_map_pdev_to_lmac 9821 (struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 9822 uint32_t lmac_id) 9823 { 9824 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 9825 9826 wlan_cfg_set_hw_mac_idx(soc->wlan_cfg_ctx, 9827 pdev_id, 9828 lmac_id); 9829 9830 /*Set host PDEV ID for lmac_id*/ 9831 wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, 9832 pdev_id, 9833 lmac_id); 9834 9835 return QDF_STATUS_SUCCESS; 9836 } 9837 9838 /** 9839 * dp_soc_handle_pdev_mode_change() - Update pdev to lmac mapping 9840 * @soc_hdl: datapath soc handle 9841 * @pdev_id: id of the datapath pdev handle 9842 * @lmac_id: lmac id 9843 * 9844 * In the event of a dynamic mode change, update the pdev to lmac mapping 9845 * 9846 * Return: QDF_STATUS 9847 */ 9848 static QDF_STATUS 9849 dp_soc_handle_pdev_mode_change 9850 (struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 9851 uint32_t lmac_id) 9852 { 9853 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 9854 struct dp_vdev *vdev = NULL; 9855 uint8_t hw_pdev_id, mac_id; 9856 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, 9857 pdev_id); 9858 int nss_config = wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx); 9859 9860 if (qdf_unlikely(!pdev)) 9861 return QDF_STATUS_E_FAILURE; 9862 9863 pdev->lmac_id = lmac_id; 9864 pdev->target_pdev_id = 9865 dp_calculate_target_pdev_id_from_host_pdev_id(soc, pdev_id); 9866 dp_info("mode change %d %d", pdev->pdev_id, pdev->lmac_id); 9867 9868 /*Set host PDEV ID for lmac_id*/ 9869 wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, 9870 pdev->pdev_id, 9871 lmac_id); 9872 9873 hw_pdev_id = 9874 dp_get_target_pdev_id_for_host_pdev_id(soc, 9875 pdev->pdev_id); 9876 9877 /* 9878 * When NSS offload is enabled, send pdev_id->lmac_id 9879 * and pdev_id to hw_pdev_id to NSS FW 9880 */ 9881 if (nss_config) { 9882 mac_id = pdev->lmac_id; 9883 if (soc->cdp_soc.ol_ops->pdev_update_lmac_n_target_pdev_id) 9884 soc->cdp_soc.ol_ops-> 9885 pdev_update_lmac_n_target_pdev_id( 9886 soc->ctrl_psoc, 9887 &pdev_id, &mac_id, &hw_pdev_id); 9888 } 9889 9890 qdf_spin_lock_bh(&pdev->vdev_list_lock); 9891 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 9892 DP_TX_TCL_METADATA_PDEV_ID_SET(vdev->htt_tcl_metadata, 9893 hw_pdev_id); 9894 vdev->lmac_id = pdev->lmac_id; 9895 } 9896 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 9897 9898 return QDF_STATUS_SUCCESS; 9899 } 9900 9901 /** 9902 * dp_soc_set_pdev_status_down() - set pdev down/up status 9903 * @soc: datapath soc handle 9904 * @pdev_id: id of datapath pdev handle 9905 * @is_pdev_down: pdev down/up status 9906 * 9907 * Return: QDF_STATUS 9908 */ 9909 static QDF_STATUS 9910 dp_soc_set_pdev_status_down(struct cdp_soc_t *soc, uint8_t pdev_id, 9911 bool is_pdev_down) 9912 { 9913 struct dp_pdev *pdev = 9914 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 9915 pdev_id); 9916 if (!pdev) 9917 return QDF_STATUS_E_FAILURE; 9918 9919 pdev->is_pdev_down = is_pdev_down; 9920 return QDF_STATUS_SUCCESS; 9921 } 9922 9923 /** 9924 * dp_get_cfg_capabilities() - get dp capabilities 9925 * @soc_handle: datapath soc handle 9926 * @dp_caps: enum for dp capabilities 9927 * 9928 * Return: bool to determine if dp caps is enabled 9929 */ 9930 static bool 9931 dp_get_cfg_capabilities(struct cdp_soc_t *soc_handle, 9932 enum cdp_capabilities dp_caps) 9933 { 9934 struct dp_soc *soc = (struct dp_soc *)soc_handle; 9935 9936 return wlan_cfg_get_dp_caps(soc->wlan_cfg_ctx, dp_caps); 9937 } 9938 9939 #ifdef FEATURE_AST 9940 static QDF_STATUS 9941 dp_peer_teardown_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 9942 uint8_t *peer_mac) 9943 { 9944 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 9945 QDF_STATUS status = QDF_STATUS_SUCCESS; 9946 struct dp_peer *peer = 9947 dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, 9948 DP_MOD_ID_CDP); 9949 9950 /* Peer can be null for monitor vap mac address */ 9951 if (!peer) { 9952 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 9953 "%s: Invalid peer\n", __func__); 9954 return QDF_STATUS_E_FAILURE; 9955 } 9956 9957 dp_peer_update_state(soc, peer, DP_PEER_STATE_LOGICAL_DELETE); 9958 9959 qdf_spin_lock_bh(&soc->ast_lock); 9960 dp_peer_send_wds_disconnect(soc, peer); 9961 dp_peer_delete_ast_entries(soc, peer); 9962 qdf_spin_unlock_bh(&soc->ast_lock); 9963 9964 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 9965 return status; 9966 } 9967 #endif 9968 9969 #ifndef WLAN_SUPPORT_RX_TAG_STATISTICS 9970 /** 9971 * dp_dump_pdev_rx_protocol_tag_stats - dump the number of packets tagged for 9972 * given protocol type (RX_PROTOCOL_TAG_ALL indicates for all protocol) 9973 * @soc: cdp_soc handle 9974 * @pdev_id: id of cdp_pdev handle 9975 * @protocol_type: protocol type for which stats should be displayed 9976 * 9977 * Return: none 9978 */ 9979 static inline void 9980 dp_dump_pdev_rx_protocol_tag_stats(struct cdp_soc_t *soc, uint8_t pdev_id, 9981 uint16_t protocol_type) 9982 { 9983 } 9984 #endif /* WLAN_SUPPORT_RX_TAG_STATISTICS */ 9985 9986 #ifndef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG 9987 /** 9988 * dp_update_pdev_rx_protocol_tag() - Add/remove a protocol tag that should be 9989 * applied to the desired protocol type packets 9990 * @soc: soc handle 9991 * @pdev_id: id of cdp_pdev handle 9992 * @enable_rx_protocol_tag: bitmask that indicates what protocol types 9993 * are enabled for tagging. zero indicates disable feature, non-zero indicates 9994 * enable feature 9995 * @protocol_type: new protocol type for which the tag is being added 9996 * @tag: user configured tag for the new protocol 9997 * 9998 * Return: Success 9999 */ 10000 static inline QDF_STATUS 10001 dp_update_pdev_rx_protocol_tag(struct cdp_soc_t *soc, uint8_t pdev_id, 10002 uint32_t enable_rx_protocol_tag, 10003 uint16_t protocol_type, 10004 uint16_t tag) 10005 { 10006 return QDF_STATUS_SUCCESS; 10007 } 10008 #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG */ 10009 10010 #ifndef WLAN_SUPPORT_RX_FLOW_TAG 10011 /** 10012 * dp_set_rx_flow_tag() - add/delete a flow 10013 * @cdp_soc: CDP soc handle 10014 * @pdev_id: id of cdp_pdev handle 10015 * @flow_info: flow tuple that is to be added to/deleted from flow search table 10016 * 10017 * Return: Success 10018 */ 10019 static inline QDF_STATUS 10020 dp_set_rx_flow_tag(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, 10021 struct cdp_rx_flow_info *flow_info) 10022 { 10023 return QDF_STATUS_SUCCESS; 10024 } 10025 /** 10026 * dp_dump_rx_flow_tag_stats() - dump the number of packets tagged for 10027 * given flow 5-tuple 10028 * @cdp_soc: soc handle 10029 * @pdev_id: id of cdp_pdev handle 10030 * @flow_info: flow 5-tuple for which stats should be displayed 10031 * 10032 * Return: Success 10033 */ 10034 static inline QDF_STATUS 10035 dp_dump_rx_flow_tag_stats(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, 10036 struct cdp_rx_flow_info *flow_info) 10037 { 10038 return QDF_STATUS_SUCCESS; 10039 } 10040 #endif /* WLAN_SUPPORT_RX_FLOW_TAG */ 10041 10042 static QDF_STATUS dp_peer_map_attach_wifi3(struct cdp_soc_t *soc_hdl, 10043 uint32_t max_peers, 10044 uint32_t max_ast_index, 10045 uint8_t peer_map_unmap_versions) 10046 { 10047 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10048 QDF_STATUS status; 10049 10050 soc->max_peers = max_peers; 10051 10052 wlan_cfg_set_max_ast_idx(soc->wlan_cfg_ctx, max_ast_index); 10053 10054 status = soc->arch_ops.txrx_peer_map_attach(soc); 10055 if (!QDF_IS_STATUS_SUCCESS(status)) { 10056 dp_err("failure in allocating peer tables"); 10057 return QDF_STATUS_E_FAILURE; 10058 } 10059 10060 dp_info("max_peers %u, calculated max_peers %u max_ast_index: %u", 10061 max_peers, soc->max_peer_id, max_ast_index); 10062 10063 status = dp_peer_find_attach(soc); 10064 if (!QDF_IS_STATUS_SUCCESS(status)) { 10065 dp_err("Peer find attach failure"); 10066 goto fail; 10067 } 10068 10069 soc->peer_map_unmap_versions = peer_map_unmap_versions; 10070 soc->peer_map_attach_success = TRUE; 10071 10072 return QDF_STATUS_SUCCESS; 10073 fail: 10074 soc->arch_ops.txrx_peer_map_detach(soc); 10075 10076 return status; 10077 } 10078 10079 static QDF_STATUS dp_soc_set_param(struct cdp_soc_t *soc_hdl, 10080 enum cdp_soc_param_t param, 10081 uint32_t value) 10082 { 10083 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10084 10085 switch (param) { 10086 case DP_SOC_PARAM_MSDU_EXCEPTION_DESC: 10087 soc->num_msdu_exception_desc = value; 10088 dp_info("num_msdu exception_desc %u", 10089 value); 10090 break; 10091 case DP_SOC_PARAM_CMEM_FSE_SUPPORT: 10092 if (wlan_cfg_is_fst_in_cmem_enabled(soc->wlan_cfg_ctx)) 10093 soc->fst_in_cmem = !!value; 10094 dp_info("FW supports CMEM FSE %u", value); 10095 break; 10096 case DP_SOC_PARAM_MAX_AST_AGEOUT: 10097 soc->max_ast_ageout_count = value; 10098 dp_info("Max ast ageout count %u", soc->max_ast_ageout_count); 10099 break; 10100 case DP_SOC_PARAM_EAPOL_OVER_CONTROL_PORT: 10101 soc->eapol_over_control_port = value; 10102 dp_info("Eapol over control_port:%d", 10103 soc->eapol_over_control_port); 10104 break; 10105 case DP_SOC_PARAM_MULTI_PEER_GRP_CMD_SUPPORT: 10106 soc->multi_peer_grp_cmd_supported = value; 10107 dp_info("Multi Peer group command support:%d", 10108 soc->multi_peer_grp_cmd_supported); 10109 break; 10110 case DP_SOC_PARAM_RSSI_DBM_CONV_SUPPORT: 10111 soc->features.rssi_dbm_conv_support = value; 10112 dp_info("Rssi dbm conversion support:%u", 10113 soc->features.rssi_dbm_conv_support); 10114 break; 10115 case DP_SOC_PARAM_UMAC_HW_RESET_SUPPORT: 10116 soc->features.umac_hw_reset_support = value; 10117 dp_info("UMAC HW reset support :%u", 10118 soc->features.umac_hw_reset_support); 10119 break; 10120 default: 10121 dp_info("not handled param %d ", param); 10122 break; 10123 } 10124 10125 return QDF_STATUS_SUCCESS; 10126 } 10127 10128 static void dp_soc_set_rate_stats_ctx(struct cdp_soc_t *soc_handle, 10129 void *stats_ctx) 10130 { 10131 struct dp_soc *soc = (struct dp_soc *)soc_handle; 10132 10133 soc->rate_stats_ctx = (struct cdp_soc_rate_stats_ctx *)stats_ctx; 10134 } 10135 10136 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 10137 /** 10138 * dp_peer_flush_rate_stats_req() - Flush peer rate stats 10139 * @soc: Datapath SOC handle 10140 * @peer: Datapath peer 10141 * @arg: argument to iter function 10142 * 10143 * Return: QDF_STATUS 10144 */ 10145 static void 10146 dp_peer_flush_rate_stats_req(struct dp_soc *soc, struct dp_peer *peer, 10147 void *arg) 10148 { 10149 /* Skip self peer */ 10150 if (!qdf_mem_cmp(peer->mac_addr.raw, peer->vdev->mac_addr.raw, 10151 QDF_MAC_ADDR_SIZE)) 10152 return; 10153 10154 dp_wdi_event_handler( 10155 WDI_EVENT_FLUSH_RATE_STATS_REQ, 10156 soc, dp_monitor_peer_get_peerstats_ctx(soc, peer), 10157 peer->peer_id, 10158 WDI_NO_VAL, peer->vdev->pdev->pdev_id); 10159 } 10160 10161 /** 10162 * dp_flush_rate_stats_req() - Flush peer rate stats in pdev 10163 * @soc_hdl: Datapath SOC handle 10164 * @pdev_id: pdev_id 10165 * 10166 * Return: QDF_STATUS 10167 */ 10168 static QDF_STATUS dp_flush_rate_stats_req(struct cdp_soc_t *soc_hdl, 10169 uint8_t pdev_id) 10170 { 10171 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10172 struct dp_pdev *pdev = 10173 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 10174 pdev_id); 10175 if (!pdev) 10176 return QDF_STATUS_E_FAILURE; 10177 10178 dp_pdev_iterate_peer(pdev, dp_peer_flush_rate_stats_req, NULL, 10179 DP_MOD_ID_CDP); 10180 10181 return QDF_STATUS_SUCCESS; 10182 } 10183 #else 10184 static inline QDF_STATUS 10185 dp_flush_rate_stats_req(struct cdp_soc_t *soc_hdl, 10186 uint8_t pdev_id) 10187 { 10188 return QDF_STATUS_SUCCESS; 10189 } 10190 #endif 10191 10192 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 10193 #ifdef WLAN_FEATURE_11BE_MLO 10194 /** 10195 * dp_get_peer_extd_rate_link_stats() - function to get peer 10196 * extended rate and link stats 10197 * @soc_hdl: dp soc handler 10198 * @mac_addr: mac address of peer 10199 * 10200 * Return: QDF_STATUS 10201 */ 10202 static QDF_STATUS 10203 dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) 10204 { 10205 uint8_t i; 10206 struct dp_peer *link_peer; 10207 struct dp_soc *link_peer_soc; 10208 struct dp_mld_link_peers link_peers_info; 10209 struct dp_peer *peer = NULL; 10210 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10211 struct cdp_peer_info peer_info = { 0 }; 10212 10213 if (!mac_addr) { 10214 dp_err("NULL peer mac addr"); 10215 return QDF_STATUS_E_FAILURE; 10216 } 10217 10218 DP_PEER_INFO_PARAMS_INIT(&peer_info, DP_VDEV_ALL, mac_addr, false, 10219 CDP_WILD_PEER_TYPE); 10220 10221 peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CDP); 10222 if (!peer) { 10223 dp_err("Peer is NULL"); 10224 return QDF_STATUS_E_FAILURE; 10225 } 10226 10227 if (IS_MLO_DP_MLD_PEER(peer)) { 10228 dp_get_link_peers_ref_from_mld_peer(soc, peer, 10229 &link_peers_info, 10230 DP_MOD_ID_CDP); 10231 for (i = 0; i < link_peers_info.num_links; i++) { 10232 link_peer = link_peers_info.link_peers[i]; 10233 link_peer_soc = link_peer->vdev->pdev->soc; 10234 dp_wdi_event_handler(WDI_EVENT_FLUSH_RATE_STATS_REQ, 10235 link_peer_soc, 10236 dp_monitor_peer_get_peerstats_ctx 10237 (link_peer_soc, link_peer), 10238 link_peer->peer_id, 10239 WDI_NO_VAL, 10240 link_peer->vdev->pdev->pdev_id); 10241 } 10242 dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); 10243 } else { 10244 dp_wdi_event_handler( 10245 WDI_EVENT_FLUSH_RATE_STATS_REQ, soc, 10246 dp_monitor_peer_get_peerstats_ctx(soc, peer), 10247 peer->peer_id, 10248 WDI_NO_VAL, peer->vdev->pdev->pdev_id); 10249 } 10250 10251 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 10252 return QDF_STATUS_SUCCESS; 10253 } 10254 #else 10255 static QDF_STATUS 10256 dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) 10257 { 10258 struct dp_peer *peer = NULL; 10259 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10260 10261 if (!mac_addr) { 10262 dp_err("NULL peer mac addr"); 10263 return QDF_STATUS_E_FAILURE; 10264 } 10265 10266 peer = dp_peer_find_hash_find(soc, mac_addr, 0, 10267 DP_VDEV_ALL, DP_MOD_ID_CDP); 10268 if (!peer) { 10269 dp_err("Peer is NULL"); 10270 return QDF_STATUS_E_FAILURE; 10271 } 10272 10273 dp_wdi_event_handler( 10274 WDI_EVENT_FLUSH_RATE_STATS_REQ, soc, 10275 dp_monitor_peer_get_peerstats_ctx(soc, peer), 10276 peer->peer_id, 10277 WDI_NO_VAL, peer->vdev->pdev->pdev_id); 10278 10279 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 10280 return QDF_STATUS_SUCCESS; 10281 } 10282 #endif 10283 #else 10284 static inline QDF_STATUS 10285 dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) 10286 { 10287 return QDF_STATUS_SUCCESS; 10288 } 10289 #endif 10290 10291 static void *dp_peer_get_peerstats_ctx(struct cdp_soc_t *soc_hdl, 10292 uint8_t vdev_id, 10293 uint8_t *mac_addr) 10294 { 10295 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 10296 struct dp_peer *peer; 10297 void *peerstats_ctx = NULL; 10298 10299 if (mac_addr) { 10300 peer = dp_peer_find_hash_find(soc, mac_addr, 10301 0, vdev_id, 10302 DP_MOD_ID_CDP); 10303 if (!peer) 10304 return NULL; 10305 10306 if (!IS_MLO_DP_MLD_PEER(peer)) 10307 peerstats_ctx = dp_monitor_peer_get_peerstats_ctx(soc, 10308 peer); 10309 10310 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 10311 } 10312 10313 return peerstats_ctx; 10314 } 10315 10316 #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE 10317 static QDF_STATUS dp_peer_flush_rate_stats(struct cdp_soc_t *soc, 10318 uint8_t pdev_id, 10319 void *buf) 10320 { 10321 dp_wdi_event_handler(WDI_EVENT_PEER_FLUSH_RATE_STATS, 10322 (struct dp_soc *)soc, buf, HTT_INVALID_PEER, 10323 WDI_NO_VAL, pdev_id); 10324 return QDF_STATUS_SUCCESS; 10325 } 10326 #else 10327 static inline QDF_STATUS 10328 dp_peer_flush_rate_stats(struct cdp_soc_t *soc, 10329 uint8_t pdev_id, 10330 void *buf) 10331 { 10332 return QDF_STATUS_SUCCESS; 10333 } 10334 #endif 10335 10336 static void *dp_soc_get_rate_stats_ctx(struct cdp_soc_t *soc_handle) 10337 { 10338 struct dp_soc *soc = (struct dp_soc *)soc_handle; 10339 10340 return soc->rate_stats_ctx; 10341 } 10342 10343 /** 10344 * dp_get_cfg() - get dp cfg 10345 * @soc: cdp soc handle 10346 * @cfg: cfg enum 10347 * 10348 * Return: cfg value 10349 */ 10350 static uint32_t dp_get_cfg(struct cdp_soc_t *soc, enum cdp_dp_cfg cfg) 10351 { 10352 struct dp_soc *dpsoc = (struct dp_soc *)soc; 10353 uint32_t value = 0; 10354 10355 switch (cfg) { 10356 case cfg_dp_enable_data_stall: 10357 value = dpsoc->wlan_cfg_ctx->enable_data_stall_detection; 10358 break; 10359 case cfg_dp_enable_p2p_ip_tcp_udp_checksum_offload: 10360 value = dpsoc->wlan_cfg_ctx->p2p_tcp_udp_checksumoffload; 10361 break; 10362 case cfg_dp_enable_nan_ip_tcp_udp_checksum_offload: 10363 value = dpsoc->wlan_cfg_ctx->nan_tcp_udp_checksumoffload; 10364 break; 10365 case cfg_dp_enable_ip_tcp_udp_checksum_offload: 10366 value = dpsoc->wlan_cfg_ctx->tcp_udp_checksumoffload; 10367 break; 10368 case cfg_dp_disable_legacy_mode_csum_offload: 10369 value = dpsoc->wlan_cfg_ctx-> 10370 legacy_mode_checksumoffload_disable; 10371 break; 10372 case cfg_dp_tso_enable: 10373 value = dpsoc->wlan_cfg_ctx->tso_enabled; 10374 break; 10375 case cfg_dp_lro_enable: 10376 value = dpsoc->wlan_cfg_ctx->lro_enabled; 10377 break; 10378 case cfg_dp_gro_enable: 10379 value = dpsoc->wlan_cfg_ctx->gro_enabled; 10380 break; 10381 case cfg_dp_tc_based_dyn_gro_enable: 10382 value = dpsoc->wlan_cfg_ctx->tc_based_dynamic_gro; 10383 break; 10384 case cfg_dp_tc_ingress_prio: 10385 value = dpsoc->wlan_cfg_ctx->tc_ingress_prio; 10386 break; 10387 case cfg_dp_sg_enable: 10388 value = dpsoc->wlan_cfg_ctx->sg_enabled; 10389 break; 10390 case cfg_dp_tx_flow_start_queue_offset: 10391 value = dpsoc->wlan_cfg_ctx->tx_flow_start_queue_offset; 10392 break; 10393 case cfg_dp_tx_flow_stop_queue_threshold: 10394 value = dpsoc->wlan_cfg_ctx->tx_flow_stop_queue_threshold; 10395 break; 10396 case cfg_dp_disable_intra_bss_fwd: 10397 value = dpsoc->wlan_cfg_ctx->disable_intra_bss_fwd; 10398 break; 10399 case cfg_dp_pktlog_buffer_size: 10400 value = dpsoc->wlan_cfg_ctx->pktlog_buffer_size; 10401 break; 10402 case cfg_dp_wow_check_rx_pending: 10403 value = dpsoc->wlan_cfg_ctx->wow_check_rx_pending_enable; 10404 break; 10405 case cfg_dp_local_pkt_capture: 10406 value = wlan_cfg_get_local_pkt_capture(dpsoc->wlan_cfg_ctx); 10407 break; 10408 default: 10409 value = 0; 10410 } 10411 10412 return value; 10413 } 10414 10415 #ifdef PEER_FLOW_CONTROL 10416 /** 10417 * dp_tx_flow_ctrl_configure_pdev() - Configure flow control params 10418 * @soc_handle: datapath soc handle 10419 * @pdev_id: id of datapath pdev handle 10420 * @param: ol ath params 10421 * @value: value of the flag 10422 * @buff: Buffer to be passed 10423 * 10424 * Implemented this function same as legacy function. In legacy code, single 10425 * function is used to display stats and update pdev params. 10426 * 10427 * Return: 0 for success. nonzero for failure. 10428 */ 10429 static uint32_t dp_tx_flow_ctrl_configure_pdev(struct cdp_soc_t *soc_handle, 10430 uint8_t pdev_id, 10431 enum _dp_param_t param, 10432 uint32_t value, void *buff) 10433 { 10434 struct dp_soc *soc = (struct dp_soc *)soc_handle; 10435 struct dp_pdev *pdev = 10436 dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, 10437 pdev_id); 10438 10439 if (qdf_unlikely(!pdev)) 10440 return 1; 10441 10442 soc = pdev->soc; 10443 if (!soc) 10444 return 1; 10445 10446 switch (param) { 10447 #ifdef QCA_ENH_V3_STATS_SUPPORT 10448 case DP_PARAM_VIDEO_DELAY_STATS_FC: 10449 if (value) 10450 pdev->delay_stats_flag = true; 10451 else 10452 pdev->delay_stats_flag = false; 10453 break; 10454 case DP_PARAM_VIDEO_STATS_FC: 10455 qdf_print("------- TID Stats ------\n"); 10456 dp_pdev_print_tid_stats(pdev); 10457 qdf_print("------ Delay Stats ------\n"); 10458 dp_pdev_print_delay_stats(pdev); 10459 qdf_print("------ Rx Error Stats ------\n"); 10460 dp_pdev_print_rx_error_stats(pdev); 10461 break; 10462 #endif 10463 case DP_PARAM_TOTAL_Q_SIZE: 10464 { 10465 uint32_t tx_min, tx_max; 10466 10467 tx_min = wlan_cfg_get_min_tx_desc(soc->wlan_cfg_ctx); 10468 tx_max = wlan_cfg_get_num_tx_desc(soc->wlan_cfg_ctx); 10469 10470 if (!buff) { 10471 if ((value >= tx_min) && (value <= tx_max)) { 10472 pdev->num_tx_allowed = value; 10473 } else { 10474 dp_tx_info("%pK: Failed to update num_tx_allowed, Q_min = %d Q_max = %d", 10475 soc, tx_min, tx_max); 10476 break; 10477 } 10478 } else { 10479 *(int *)buff = pdev->num_tx_allowed; 10480 } 10481 } 10482 break; 10483 default: 10484 dp_tx_info("%pK: not handled param %d ", soc, param); 10485 break; 10486 } 10487 10488 return 0; 10489 } 10490 #endif 10491 10492 #ifdef DP_UMAC_HW_RESET_SUPPORT 10493 /** 10494 * dp_reset_interrupt_ring_masks() - Reset rx interrupt masks 10495 * @soc: dp soc handle 10496 * 10497 * Return: void 10498 */ 10499 static void dp_reset_interrupt_ring_masks(struct dp_soc *soc) 10500 { 10501 struct dp_intr_bkp *intr_bkp; 10502 struct dp_intr *intr_ctx; 10503 int num_ctxt = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); 10504 int i; 10505 10506 intr_bkp = 10507 (struct dp_intr_bkp *)qdf_mem_malloc_atomic(sizeof(struct dp_intr_bkp) * 10508 num_ctxt); 10509 10510 qdf_assert_always(intr_bkp); 10511 10512 soc->umac_reset_ctx.intr_ctx_bkp = intr_bkp; 10513 for (i = 0; i < num_ctxt; i++) { 10514 intr_ctx = &soc->intr_ctx[i]; 10515 10516 intr_bkp->tx_ring_mask = intr_ctx->tx_ring_mask; 10517 intr_bkp->rx_ring_mask = intr_ctx->rx_ring_mask; 10518 intr_bkp->rx_mon_ring_mask = intr_ctx->rx_mon_ring_mask; 10519 intr_bkp->rx_err_ring_mask = intr_ctx->rx_err_ring_mask; 10520 intr_bkp->rx_wbm_rel_ring_mask = intr_ctx->rx_wbm_rel_ring_mask; 10521 intr_bkp->reo_status_ring_mask = intr_ctx->reo_status_ring_mask; 10522 intr_bkp->rxdma2host_ring_mask = intr_ctx->rxdma2host_ring_mask; 10523 intr_bkp->host2rxdma_ring_mask = intr_ctx->host2rxdma_ring_mask; 10524 intr_bkp->host2rxdma_mon_ring_mask = 10525 intr_ctx->host2rxdma_mon_ring_mask; 10526 intr_bkp->tx_mon_ring_mask = intr_ctx->tx_mon_ring_mask; 10527 10528 intr_ctx->tx_ring_mask = 0; 10529 intr_ctx->rx_ring_mask = 0; 10530 intr_ctx->rx_mon_ring_mask = 0; 10531 intr_ctx->rx_err_ring_mask = 0; 10532 intr_ctx->rx_wbm_rel_ring_mask = 0; 10533 intr_ctx->reo_status_ring_mask = 0; 10534 intr_ctx->rxdma2host_ring_mask = 0; 10535 intr_ctx->host2rxdma_ring_mask = 0; 10536 intr_ctx->host2rxdma_mon_ring_mask = 0; 10537 intr_ctx->tx_mon_ring_mask = 0; 10538 10539 intr_bkp++; 10540 } 10541 } 10542 10543 /** 10544 * dp_restore_interrupt_ring_masks() - Restore rx interrupt masks 10545 * @soc: dp soc handle 10546 * 10547 * Return: void 10548 */ 10549 static void dp_restore_interrupt_ring_masks(struct dp_soc *soc) 10550 { 10551 struct dp_intr_bkp *intr_bkp = soc->umac_reset_ctx.intr_ctx_bkp; 10552 struct dp_intr_bkp *intr_bkp_base = intr_bkp; 10553 struct dp_intr *intr_ctx; 10554 int num_ctxt = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); 10555 int i; 10556 10557 if (!intr_bkp) 10558 return; 10559 10560 for (i = 0; i < num_ctxt; i++) { 10561 intr_ctx = &soc->intr_ctx[i]; 10562 10563 intr_ctx->tx_ring_mask = intr_bkp->tx_ring_mask; 10564 intr_ctx->rx_ring_mask = intr_bkp->rx_ring_mask; 10565 intr_ctx->rx_mon_ring_mask = intr_bkp->rx_mon_ring_mask; 10566 intr_ctx->rx_err_ring_mask = intr_bkp->rx_err_ring_mask; 10567 intr_ctx->rx_wbm_rel_ring_mask = intr_bkp->rx_wbm_rel_ring_mask; 10568 intr_ctx->reo_status_ring_mask = intr_bkp->reo_status_ring_mask; 10569 intr_ctx->rxdma2host_ring_mask = intr_bkp->rxdma2host_ring_mask; 10570 intr_ctx->host2rxdma_ring_mask = intr_bkp->host2rxdma_ring_mask; 10571 intr_ctx->host2rxdma_mon_ring_mask = 10572 intr_bkp->host2rxdma_mon_ring_mask; 10573 intr_ctx->tx_mon_ring_mask = intr_bkp->tx_mon_ring_mask; 10574 10575 intr_bkp++; 10576 } 10577 10578 qdf_mem_free(intr_bkp_base); 10579 soc->umac_reset_ctx.intr_ctx_bkp = NULL; 10580 } 10581 10582 /** 10583 * dp_resume_tx_hardstart() - Restore the old Tx hardstart functions 10584 * @soc: dp soc handle 10585 * 10586 * Return: void 10587 */ 10588 static void dp_resume_tx_hardstart(struct dp_soc *soc) 10589 { 10590 struct dp_vdev *vdev; 10591 struct ol_txrx_hardtart_ctxt ctxt = {0}; 10592 struct cdp_ctrl_objmgr_psoc *psoc = soc->ctrl_psoc; 10593 int i; 10594 10595 for (i = 0; i < MAX_PDEV_CNT; i++) { 10596 struct dp_pdev *pdev = soc->pdev_list[i]; 10597 10598 if (!pdev) 10599 continue; 10600 10601 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 10602 uint8_t vdev_id = vdev->vdev_id; 10603 10604 dp_vdev_fetch_tx_handler(vdev, soc, &ctxt); 10605 soc->cdp_soc.ol_ops->dp_update_tx_hardstart(psoc, 10606 vdev_id, 10607 &ctxt); 10608 } 10609 } 10610 } 10611 10612 /** 10613 * dp_pause_tx_hardstart() - Register Tx hardstart functions to drop packets 10614 * @soc: dp soc handle 10615 * 10616 * Return: void 10617 */ 10618 static void dp_pause_tx_hardstart(struct dp_soc *soc) 10619 { 10620 struct dp_vdev *vdev; 10621 struct ol_txrx_hardtart_ctxt ctxt; 10622 struct cdp_ctrl_objmgr_psoc *psoc = soc->ctrl_psoc; 10623 int i; 10624 10625 ctxt.tx = &dp_tx_drop; 10626 ctxt.tx_fast = &dp_tx_drop; 10627 ctxt.tx_exception = &dp_tx_exc_drop; 10628 10629 for (i = 0; i < MAX_PDEV_CNT; i++) { 10630 struct dp_pdev *pdev = soc->pdev_list[i]; 10631 10632 if (!pdev) 10633 continue; 10634 10635 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 10636 uint8_t vdev_id = vdev->vdev_id; 10637 10638 soc->cdp_soc.ol_ops->dp_update_tx_hardstart(psoc, 10639 vdev_id, 10640 &ctxt); 10641 } 10642 } 10643 } 10644 10645 /** 10646 * dp_unregister_notify_umac_pre_reset_fw_callback() - unregister notify_fw_cb 10647 * @soc: dp soc handle 10648 * 10649 * Return: void 10650 */ 10651 static inline 10652 void dp_unregister_notify_umac_pre_reset_fw_callback(struct dp_soc *soc) 10653 { 10654 soc->notify_fw_callback = NULL; 10655 } 10656 10657 /** 10658 * dp_check_n_notify_umac_prereset_done() - Send pre reset done to firmware 10659 * @soc: dp soc handle 10660 * 10661 * Return: void 10662 */ 10663 static inline 10664 void dp_check_n_notify_umac_prereset_done(struct dp_soc *soc) 10665 { 10666 /* Some Cpu(s) is processing the umac rings*/ 10667 if (soc->service_rings_running) 10668 return; 10669 10670 /* Notify the firmware that Umac pre reset is complete */ 10671 dp_umac_reset_notify_action_completion(soc, 10672 UMAC_RESET_ACTION_DO_PRE_RESET); 10673 10674 /* Unregister the callback */ 10675 dp_unregister_notify_umac_pre_reset_fw_callback(soc); 10676 } 10677 10678 /** 10679 * dp_register_notify_umac_pre_reset_fw_callback() - register notify_fw_cb 10680 * @soc: dp soc handle 10681 * 10682 * Return: void 10683 */ 10684 static inline 10685 void dp_register_notify_umac_pre_reset_fw_callback(struct dp_soc *soc) 10686 { 10687 soc->notify_fw_callback = dp_check_n_notify_umac_prereset_done; 10688 } 10689 10690 #ifdef DP_UMAC_HW_HARD_RESET 10691 /** 10692 * dp_set_umac_regs() - Reinitialize host umac registers 10693 * @soc: dp soc handle 10694 * 10695 * Return: void 10696 */ 10697 static void dp_set_umac_regs(struct dp_soc *soc) 10698 { 10699 int i; 10700 struct hal_reo_params reo_params; 10701 10702 qdf_mem_zero(&reo_params, sizeof(reo_params)); 10703 10704 if (wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { 10705 if (soc->arch_ops.reo_remap_config(soc, &reo_params.remap0, 10706 &reo_params.remap1, 10707 &reo_params.remap2)) 10708 reo_params.rx_hash_enabled = true; 10709 else 10710 reo_params.rx_hash_enabled = false; 10711 } 10712 10713 reo_params.reo_qref = &soc->reo_qref; 10714 hal_reo_setup(soc->hal_soc, &reo_params, 0); 10715 10716 soc->arch_ops.dp_cc_reg_cfg_init(soc, true); 10717 10718 for (i = 0; i < PCP_TID_MAP_MAX; i++) 10719 hal_tx_update_pcp_tid_map(soc->hal_soc, soc->pcp_tid_map[i], i); 10720 10721 for (i = 0; i < MAX_PDEV_CNT; i++) { 10722 struct dp_vdev *vdev = NULL; 10723 struct dp_pdev *pdev = soc->pdev_list[i]; 10724 10725 if (!pdev) 10726 continue; 10727 10728 for (i = 0; i < soc->num_hw_dscp_tid_map; i++) 10729 hal_tx_set_dscp_tid_map(soc->hal_soc, 10730 pdev->dscp_tid_map[i], i); 10731 10732 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 10733 soc->arch_ops.dp_bank_reconfig(soc, vdev); 10734 soc->arch_ops.dp_reconfig_tx_vdev_mcast_ctrl(soc, 10735 vdev); 10736 } 10737 } 10738 } 10739 #else 10740 static void dp_set_umac_regs(struct dp_soc *soc) 10741 { 10742 } 10743 #endif 10744 10745 /** 10746 * dp_reinit_rings() - Reinitialize host managed rings 10747 * @soc: dp soc handle 10748 * 10749 * Return: QDF_STATUS 10750 */ 10751 static void dp_reinit_rings(struct dp_soc *soc) 10752 { 10753 unsigned long end; 10754 10755 dp_soc_srng_deinit(soc); 10756 dp_hw_link_desc_ring_deinit(soc); 10757 10758 /* Busy wait for 2 ms to make sure the rings are in idle state 10759 * before we enable them again 10760 */ 10761 end = jiffies + msecs_to_jiffies(2); 10762 while (time_before(jiffies, end)) 10763 ; 10764 10765 dp_hw_link_desc_ring_init(soc); 10766 dp_link_desc_ring_replenish(soc, WLAN_INVALID_PDEV_ID); 10767 dp_soc_srng_init(soc); 10768 } 10769 10770 /** 10771 * dp_umac_reset_action_trigger_recovery() - Handle FW Umac recovery trigger 10772 * @soc: dp soc handle 10773 * 10774 * Return: QDF_STATUS 10775 */ 10776 static QDF_STATUS dp_umac_reset_action_trigger_recovery(struct dp_soc *soc) 10777 { 10778 enum umac_reset_action action = UMAC_RESET_ACTION_DO_TRIGGER_RECOVERY; 10779 10780 return dp_umac_reset_notify_action_completion(soc, action); 10781 } 10782 10783 #ifdef WLAN_SUPPORT_PPEDS 10784 /** 10785 * dp_umac_reset_service_handle_n_notify_done() 10786 * Handle Umac pre reset for direct switch 10787 * @soc: dp soc handle 10788 * 10789 * Return: QDF_STATUS 10790 */ 10791 static QDF_STATUS dp_umac_reset_service_handle_n_notify_done(struct dp_soc *soc) 10792 { 10793 if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || 10794 !soc->arch_ops.txrx_soc_ppeds_service_status_update || 10795 !soc->arch_ops.txrx_soc_ppeds_interrupt_stop) 10796 goto non_ppeds; 10797 10798 /* 10799 * Check if ppeds is enabled on SoC. 10800 */ 10801 if (!soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) 10802 goto non_ppeds; 10803 10804 /* 10805 * Start the UMAC pre reset done service. 10806 */ 10807 soc->arch_ops.txrx_soc_ppeds_service_status_update(soc, true); 10808 10809 dp_register_notify_umac_pre_reset_fw_callback(soc); 10810 10811 soc->arch_ops.txrx_soc_ppeds_interrupt_stop(soc); 10812 10813 dp_soc_ppeds_stop((struct cdp_soc_t *)soc); 10814 10815 /* 10816 * UMAC pre reset service complete 10817 */ 10818 soc->arch_ops.txrx_soc_ppeds_service_status_update(soc, false); 10819 10820 soc->umac_reset_ctx.nbuf_list = NULL; 10821 return QDF_STATUS_SUCCESS; 10822 10823 non_ppeds: 10824 dp_register_notify_umac_pre_reset_fw_callback(soc); 10825 dp_check_n_notify_umac_prereset_done(soc); 10826 soc->umac_reset_ctx.nbuf_list = NULL; 10827 return QDF_STATUS_SUCCESS; 10828 } 10829 10830 static inline void dp_umac_reset_ppeds_txdesc_pool_reset(struct dp_soc *soc, 10831 qdf_nbuf_t *nbuf_list) 10832 { 10833 if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || 10834 !soc->arch_ops.txrx_soc_ppeds_txdesc_pool_reset) 10835 return; 10836 10837 /* 10838 * Deinit of PPEDS Tx desc rings. 10839 */ 10840 if (soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) 10841 soc->arch_ops.txrx_soc_ppeds_txdesc_pool_reset(soc, nbuf_list); 10842 } 10843 10844 static inline void dp_umac_reset_ppeds_start(struct dp_soc *soc) 10845 { 10846 if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || 10847 !soc->arch_ops.txrx_soc_ppeds_start || 10848 !soc->arch_ops.txrx_soc_ppeds_interrupt_start) 10849 return; 10850 10851 /* 10852 * Start PPEDS node and enable interrupt. 10853 */ 10854 if (soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) { 10855 soc->arch_ops.txrx_soc_ppeds_start(soc); 10856 soc->arch_ops.txrx_soc_ppeds_interrupt_start(soc); 10857 } 10858 } 10859 #else 10860 static QDF_STATUS dp_umac_reset_service_handle_n_notify_done(struct dp_soc *soc) 10861 { 10862 dp_register_notify_umac_pre_reset_fw_callback(soc); 10863 dp_check_n_notify_umac_prereset_done(soc); 10864 soc->umac_reset_ctx.nbuf_list = NULL; 10865 return QDF_STATUS_SUCCESS; 10866 } 10867 10868 static inline void dp_umac_reset_ppeds_txdesc_pool_reset(struct dp_soc *soc, 10869 qdf_nbuf_t *nbuf_list) 10870 { 10871 } 10872 10873 static inline void dp_umac_reset_ppeds_start(struct dp_soc *soc) 10874 { 10875 } 10876 #endif 10877 10878 /** 10879 * dp_umac_reset_handle_pre_reset() - Handle Umac prereset interrupt from FW 10880 * @soc: dp soc handle 10881 * 10882 * Return: QDF_STATUS 10883 */ 10884 static QDF_STATUS dp_umac_reset_handle_pre_reset(struct dp_soc *soc) 10885 { 10886 dp_reset_interrupt_ring_masks(soc); 10887 10888 dp_pause_tx_hardstart(soc); 10889 dp_pause_reo_send_cmd(soc); 10890 dp_umac_reset_service_handle_n_notify_done(soc); 10891 return QDF_STATUS_SUCCESS; 10892 } 10893 10894 /** 10895 * dp_umac_reset_handle_post_reset() - Handle Umac postreset interrupt from FW 10896 * @soc: dp soc handle 10897 * 10898 * Return: QDF_STATUS 10899 */ 10900 static QDF_STATUS dp_umac_reset_handle_post_reset(struct dp_soc *soc) 10901 { 10902 if (!soc->umac_reset_ctx.skel_enable) { 10903 qdf_nbuf_t *nbuf_list = &soc->umac_reset_ctx.nbuf_list; 10904 10905 dp_set_umac_regs(soc); 10906 10907 dp_reinit_rings(soc); 10908 10909 dp_rx_desc_reuse(soc, nbuf_list); 10910 10911 dp_cleanup_reo_cmd_module(soc); 10912 10913 dp_umac_reset_ppeds_txdesc_pool_reset(soc, nbuf_list); 10914 10915 dp_tx_desc_pool_cleanup(soc, nbuf_list); 10916 10917 dp_reset_tid_q_setup(soc); 10918 } 10919 10920 return dp_umac_reset_notify_action_completion(soc, 10921 UMAC_RESET_ACTION_DO_POST_RESET_START); 10922 } 10923 10924 /** 10925 * dp_umac_reset_handle_post_reset_complete() - Handle Umac postreset_complete 10926 * interrupt from FW 10927 * @soc: dp soc handle 10928 * 10929 * Return: QDF_STATUS 10930 */ 10931 static QDF_STATUS dp_umac_reset_handle_post_reset_complete(struct dp_soc *soc) 10932 { 10933 QDF_STATUS status; 10934 qdf_nbuf_t nbuf_list = soc->umac_reset_ctx.nbuf_list; 10935 10936 soc->umac_reset_ctx.nbuf_list = NULL; 10937 10938 dp_resume_reo_send_cmd(soc); 10939 10940 dp_umac_reset_ppeds_start(soc); 10941 10942 dp_restore_interrupt_ring_masks(soc); 10943 10944 dp_resume_tx_hardstart(soc); 10945 10946 status = dp_umac_reset_notify_action_completion(soc, 10947 UMAC_RESET_ACTION_DO_POST_RESET_COMPLETE); 10948 10949 while (nbuf_list) { 10950 qdf_nbuf_t nbuf = nbuf_list->next; 10951 10952 qdf_nbuf_free(nbuf_list); 10953 nbuf_list = nbuf; 10954 } 10955 10956 dp_umac_reset_info("Umac reset done on soc %pK\n trigger start : %u us " 10957 "trigger done : %u us prereset : %u us\n" 10958 "postreset : %u us \n postreset complete: %u us \n", 10959 soc, 10960 soc->umac_reset_ctx.ts.trigger_done - 10961 soc->umac_reset_ctx.ts.trigger_start, 10962 soc->umac_reset_ctx.ts.pre_reset_done - 10963 soc->umac_reset_ctx.ts.pre_reset_start, 10964 soc->umac_reset_ctx.ts.post_reset_done - 10965 soc->umac_reset_ctx.ts.post_reset_start, 10966 soc->umac_reset_ctx.ts.post_reset_complete_done - 10967 soc->umac_reset_ctx.ts.post_reset_complete_start); 10968 10969 return status; 10970 } 10971 #endif 10972 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 10973 static void 10974 dp_set_pkt_capture_mode(struct cdp_soc_t *soc_handle, bool val) 10975 { 10976 struct dp_soc *soc = (struct dp_soc *)soc_handle; 10977 10978 soc->wlan_cfg_ctx->pkt_capture_mode = val; 10979 } 10980 #endif 10981 10982 #ifdef HW_TX_DELAY_STATS_ENABLE 10983 /** 10984 * dp_enable_disable_vdev_tx_delay_stats() - Start/Stop tx delay stats capture 10985 * @soc_hdl: DP soc handle 10986 * @vdev_id: vdev id 10987 * @value: value 10988 * 10989 * Return: None 10990 */ 10991 static void 10992 dp_enable_disable_vdev_tx_delay_stats(struct cdp_soc_t *soc_hdl, 10993 uint8_t vdev_id, 10994 uint8_t value) 10995 { 10996 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 10997 struct dp_vdev *vdev = NULL; 10998 10999 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 11000 if (!vdev) 11001 return; 11002 11003 vdev->hw_tx_delay_stats_enabled = value; 11004 11005 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 11006 } 11007 11008 /** 11009 * dp_check_vdev_tx_delay_stats_enabled() - check the feature is enabled or not 11010 * @soc_hdl: DP soc handle 11011 * @vdev_id: vdev id 11012 * 11013 * Return: 1 if enabled, 0 if disabled 11014 */ 11015 static uint8_t 11016 dp_check_vdev_tx_delay_stats_enabled(struct cdp_soc_t *soc_hdl, 11017 uint8_t vdev_id) 11018 { 11019 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11020 struct dp_vdev *vdev; 11021 uint8_t ret_val = 0; 11022 11023 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 11024 if (!vdev) 11025 return ret_val; 11026 11027 ret_val = vdev->hw_tx_delay_stats_enabled; 11028 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 11029 11030 return ret_val; 11031 } 11032 #endif 11033 11034 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 11035 static void 11036 dp_recovery_vdev_flush_peers(struct cdp_soc_t *cdp_soc, 11037 uint8_t vdev_id, 11038 bool mlo_peers_only) 11039 { 11040 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 11041 struct dp_vdev *vdev; 11042 11043 vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); 11044 11045 if (!vdev) 11046 return; 11047 11048 dp_vdev_flush_peers((struct cdp_vdev *)vdev, false, mlo_peers_only); 11049 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 11050 } 11051 #endif 11052 #ifdef QCA_GET_TSF_VIA_REG 11053 /** 11054 * dp_get_tsf_time() - get tsf time 11055 * @soc_hdl: Datapath soc handle 11056 * @tsf_id: TSF identifier 11057 * @mac_id: mac_id 11058 * @tsf: pointer to update tsf value 11059 * @tsf_sync_soc_time: pointer to update tsf sync time 11060 * 11061 * Return: None. 11062 */ 11063 static inline void 11064 dp_get_tsf_time(struct cdp_soc_t *soc_hdl, uint32_t tsf_id, uint32_t mac_id, 11065 uint64_t *tsf, uint64_t *tsf_sync_soc_time) 11066 { 11067 hal_get_tsf_time(((struct dp_soc *)soc_hdl)->hal_soc, tsf_id, mac_id, 11068 tsf, tsf_sync_soc_time); 11069 } 11070 #else 11071 static inline void 11072 dp_get_tsf_time(struct cdp_soc_t *soc_hdl, uint32_t tsf_id, uint32_t mac_id, 11073 uint64_t *tsf, uint64_t *tsf_sync_soc_time) 11074 { 11075 } 11076 #endif 11077 11078 /** 11079 * dp_get_tsf2_scratch_reg() - get tsf2 offset from the scratch register 11080 * @soc_hdl: Datapath soc handle 11081 * @mac_id: mac_id 11082 * @value: pointer to update tsf2 offset value 11083 * 11084 * Return: None. 11085 */ 11086 static inline void 11087 dp_get_tsf2_scratch_reg(struct cdp_soc_t *soc_hdl, uint8_t mac_id, 11088 uint64_t *value) 11089 { 11090 hal_get_tsf2_offset(((struct dp_soc *)soc_hdl)->hal_soc, mac_id, value); 11091 } 11092 11093 /** 11094 * dp_get_tqm_scratch_reg() - get tqm offset from the scratch register 11095 * @soc_hdl: Datapath soc handle 11096 * @value: pointer to update tqm offset value 11097 * 11098 * Return: None. 11099 */ 11100 static inline void 11101 dp_get_tqm_scratch_reg(struct cdp_soc_t *soc_hdl, uint64_t *value) 11102 { 11103 hal_get_tqm_offset(((struct dp_soc *)soc_hdl)->hal_soc, value); 11104 } 11105 11106 /** 11107 * dp_set_tx_pause() - Pause or resume tx path 11108 * @soc_hdl: Datapath soc handle 11109 * @flag: set or clear is_tx_pause 11110 * 11111 * Return: None. 11112 */ 11113 static inline 11114 void dp_set_tx_pause(struct cdp_soc_t *soc_hdl, bool flag) 11115 { 11116 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11117 11118 soc->is_tx_pause = flag; 11119 } 11120 11121 static inline uint64_t dp_rx_fisa_get_cmem_base(struct cdp_soc_t *soc_hdl, 11122 uint64_t size) 11123 { 11124 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11125 11126 if (soc->arch_ops.dp_get_fst_cmem_base) 11127 return soc->arch_ops.dp_get_fst_cmem_base(soc, size); 11128 11129 return 0; 11130 } 11131 11132 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 11133 /** 11134 * dp_evaluate_update_tx_ilp_config() - Evaluate and update DP TX 11135 * ILP configuration 11136 * @soc_hdl: CDP SOC handle 11137 * @num_msdu_idx_map: Number of HTT msdu index to qtype map in array 11138 * @msdu_idx_map_arr: Pointer to HTT msdu index to qtype map array 11139 * 11140 * This function will check: (a) TX ILP INI configuration, 11141 * (b) index 3 value in array same as HTT_MSDU_QTYPE_LATENCY_TOLERANT, 11142 * only if both (a) and (b) condition is met, then TX ILP feature is 11143 * considered to be enabled. 11144 * 11145 * Return: Final updated TX ILP enable result in dp_soc, 11146 * true is enabled, false is not 11147 */ 11148 static 11149 bool dp_evaluate_update_tx_ilp_config(struct cdp_soc_t *soc_hdl, 11150 uint8_t num_msdu_idx_map, 11151 uint8_t *msdu_idx_map_arr) 11152 { 11153 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11154 bool enable_tx_ilp = false; 11155 11156 /** 11157 * Check INI configuration firstly, if it's disabled, 11158 * then keep feature disabled. 11159 */ 11160 if (!wlan_cfg_get_tx_ilp_inspect_config(soc->wlan_cfg_ctx)) { 11161 dp_info("TX ILP INI is disabled already"); 11162 goto update_tx_ilp; 11163 } 11164 11165 /* Check if the msdu index to qtype map table is valid */ 11166 if (num_msdu_idx_map != HTT_MSDUQ_MAX_INDEX || !msdu_idx_map_arr) { 11167 dp_info("Invalid msdu_idx qtype map num: 0x%x, arr_addr %pK", 11168 num_msdu_idx_map, msdu_idx_map_arr); 11169 goto update_tx_ilp; 11170 } 11171 11172 dp_info("msdu_idx_map_arr idx 0x%x value 0x%x", 11173 HTT_MSDUQ_INDEX_CUSTOM_PRIO_1, 11174 msdu_idx_map_arr[HTT_MSDUQ_INDEX_CUSTOM_PRIO_1]); 11175 11176 if (HTT_MSDU_QTYPE_USER_SPECIFIED == 11177 msdu_idx_map_arr[HTT_MSDUQ_INDEX_CUSTOM_PRIO_1]) 11178 enable_tx_ilp = true; 11179 11180 update_tx_ilp: 11181 soc->tx_ilp_enable = enable_tx_ilp; 11182 dp_info("configure tx ilp enable %d", soc->tx_ilp_enable); 11183 11184 return soc->tx_ilp_enable; 11185 } 11186 #endif 11187 11188 static struct cdp_cmn_ops dp_ops_cmn = { 11189 .txrx_soc_attach_target = dp_soc_attach_target_wifi3, 11190 .txrx_vdev_attach = dp_vdev_attach_wifi3, 11191 .txrx_vdev_detach = dp_vdev_detach_wifi3, 11192 .txrx_pdev_attach = dp_pdev_attach_wifi3, 11193 .txrx_pdev_post_attach = dp_pdev_post_attach_wifi3, 11194 .txrx_pdev_detach = dp_pdev_detach_wifi3, 11195 .txrx_pdev_deinit = dp_pdev_deinit_wifi3, 11196 .txrx_peer_create = dp_peer_create_wifi3, 11197 .txrx_peer_setup = dp_peer_setup_wifi3_wrapper, 11198 #ifdef FEATURE_AST 11199 .txrx_peer_teardown = dp_peer_teardown_wifi3, 11200 #else 11201 .txrx_peer_teardown = NULL, 11202 #endif 11203 .txrx_peer_add_ast = dp_peer_add_ast_wifi3, 11204 .txrx_peer_update_ast = dp_peer_update_ast_wifi3, 11205 .txrx_peer_get_ast_info_by_soc = dp_peer_get_ast_info_by_soc_wifi3, 11206 .txrx_peer_get_ast_info_by_pdev = 11207 dp_peer_get_ast_info_by_pdevid_wifi3, 11208 .txrx_peer_ast_delete_by_soc = 11209 dp_peer_ast_entry_del_by_soc, 11210 .txrx_peer_ast_delete_by_pdev = 11211 dp_peer_ast_entry_del_by_pdev, 11212 .txrx_peer_HMWDS_ast_delete = dp_peer_HMWDS_ast_entry_del, 11213 .txrx_peer_delete = dp_peer_delete_wifi3, 11214 #ifdef DP_RX_UDP_OVER_PEER_ROAM 11215 .txrx_update_roaming_peer = dp_update_roaming_peer_wifi3, 11216 #endif 11217 .txrx_vdev_register = dp_vdev_register_wifi3, 11218 .txrx_soc_detach = dp_soc_detach_wifi3, 11219 .txrx_soc_deinit = dp_soc_deinit_wifi3, 11220 .txrx_soc_init = dp_soc_init_wifi3, 11221 #ifndef QCA_HOST_MODE_WIFI_DISABLED 11222 .txrx_tso_soc_attach = dp_tso_soc_attach, 11223 .txrx_tso_soc_detach = dp_tso_soc_detach, 11224 .tx_send = dp_tx_send, 11225 .tx_send_exc = dp_tx_send_exception, 11226 #endif 11227 .set_tx_pause = dp_set_tx_pause, 11228 .txrx_pdev_init = dp_pdev_init_wifi3, 11229 .txrx_get_vdev_mac_addr = dp_get_vdev_mac_addr_wifi3, 11230 .txrx_get_ctrl_pdev_from_vdev = dp_get_ctrl_pdev_from_vdev_wifi3, 11231 .txrx_ath_getstats = dp_get_device_stats, 11232 #ifndef WLAN_SOFTUMAC_SUPPORT 11233 .addba_requestprocess = dp_addba_requestprocess_wifi3, 11234 .addba_responsesetup = dp_addba_responsesetup_wifi3, 11235 .addba_resp_tx_completion = dp_addba_resp_tx_completion_wifi3, 11236 .delba_process = dp_delba_process_wifi3, 11237 .set_addba_response = dp_set_addba_response, 11238 .flush_cache_rx_queue = NULL, 11239 .tid_update_ba_win_size = dp_rx_tid_update_ba_win_size, 11240 #endif 11241 /* TODO: get API's for dscp-tid need to be added*/ 11242 .set_vdev_dscp_tid_map = dp_set_vdev_dscp_tid_map_wifi3, 11243 .set_pdev_dscp_tid_map = dp_set_pdev_dscp_tid_map_wifi3, 11244 .txrx_get_total_per = dp_get_total_per, 11245 .txrx_stats_request = dp_txrx_stats_request, 11246 .txrx_get_peer_mac_from_peer_id = dp_get_peer_mac_from_peer_id, 11247 .display_stats = dp_txrx_dump_stats, 11248 .notify_asserted_soc = dp_soc_notify_asserted_soc, 11249 .txrx_intr_attach = dp_soc_interrupt_attach_wrapper, 11250 .txrx_intr_detach = dp_soc_interrupt_detach, 11251 .txrx_ppeds_stop = dp_soc_ppeds_stop, 11252 .set_key_sec_type = dp_set_key_sec_type_wifi3, 11253 .update_config_parameters = dp_update_config_parameters, 11254 /* TODO: Add other functions */ 11255 .txrx_data_tx_cb_set = dp_txrx_data_tx_cb_set, 11256 .get_dp_txrx_handle = dp_pdev_get_dp_txrx_handle, 11257 .set_dp_txrx_handle = dp_pdev_set_dp_txrx_handle, 11258 .get_vdev_dp_ext_txrx_handle = dp_vdev_get_dp_ext_handle, 11259 .set_vdev_dp_ext_txrx_handle = dp_vdev_set_dp_ext_handle, 11260 .get_soc_dp_txrx_handle = dp_soc_get_dp_txrx_handle, 11261 .set_soc_dp_txrx_handle = dp_soc_set_dp_txrx_handle, 11262 .map_pdev_to_lmac = dp_soc_map_pdev_to_lmac, 11263 .handle_mode_change = dp_soc_handle_pdev_mode_change, 11264 .set_pdev_status_down = dp_soc_set_pdev_status_down, 11265 .txrx_peer_reset_ast = dp_wds_reset_ast_wifi3, 11266 .txrx_peer_reset_ast_table = dp_wds_reset_ast_table_wifi3, 11267 .txrx_peer_flush_ast_table = dp_wds_flush_ast_table_wifi3, 11268 .txrx_peer_map_attach = dp_peer_map_attach_wifi3, 11269 .set_soc_param = dp_soc_set_param, 11270 .txrx_get_os_rx_handles_from_vdev = 11271 dp_get_os_rx_handles_from_vdev_wifi3, 11272 #ifndef WLAN_SOFTUMAC_SUPPORT 11273 .set_pn_check = dp_set_pn_check_wifi3, 11274 .txrx_set_ba_aging_timeout = dp_set_ba_aging_timeout, 11275 .txrx_get_ba_aging_timeout = dp_get_ba_aging_timeout, 11276 .delba_tx_completion = dp_delba_tx_completion_wifi3, 11277 .set_pdev_pcp_tid_map = dp_set_pdev_pcp_tid_map_wifi3, 11278 .set_vdev_pcp_tid_map = dp_set_vdev_pcp_tid_map_wifi3, 11279 #endif 11280 .get_dp_capabilities = dp_get_cfg_capabilities, 11281 .txrx_get_cfg = dp_get_cfg, 11282 .set_rate_stats_ctx = dp_soc_set_rate_stats_ctx, 11283 .get_rate_stats_ctx = dp_soc_get_rate_stats_ctx, 11284 .txrx_peer_flush_rate_stats = dp_peer_flush_rate_stats, 11285 .txrx_flush_rate_stats_request = dp_flush_rate_stats_req, 11286 .txrx_peer_get_peerstats_ctx = dp_peer_get_peerstats_ctx, 11287 11288 .txrx_cp_peer_del_response = dp_cp_peer_del_resp_handler, 11289 #ifdef QCA_MULTIPASS_SUPPORT 11290 .set_vlan_groupkey = dp_set_vlan_groupkey, 11291 #endif 11292 .get_peer_mac_list = dp_get_peer_mac_list, 11293 .get_peer_id = dp_get_peer_id, 11294 #ifdef QCA_SUPPORT_WDS_EXTENDED 11295 .set_wds_ext_peer_rx = dp_wds_ext_set_peer_rx, 11296 .get_wds_ext_peer_osif_handle = dp_wds_ext_get_peer_osif_handle, 11297 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 11298 11299 #if defined(FEATURE_RUNTIME_PM) || defined(DP_POWER_SAVE) 11300 .txrx_drain = dp_drain_txrx, 11301 #endif 11302 #if defined(FEATURE_RUNTIME_PM) 11303 .set_rtpm_tput_policy = dp_set_rtpm_tput_policy_requirement, 11304 #endif 11305 #ifdef WLAN_SYSFS_DP_STATS 11306 .txrx_sysfs_fill_stats = dp_sysfs_fill_stats, 11307 .txrx_sysfs_set_stat_type = dp_sysfs_set_stat_type, 11308 #endif /* WLAN_SYSFS_DP_STATS */ 11309 #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 11310 .set_pkt_capture_mode = dp_set_pkt_capture_mode, 11311 #endif 11312 #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) 11313 .txrx_recovery_vdev_flush_peers = dp_recovery_vdev_flush_peers, 11314 #endif 11315 .txrx_umac_reset_deinit = dp_soc_umac_reset_deinit, 11316 .txrx_umac_reset_init = dp_soc_umac_reset_init, 11317 .txrx_get_tsf_time = dp_get_tsf_time, 11318 .txrx_get_tsf2_offset = dp_get_tsf2_scratch_reg, 11319 .txrx_get_tqm_offset = dp_get_tqm_scratch_reg, 11320 #ifdef WLAN_SUPPORT_RX_FISA 11321 .get_fst_cmem_base = dp_rx_fisa_get_cmem_base, 11322 #endif 11323 }; 11324 11325 static struct cdp_ctrl_ops dp_ops_ctrl = { 11326 .txrx_peer_authorize = dp_peer_authorize, 11327 .txrx_peer_get_authorize = dp_peer_get_authorize, 11328 #ifdef VDEV_PEER_PROTOCOL_COUNT 11329 .txrx_enable_peer_protocol_count = dp_enable_vdev_peer_protocol_count, 11330 .txrx_set_peer_protocol_drop_mask = 11331 dp_enable_vdev_peer_protocol_drop_mask, 11332 .txrx_is_peer_protocol_count_enabled = 11333 dp_is_vdev_peer_protocol_count_enabled, 11334 .txrx_get_peer_protocol_drop_mask = dp_get_vdev_peer_protocol_drop_mask, 11335 #endif 11336 .txrx_set_vdev_param = dp_set_vdev_param_wrapper, 11337 .txrx_set_psoc_param = dp_set_psoc_param, 11338 .txrx_get_psoc_param = dp_get_psoc_param, 11339 #ifndef WLAN_SOFTUMAC_SUPPORT 11340 .txrx_set_pdev_reo_dest = dp_set_pdev_reo_dest, 11341 .txrx_get_pdev_reo_dest = dp_get_pdev_reo_dest, 11342 #endif 11343 .txrx_get_sec_type = dp_get_sec_type, 11344 .txrx_wdi_event_sub = dp_wdi_event_sub, 11345 .txrx_wdi_event_unsub = dp_wdi_event_unsub, 11346 .txrx_set_pdev_param = dp_set_pdev_param, 11347 .txrx_get_pdev_param = dp_get_pdev_param, 11348 #ifdef WLAN_FEATURE_11BE_MLO 11349 .txrx_set_peer_param = dp_set_peer_param_wrapper, 11350 #else 11351 .txrx_set_peer_param = dp_set_peer_param, 11352 #endif 11353 .txrx_get_peer_param = dp_get_peer_param, 11354 #ifdef VDEV_PEER_PROTOCOL_COUNT 11355 .txrx_peer_protocol_cnt = dp_peer_stats_update_protocol_cnt, 11356 #endif 11357 #ifdef WLAN_SUPPORT_MSCS 11358 .txrx_record_mscs_params = dp_record_mscs_params, 11359 #endif 11360 .set_key = dp_set_michael_key, 11361 .txrx_get_vdev_param = dp_get_vdev_param, 11362 .calculate_delay_stats = dp_calculate_delay_stats, 11363 #ifdef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG 11364 .txrx_update_pdev_rx_protocol_tag = dp_update_pdev_rx_protocol_tag, 11365 #ifdef WLAN_SUPPORT_RX_TAG_STATISTICS 11366 .txrx_dump_pdev_rx_protocol_tag_stats = 11367 dp_dump_pdev_rx_protocol_tag_stats, 11368 #endif /* WLAN_SUPPORT_RX_TAG_STATISTICS */ 11369 #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG */ 11370 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 11371 .txrx_set_rx_flow_tag = dp_set_rx_flow_tag, 11372 .txrx_dump_rx_flow_tag_stats = dp_dump_rx_flow_tag_stats, 11373 #endif /* WLAN_SUPPORT_RX_FLOW_TAG */ 11374 #ifdef QCA_MULTIPASS_SUPPORT 11375 .txrx_peer_set_vlan_id = dp_peer_set_vlan_id, 11376 #endif /*QCA_MULTIPASS_SUPPORT*/ 11377 #if defined(WLAN_FEATURE_TSF_UPLINK_DELAY) || defined(WLAN_CONFIG_TX_DELAY) 11378 .txrx_set_delta_tsf = dp_set_delta_tsf, 11379 #endif 11380 #ifdef WLAN_FEATURE_TSF_UPLINK_DELAY 11381 .txrx_set_tsf_ul_delay_report = dp_set_tsf_ul_delay_report, 11382 .txrx_get_uplink_delay = dp_get_uplink_delay, 11383 #endif 11384 #ifdef QCA_UNDECODED_METADATA_SUPPORT 11385 .txrx_set_pdev_phyrx_error_mask = dp_set_pdev_phyrx_error_mask, 11386 .txrx_get_pdev_phyrx_error_mask = dp_get_pdev_phyrx_error_mask, 11387 #endif 11388 .txrx_peer_flush_frags = dp_peer_flush_frags, 11389 #ifdef DP_UMAC_HW_RESET_SUPPORT 11390 .get_umac_reset_in_progress_state = dp_get_umac_reset_in_progress_state, 11391 #endif 11392 #ifdef WLAN_SUPPORT_RX_FISA 11393 .txrx_fisa_config = dp_fisa_config, 11394 #endif 11395 }; 11396 11397 static struct cdp_me_ops dp_ops_me = { 11398 #ifndef QCA_HOST_MODE_WIFI_DISABLED 11399 #ifdef ATH_SUPPORT_IQUE 11400 .tx_me_alloc_descriptor = dp_tx_me_alloc_descriptor, 11401 .tx_me_free_descriptor = dp_tx_me_free_descriptor, 11402 .tx_me_convert_ucast = dp_tx_me_send_convert_ucast, 11403 #endif 11404 #endif 11405 }; 11406 11407 static struct cdp_host_stats_ops dp_ops_host_stats = { 11408 .txrx_per_peer_stats = dp_get_host_peer_stats, 11409 .get_fw_peer_stats = dp_get_fw_peer_stats, 11410 .get_htt_stats = dp_get_htt_stats, 11411 .txrx_stats_publish = dp_txrx_stats_publish, 11412 .txrx_get_vdev_stats = dp_txrx_get_vdev_stats, 11413 .txrx_get_peer_stats = dp_txrx_get_peer_stats, 11414 .txrx_get_soc_stats = dp_txrx_get_soc_stats, 11415 .txrx_get_peer_stats_param = dp_txrx_get_peer_stats_param, 11416 .txrx_get_per_link_stats = dp_txrx_get_per_link_peer_stats, 11417 .txrx_reset_peer_stats = dp_txrx_reset_peer_stats, 11418 .txrx_get_pdev_stats = dp_txrx_get_pdev_stats, 11419 #if defined(IPA_OFFLOAD) && defined(QCA_ENHANCED_STATS_SUPPORT) 11420 .txrx_get_peer_stats = dp_ipa_txrx_get_peer_stats, 11421 .txrx_get_vdev_stats = dp_ipa_txrx_get_vdev_stats, 11422 .txrx_get_pdev_stats = dp_ipa_txrx_get_pdev_stats, 11423 #endif 11424 .txrx_get_ratekbps = dp_txrx_get_ratekbps, 11425 .txrx_update_vdev_stats = dp_txrx_update_vdev_host_stats, 11426 .txrx_get_peer_delay_stats = dp_txrx_get_peer_delay_stats, 11427 .txrx_get_peer_jitter_stats = dp_txrx_get_peer_jitter_stats, 11428 #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT 11429 .txrx_alloc_vdev_stats_id = dp_txrx_alloc_vdev_stats_id, 11430 .txrx_reset_vdev_stats_id = dp_txrx_reset_vdev_stats_id, 11431 #endif 11432 #ifdef WLAN_TX_PKT_CAPTURE_ENH 11433 .get_peer_tx_capture_stats = dp_peer_get_tx_capture_stats, 11434 .get_pdev_tx_capture_stats = dp_pdev_get_tx_capture_stats, 11435 #endif /* WLAN_TX_PKT_CAPTURE_ENH */ 11436 #ifdef HW_TX_DELAY_STATS_ENABLE 11437 .enable_disable_vdev_tx_delay_stats = 11438 dp_enable_disable_vdev_tx_delay_stats, 11439 .is_tx_delay_stats_enabled = dp_check_vdev_tx_delay_stats_enabled, 11440 #endif 11441 .txrx_get_pdev_tid_stats = dp_pdev_get_tid_stats, 11442 #ifdef WLAN_CONFIG_TELEMETRY_AGENT 11443 .txrx_pdev_telemetry_stats = dp_get_pdev_telemetry_stats, 11444 .txrx_peer_telemetry_stats = dp_get_peer_telemetry_stats, 11445 .txrx_pdev_deter_stats = dp_get_pdev_deter_stats, 11446 .txrx_peer_deter_stats = dp_get_peer_deter_stats, 11447 .txrx_update_pdev_chan_util_stats = dp_update_pdev_chan_util_stats, 11448 #endif 11449 .txrx_get_peer_extd_rate_link_stats = 11450 dp_get_peer_extd_rate_link_stats, 11451 .get_pdev_obss_stats = dp_get_obss_stats, 11452 .clear_pdev_obss_pd_stats = dp_clear_pdev_obss_pd_stats, 11453 .txrx_get_interface_stats = dp_txrx_get_interface_stats, 11454 /* TODO */ 11455 }; 11456 11457 static struct cdp_raw_ops dp_ops_raw = { 11458 /* TODO */ 11459 }; 11460 11461 #ifdef PEER_FLOW_CONTROL 11462 static struct cdp_pflow_ops dp_ops_pflow = { 11463 dp_tx_flow_ctrl_configure_pdev, 11464 }; 11465 #endif 11466 11467 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) 11468 static struct cdp_cfr_ops dp_ops_cfr = { 11469 .txrx_get_cfr_rcc = dp_get_cfr_rcc, 11470 .txrx_set_cfr_rcc = dp_set_cfr_rcc, 11471 .txrx_get_cfr_dbg_stats = dp_get_cfr_dbg_stats, 11472 .txrx_clear_cfr_dbg_stats = dp_clear_cfr_dbg_stats, 11473 }; 11474 #endif 11475 11476 #ifdef WLAN_SUPPORT_MSCS 11477 static struct cdp_mscs_ops dp_ops_mscs = { 11478 .mscs_peer_lookup_n_get_priority = dp_mscs_peer_lookup_n_get_priority, 11479 }; 11480 #endif 11481 11482 #ifdef WLAN_SUPPORT_MESH_LATENCY 11483 static struct cdp_mesh_latency_ops dp_ops_mesh_latency = { 11484 .mesh_latency_update_peer_parameter = 11485 dp_mesh_latency_update_peer_parameter, 11486 }; 11487 #endif 11488 11489 #ifdef WLAN_SUPPORT_SCS 11490 static struct cdp_scs_ops dp_ops_scs = { 11491 .scs_peer_lookup_n_rule_match = dp_scs_peer_lookup_n_rule_match, 11492 }; 11493 #endif 11494 11495 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 11496 static struct cdp_fse_ops dp_ops_fse = { 11497 .fse_rule_add = dp_rx_sfe_add_flow_entry, 11498 .fse_rule_delete = dp_rx_sfe_delete_flow_entry, 11499 }; 11500 #endif 11501 11502 #ifdef CONFIG_SAWF_DEF_QUEUES 11503 static struct cdp_sawf_ops dp_ops_sawf = { 11504 .sawf_def_queues_map_req = dp_sawf_def_queues_map_req, 11505 .sawf_def_queues_unmap_req = dp_sawf_def_queues_unmap_req, 11506 .sawf_def_queues_get_map_report = 11507 dp_sawf_def_queues_get_map_report, 11508 #ifdef CONFIG_SAWF_STATS 11509 .sawf_get_peer_msduq_info = dp_sawf_get_peer_msduq_info, 11510 .txrx_get_peer_sawf_delay_stats = dp_sawf_get_peer_delay_stats, 11511 .txrx_get_peer_sawf_tx_stats = dp_sawf_get_peer_tx_stats, 11512 .sawf_mpdu_stats_req = dp_sawf_mpdu_stats_req, 11513 .sawf_mpdu_details_stats_req = dp_sawf_mpdu_details_stats_req, 11514 .txrx_sawf_set_mov_avg_params = dp_sawf_set_mov_avg_params, 11515 .txrx_sawf_set_sla_params = dp_sawf_set_sla_params, 11516 .txrx_sawf_init_telemtery_params = dp_sawf_init_telemetry_params, 11517 .telemetry_get_throughput_stats = dp_sawf_get_tx_stats, 11518 .telemetry_get_mpdu_stats = dp_sawf_get_mpdu_sched_stats, 11519 .telemetry_get_drop_stats = dp_sawf_get_drop_stats, 11520 .peer_config_ul = dp_sawf_peer_config_ul, 11521 .swaf_peer_sla_configuration = dp_swaf_peer_sla_configuration, 11522 .sawf_peer_flow_count = dp_sawf_peer_flow_count, 11523 #endif 11524 }; 11525 #endif 11526 11527 #ifdef DP_TX_TRACKING 11528 11529 #define DP_TX_COMP_MAX_LATENCY_MS 60000 11530 /** 11531 * dp_tx_comp_delay_check() - calculate time latency for tx completion per pkt 11532 * @tx_desc: tx descriptor 11533 * 11534 * Calculate time latency for tx completion per pkt and trigger self recovery 11535 * when the delay is more than threshold value. 11536 * 11537 * Return: True if delay is more than threshold 11538 */ 11539 static bool dp_tx_comp_delay_check(struct dp_tx_desc_s *tx_desc) 11540 { 11541 uint64_t time_latency, timestamp_tick = tx_desc->timestamp_tick; 11542 qdf_ktime_t current_time = qdf_ktime_real_get(); 11543 qdf_ktime_t timestamp = tx_desc->timestamp; 11544 11545 if (dp_tx_pkt_tracepoints_enabled()) { 11546 if (!timestamp) 11547 return false; 11548 11549 time_latency = qdf_ktime_to_ms(current_time) - 11550 qdf_ktime_to_ms(timestamp); 11551 if (time_latency >= DP_TX_COMP_MAX_LATENCY_MS) { 11552 dp_err_rl("enqueued: %llu ms, current : %llu ms", 11553 timestamp, current_time); 11554 return true; 11555 } 11556 } else { 11557 if (!timestamp_tick) 11558 return false; 11559 11560 current_time = qdf_system_ticks(); 11561 time_latency = qdf_system_ticks_to_msecs(current_time - 11562 timestamp_tick); 11563 if (time_latency >= DP_TX_COMP_MAX_LATENCY_MS) { 11564 dp_err_rl("enqueued: %u ms, current : %u ms", 11565 qdf_system_ticks_to_msecs(timestamp_tick), 11566 qdf_system_ticks_to_msecs(current_time)); 11567 return true; 11568 } 11569 } 11570 11571 return false; 11572 } 11573 11574 void dp_find_missing_tx_comp(struct dp_soc *soc) 11575 { 11576 uint8_t i; 11577 uint32_t j; 11578 uint32_t num_desc, page_id, offset; 11579 uint16_t num_desc_per_page; 11580 struct dp_tx_desc_s *tx_desc = NULL; 11581 struct dp_tx_desc_pool_s *tx_desc_pool = NULL; 11582 11583 for (i = 0; i < MAX_TXDESC_POOLS; i++) { 11584 tx_desc_pool = &soc->tx_desc[i]; 11585 if (!(tx_desc_pool->pool_size) || 11586 IS_TX_DESC_POOL_STATUS_INACTIVE(tx_desc_pool) || 11587 !(tx_desc_pool->desc_pages.cacheable_pages)) 11588 continue; 11589 11590 num_desc = tx_desc_pool->pool_size; 11591 num_desc_per_page = 11592 tx_desc_pool->desc_pages.num_element_per_page; 11593 for (j = 0; j < num_desc; j++) { 11594 page_id = j / num_desc_per_page; 11595 offset = j % num_desc_per_page; 11596 11597 if (qdf_unlikely(!(tx_desc_pool-> 11598 desc_pages.cacheable_pages))) 11599 break; 11600 11601 tx_desc = dp_tx_desc_find(soc, i, page_id, offset); 11602 if (tx_desc->magic == DP_TX_MAGIC_PATTERN_FREE) { 11603 continue; 11604 } else if (tx_desc->magic == 11605 DP_TX_MAGIC_PATTERN_INUSE) { 11606 if (dp_tx_comp_delay_check(tx_desc)) { 11607 dp_err_rl("Tx completion not rcvd for id: %u", 11608 tx_desc->id); 11609 if (tx_desc->vdev_id == DP_INVALID_VDEV_ID) { 11610 tx_desc->flags |= DP_TX_DESC_FLAG_FLUSH; 11611 dp_err_rl("Freed tx_desc %u", 11612 tx_desc->id); 11613 dp_tx_comp_free_buf(soc, 11614 tx_desc, 11615 false); 11616 dp_tx_desc_release(soc, tx_desc, 11617 i); 11618 DP_STATS_INC(soc, 11619 tx.tx_comp_force_freed, 1); 11620 } 11621 } 11622 } else { 11623 dp_err_rl("tx desc %u corrupted, flags: 0x%x", 11624 tx_desc->id, tx_desc->flags); 11625 } 11626 } 11627 } 11628 } 11629 #else 11630 inline void dp_find_missing_tx_comp(struct dp_soc *soc) 11631 { 11632 } 11633 #endif 11634 11635 #ifdef FEATURE_RUNTIME_PM 11636 /** 11637 * dp_runtime_suspend() - ensure DP is ready to runtime suspend 11638 * @soc_hdl: Datapath soc handle 11639 * @pdev_id: id of data path pdev handle 11640 * 11641 * DP is ready to runtime suspend if there are no pending TX packets. 11642 * 11643 * Return: QDF_STATUS 11644 */ 11645 static QDF_STATUS dp_runtime_suspend(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 11646 { 11647 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11648 struct dp_pdev *pdev; 11649 int32_t tx_pending; 11650 11651 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11652 if (!pdev) { 11653 dp_err("pdev is NULL"); 11654 return QDF_STATUS_E_INVAL; 11655 } 11656 11657 /* Abort if there are any pending TX packets */ 11658 tx_pending = dp_get_tx_pending(dp_pdev_to_cdp_pdev(pdev)); 11659 if (tx_pending) { 11660 dp_info_rl("%pK: Abort suspend due to pending TX packets %d", 11661 soc, tx_pending); 11662 dp_find_missing_tx_comp(soc); 11663 /* perform a force flush if tx is pending */ 11664 soc->arch_ops.dp_update_ring_hptp(soc, true); 11665 qdf_atomic_set(&soc->tx_pending_rtpm, 0); 11666 11667 return QDF_STATUS_E_AGAIN; 11668 } 11669 11670 if (dp_runtime_get_refcount(soc)) { 11671 dp_init_info("refcount: %d", dp_runtime_get_refcount(soc)); 11672 11673 return QDF_STATUS_E_AGAIN; 11674 } 11675 11676 if (soc->intr_mode == DP_INTR_POLL) 11677 qdf_timer_stop(&soc->int_timer); 11678 11679 return QDF_STATUS_SUCCESS; 11680 } 11681 11682 #define DP_FLUSH_WAIT_CNT 10 11683 #define DP_RUNTIME_SUSPEND_WAIT_MS 10 11684 /** 11685 * dp_runtime_resume() - ensure DP is ready to runtime resume 11686 * @soc_hdl: Datapath soc handle 11687 * @pdev_id: id of data path pdev handle 11688 * 11689 * Resume DP for runtime PM. 11690 * 11691 * Return: QDF_STATUS 11692 */ 11693 static QDF_STATUS dp_runtime_resume(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 11694 { 11695 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11696 int suspend_wait = 0; 11697 11698 if (soc->intr_mode == DP_INTR_POLL) 11699 qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); 11700 11701 /* 11702 * Wait until dp runtime refcount becomes zero or time out, then flush 11703 * pending tx for runtime suspend. 11704 */ 11705 while (dp_runtime_get_refcount(soc) && 11706 suspend_wait < DP_FLUSH_WAIT_CNT) { 11707 qdf_sleep(DP_RUNTIME_SUSPEND_WAIT_MS); 11708 suspend_wait++; 11709 } 11710 11711 soc->arch_ops.dp_update_ring_hptp(soc, false); 11712 qdf_atomic_set(&soc->tx_pending_rtpm, 0); 11713 11714 return QDF_STATUS_SUCCESS; 11715 } 11716 #endif /* FEATURE_RUNTIME_PM */ 11717 11718 /** 11719 * dp_tx_get_success_ack_stats() - get tx success completion count 11720 * @soc_hdl: Datapath soc handle 11721 * @vdev_id: vdev identifier 11722 * 11723 * Return: tx success ack count 11724 */ 11725 static uint32_t dp_tx_get_success_ack_stats(struct cdp_soc_t *soc_hdl, 11726 uint8_t vdev_id) 11727 { 11728 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11729 struct cdp_vdev_stats *vdev_stats = NULL; 11730 uint32_t tx_success; 11731 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 11732 DP_MOD_ID_CDP); 11733 11734 if (!vdev) { 11735 dp_cdp_err("%pK: Invalid vdev id %d", soc, vdev_id); 11736 return 0; 11737 } 11738 11739 vdev_stats = qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); 11740 if (!vdev_stats) { 11741 dp_cdp_err("%pK: DP alloc failure - unable to get alloc vdev stats", soc); 11742 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 11743 return 0; 11744 } 11745 11746 dp_aggregate_vdev_stats(vdev, vdev_stats); 11747 11748 tx_success = vdev_stats->tx.tx_success.num; 11749 qdf_mem_free(vdev_stats); 11750 11751 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); 11752 return tx_success; 11753 } 11754 11755 #ifdef WLAN_SUPPORT_DATA_STALL 11756 /** 11757 * dp_register_data_stall_detect_cb() - register data stall callback 11758 * @soc_hdl: Datapath soc handle 11759 * @pdev_id: id of data path pdev handle 11760 * @data_stall_detect_callback: data stall callback function 11761 * 11762 * Return: QDF_STATUS Enumeration 11763 */ 11764 static 11765 QDF_STATUS dp_register_data_stall_detect_cb( 11766 struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 11767 data_stall_detect_cb data_stall_detect_callback) 11768 { 11769 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11770 struct dp_pdev *pdev; 11771 11772 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11773 if (!pdev) { 11774 dp_err("pdev NULL!"); 11775 return QDF_STATUS_E_INVAL; 11776 } 11777 11778 pdev->data_stall_detect_callback = data_stall_detect_callback; 11779 return QDF_STATUS_SUCCESS; 11780 } 11781 11782 /** 11783 * dp_deregister_data_stall_detect_cb() - de-register data stall callback 11784 * @soc_hdl: Datapath soc handle 11785 * @pdev_id: id of data path pdev handle 11786 * @data_stall_detect_callback: data stall callback function 11787 * 11788 * Return: QDF_STATUS Enumeration 11789 */ 11790 static 11791 QDF_STATUS dp_deregister_data_stall_detect_cb( 11792 struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 11793 data_stall_detect_cb data_stall_detect_callback) 11794 { 11795 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11796 struct dp_pdev *pdev; 11797 11798 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11799 if (!pdev) { 11800 dp_err("pdev NULL!"); 11801 return QDF_STATUS_E_INVAL; 11802 } 11803 11804 pdev->data_stall_detect_callback = NULL; 11805 return QDF_STATUS_SUCCESS; 11806 } 11807 11808 /** 11809 * dp_txrx_post_data_stall_event() - post data stall event 11810 * @soc_hdl: Datapath soc handle 11811 * @indicator: Module triggering data stall 11812 * @data_stall_type: data stall event type 11813 * @pdev_id: pdev id 11814 * @vdev_id_bitmap: vdev id bitmap 11815 * @recovery_type: data stall recovery type 11816 * 11817 * Return: None 11818 */ 11819 static void 11820 dp_txrx_post_data_stall_event(struct cdp_soc_t *soc_hdl, 11821 enum data_stall_log_event_indicator indicator, 11822 enum data_stall_log_event_type data_stall_type, 11823 uint32_t pdev_id, uint32_t vdev_id_bitmap, 11824 enum data_stall_log_recovery_type recovery_type) 11825 { 11826 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11827 struct data_stall_event_info data_stall_info; 11828 struct dp_pdev *pdev; 11829 11830 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11831 if (!pdev) { 11832 dp_err("pdev NULL!"); 11833 return; 11834 } 11835 11836 if (!pdev->data_stall_detect_callback) { 11837 dp_err("data stall cb not registered!"); 11838 return; 11839 } 11840 11841 dp_info("data_stall_type: %x pdev_id: %d", 11842 data_stall_type, pdev_id); 11843 11844 data_stall_info.indicator = indicator; 11845 data_stall_info.data_stall_type = data_stall_type; 11846 data_stall_info.vdev_id_bitmap = vdev_id_bitmap; 11847 data_stall_info.pdev_id = pdev_id; 11848 data_stall_info.recovery_type = recovery_type; 11849 11850 pdev->data_stall_detect_callback(&data_stall_info); 11851 } 11852 #endif /* WLAN_SUPPORT_DATA_STALL */ 11853 11854 #ifdef WLAN_FEATURE_STATS_EXT 11855 /** 11856 * dp_txrx_ext_stats_request() - request dp txrx extended stats request 11857 * @soc_hdl: soc handle 11858 * @pdev_id: pdev id 11859 * @req: stats request 11860 * 11861 * Return: QDF_STATUS 11862 */ 11863 static QDF_STATUS 11864 dp_txrx_ext_stats_request(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 11865 struct cdp_txrx_ext_stats *req) 11866 { 11867 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 11868 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11869 int i = 0; 11870 int tcl_ring_full = 0; 11871 11872 if (!pdev) { 11873 dp_err("pdev is null"); 11874 return QDF_STATUS_E_INVAL; 11875 } 11876 11877 dp_aggregate_pdev_stats(pdev); 11878 11879 for(i = 0 ; i < MAX_TCL_DATA_RINGS; i++) 11880 tcl_ring_full += soc->stats.tx.tcl_ring_full[i]; 11881 11882 req->tx_msdu_enqueue = pdev->stats.tx_i.processed.num; 11883 req->tx_msdu_overflow = tcl_ring_full; 11884 /* Error rate at LMAC */ 11885 req->rx_mpdu_received = soc->ext_stats.rx_mpdu_received + 11886 pdev->stats.err.fw_reported_rxdma_error; 11887 /* only count error source from RXDMA */ 11888 req->rx_mpdu_error = pdev->stats.err.fw_reported_rxdma_error; 11889 11890 /* Error rate at above the MAC */ 11891 req->rx_mpdu_delivered = soc->ext_stats.rx_mpdu_received; 11892 req->rx_mpdu_missed = pdev->stats.err.reo_error; 11893 11894 dp_info("ext stats: tx_msdu_enq = %u, tx_msdu_overflow = %u, " 11895 "rx_mpdu_receive = %u, rx_mpdu_delivered = %u, " 11896 "rx_mpdu_missed = %u, rx_mpdu_error = %u", 11897 req->tx_msdu_enqueue, 11898 req->tx_msdu_overflow, 11899 req->rx_mpdu_received, 11900 req->rx_mpdu_delivered, 11901 req->rx_mpdu_missed, 11902 req->rx_mpdu_error); 11903 11904 return QDF_STATUS_SUCCESS; 11905 } 11906 11907 #endif /* WLAN_FEATURE_STATS_EXT */ 11908 11909 #ifdef WLAN_FEATURE_MARK_FIRST_WAKEUP_PACKET 11910 /** 11911 * dp_mark_first_wakeup_packet() - set flag to indicate that 11912 * fw is compatible for marking first packet after wow wakeup 11913 * @soc_hdl: Datapath soc handle 11914 * @pdev_id: id of data path pdev handle 11915 * @value: 1 for enabled/ 0 for disabled 11916 * 11917 * Return: None 11918 */ 11919 static void dp_mark_first_wakeup_packet(struct cdp_soc_t *soc_hdl, 11920 uint8_t pdev_id, uint8_t value) 11921 { 11922 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11923 struct dp_pdev *pdev; 11924 11925 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11926 if (!pdev) { 11927 dp_err("pdev is NULL"); 11928 return; 11929 } 11930 11931 pdev->is_first_wakeup_packet = value; 11932 } 11933 #endif 11934 11935 #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF 11936 /** 11937 * dp_set_peer_txq_flush_config() - Set the peer txq flush configuration 11938 * @soc_hdl: Opaque handle to the DP soc object 11939 * @vdev_id: VDEV identifier 11940 * @mac: MAC address of the peer 11941 * @ac: access category mask 11942 * @tid: TID mask 11943 * @policy: Flush policy 11944 * 11945 * Return: 0 on success, errno on failure 11946 */ 11947 static int dp_set_peer_txq_flush_config(struct cdp_soc_t *soc_hdl, 11948 uint8_t vdev_id, uint8_t *mac, 11949 uint8_t ac, uint32_t tid, 11950 enum cdp_peer_txq_flush_policy policy) 11951 { 11952 struct dp_soc *soc; 11953 11954 if (!soc_hdl) { 11955 dp_err("soc is null"); 11956 return -EINVAL; 11957 } 11958 soc = cdp_soc_t_to_dp_soc(soc_hdl); 11959 return target_if_peer_txq_flush_config(soc->ctrl_psoc, vdev_id, 11960 mac, ac, tid, policy); 11961 } 11962 #endif 11963 11964 #ifdef CONNECTIVITY_PKTLOG 11965 /** 11966 * dp_register_packetdump_callback() - registers 11967 * tx data packet, tx mgmt. packet and rx data packet 11968 * dump callback handler. 11969 * 11970 * @soc_hdl: Datapath soc handle 11971 * @pdev_id: id of data path pdev handle 11972 * @dp_tx_packetdump_cb: tx packetdump cb 11973 * @dp_rx_packetdump_cb: rx packetdump cb 11974 * 11975 * This function is used to register tx data pkt, tx mgmt. 11976 * pkt and rx data pkt dump callback 11977 * 11978 * Return: None 11979 * 11980 */ 11981 static inline 11982 void dp_register_packetdump_callback(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 11983 ol_txrx_pktdump_cb dp_tx_packetdump_cb, 11984 ol_txrx_pktdump_cb dp_rx_packetdump_cb) 11985 { 11986 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 11987 struct dp_pdev *pdev; 11988 11989 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 11990 if (!pdev) { 11991 dp_err("pdev is NULL!"); 11992 return; 11993 } 11994 11995 pdev->dp_tx_packetdump_cb = dp_tx_packetdump_cb; 11996 pdev->dp_rx_packetdump_cb = dp_rx_packetdump_cb; 11997 } 11998 11999 /** 12000 * dp_deregister_packetdump_callback() - deregidters 12001 * tx data packet, tx mgmt. packet and rx data packet 12002 * dump callback handler 12003 * @soc_hdl: Datapath soc handle 12004 * @pdev_id: id of data path pdev handle 12005 * 12006 * This function is used to deregidter tx data pkt., 12007 * tx mgmt. pkt and rx data pkt. dump callback 12008 * 12009 * Return: None 12010 * 12011 */ 12012 static inline 12013 void dp_deregister_packetdump_callback(struct cdp_soc_t *soc_hdl, 12014 uint8_t pdev_id) 12015 { 12016 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12017 struct dp_pdev *pdev; 12018 12019 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12020 if (!pdev) { 12021 dp_err("pdev is NULL!"); 12022 return; 12023 } 12024 12025 pdev->dp_tx_packetdump_cb = NULL; 12026 pdev->dp_rx_packetdump_cb = NULL; 12027 } 12028 #endif 12029 12030 #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER 12031 /** 12032 * dp_set_bus_vote_lvl_high() - Take a vote on bus bandwidth from dp 12033 * @soc_hdl: Datapath soc handle 12034 * @high: whether the bus bw is high or not 12035 * 12036 * Return: void 12037 */ 12038 static void 12039 dp_set_bus_vote_lvl_high(ol_txrx_soc_handle soc_hdl, bool high) 12040 { 12041 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12042 12043 soc->high_throughput = high; 12044 } 12045 12046 /** 12047 * dp_get_bus_vote_lvl_high() - get bus bandwidth vote to dp 12048 * @soc_hdl: Datapath soc handle 12049 * 12050 * Return: bool 12051 */ 12052 static bool 12053 dp_get_bus_vote_lvl_high(ol_txrx_soc_handle soc_hdl) 12054 { 12055 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12056 12057 return soc->high_throughput; 12058 } 12059 #endif 12060 12061 #ifdef DP_PEER_EXTENDED_API 12062 static struct cdp_misc_ops dp_ops_misc = { 12063 #ifdef FEATURE_WLAN_TDLS 12064 .tx_non_std = dp_tx_non_std, 12065 #endif /* FEATURE_WLAN_TDLS */ 12066 .get_opmode = dp_get_opmode, 12067 #ifdef FEATURE_RUNTIME_PM 12068 .runtime_suspend = dp_runtime_suspend, 12069 .runtime_resume = dp_runtime_resume, 12070 #endif /* FEATURE_RUNTIME_PM */ 12071 .get_num_rx_contexts = dp_get_num_rx_contexts, 12072 .get_tx_ack_stats = dp_tx_get_success_ack_stats, 12073 #ifdef WLAN_SUPPORT_DATA_STALL 12074 .txrx_data_stall_cb_register = dp_register_data_stall_detect_cb, 12075 .txrx_data_stall_cb_deregister = dp_deregister_data_stall_detect_cb, 12076 .txrx_post_data_stall_event = dp_txrx_post_data_stall_event, 12077 #endif 12078 12079 #ifdef WLAN_FEATURE_STATS_EXT 12080 .txrx_ext_stats_request = dp_txrx_ext_stats_request, 12081 #ifndef WLAN_SOFTUMAC_SUPPORT 12082 .request_rx_hw_stats = dp_request_rx_hw_stats, 12083 .reset_rx_hw_ext_stats = dp_reset_rx_hw_ext_stats, 12084 #endif 12085 #endif /* WLAN_FEATURE_STATS_EXT */ 12086 .vdev_inform_ll_conn = dp_vdev_inform_ll_conn, 12087 #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR 12088 .set_swlm_enable = dp_soc_set_swlm_enable, 12089 .is_swlm_enabled = dp_soc_is_swlm_enabled, 12090 #endif 12091 .display_txrx_hw_info = dp_display_srng_info, 12092 #ifndef WLAN_SOFTUMAC_SUPPORT 12093 .get_tx_rings_grp_bitmap = dp_get_tx_rings_grp_bitmap, 12094 #endif 12095 #ifdef WLAN_FEATURE_MARK_FIRST_WAKEUP_PACKET 12096 .mark_first_wakeup_packet = dp_mark_first_wakeup_packet, 12097 #endif 12098 #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF 12099 .set_peer_txq_flush_config = dp_set_peer_txq_flush_config, 12100 #endif 12101 #ifdef CONNECTIVITY_PKTLOG 12102 .register_pktdump_cb = dp_register_packetdump_callback, 12103 .unregister_pktdump_cb = dp_deregister_packetdump_callback, 12104 #endif 12105 #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER 12106 .set_bus_vote_lvl_high = dp_set_bus_vote_lvl_high, 12107 .get_bus_vote_lvl_high = dp_get_bus_vote_lvl_high, 12108 #endif 12109 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 12110 .evaluate_update_tx_ilp_cfg = dp_evaluate_update_tx_ilp_config, 12111 #endif 12112 }; 12113 #endif 12114 12115 #ifdef DP_FLOW_CTL 12116 static struct cdp_flowctl_ops dp_ops_flowctl = { 12117 /* WIFI 3.0 DP implement as required. */ 12118 #ifdef QCA_LL_TX_FLOW_CONTROL_V2 12119 #ifndef WLAN_SOFTUMAC_SUPPORT 12120 .flow_pool_map_handler = dp_tx_flow_pool_map, 12121 .flow_pool_unmap_handler = dp_tx_flow_pool_unmap, 12122 #endif /*WLAN_SOFTUMAC_SUPPORT */ 12123 .register_pause_cb = dp_txrx_register_pause_cb, 12124 .dump_flow_pool_info = dp_tx_dump_flow_pool_info, 12125 .tx_desc_thresh_reached = dp_tx_desc_thresh_reached, 12126 #endif /* QCA_LL_TX_FLOW_CONTROL_V2 */ 12127 }; 12128 12129 static struct cdp_lflowctl_ops dp_ops_l_flowctl = { 12130 /* WIFI 3.0 DP NOT IMPLEMENTED YET */ 12131 }; 12132 #endif 12133 12134 #ifdef IPA_OFFLOAD 12135 static struct cdp_ipa_ops dp_ops_ipa = { 12136 .ipa_get_resource = dp_ipa_get_resource, 12137 .ipa_set_doorbell_paddr = dp_ipa_set_doorbell_paddr, 12138 .ipa_iounmap_doorbell_vaddr = dp_ipa_iounmap_doorbell_vaddr, 12139 .ipa_op_response = dp_ipa_op_response, 12140 .ipa_register_op_cb = dp_ipa_register_op_cb, 12141 .ipa_deregister_op_cb = dp_ipa_deregister_op_cb, 12142 .ipa_get_stat = dp_ipa_get_stat, 12143 .ipa_tx_data_frame = dp_tx_send_ipa_data_frame, 12144 .ipa_enable_autonomy = dp_ipa_enable_autonomy, 12145 .ipa_disable_autonomy = dp_ipa_disable_autonomy, 12146 .ipa_setup = dp_ipa_setup, 12147 .ipa_cleanup = dp_ipa_cleanup, 12148 .ipa_setup_iface = dp_ipa_setup_iface, 12149 .ipa_cleanup_iface = dp_ipa_cleanup_iface, 12150 .ipa_enable_pipes = dp_ipa_enable_pipes, 12151 .ipa_disable_pipes = dp_ipa_disable_pipes, 12152 .ipa_set_perf_level = dp_ipa_set_perf_level, 12153 .ipa_rx_intrabss_fwd = dp_ipa_rx_intrabss_fwd, 12154 .ipa_tx_buf_smmu_mapping = dp_ipa_tx_buf_smmu_mapping, 12155 .ipa_tx_buf_smmu_unmapping = dp_ipa_tx_buf_smmu_unmapping, 12156 .ipa_rx_buf_smmu_pool_mapping = dp_ipa_rx_buf_pool_smmu_mapping, 12157 .ipa_set_smmu_mapped = dp_ipa_set_smmu_mapped, 12158 .ipa_get_smmu_mapped = dp_ipa_get_smmu_mapped, 12159 #ifdef QCA_ENHANCED_STATS_SUPPORT 12160 .ipa_update_peer_rx_stats = dp_ipa_update_peer_rx_stats, 12161 #endif 12162 #ifdef IPA_OPT_WIFI_DP 12163 .ipa_rx_super_rule_setup = dp_ipa_rx_super_rule_setup, 12164 .ipa_pcie_link_up = dp_ipa_pcie_link_up, 12165 .ipa_pcie_link_down = dp_ipa_pcie_link_down, 12166 #endif 12167 #ifdef IPA_WDS_EASYMESH_FEATURE 12168 .ipa_ast_create = dp_ipa_ast_create, 12169 #endif 12170 .ipa_get_wdi_version = dp_ipa_get_wdi_version, 12171 }; 12172 #endif 12173 12174 #ifdef DP_POWER_SAVE 12175 static QDF_STATUS dp_bus_suspend(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 12176 { 12177 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12178 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12179 int timeout = SUSPEND_DRAIN_WAIT; 12180 int drain_wait_delay = 50; /* 50 ms */ 12181 int32_t tx_pending; 12182 12183 if (qdf_unlikely(!pdev)) { 12184 dp_err("pdev is NULL"); 12185 return QDF_STATUS_E_INVAL; 12186 } 12187 12188 /* Abort if there are any pending TX packets */ 12189 while ((tx_pending = dp_get_tx_pending((struct cdp_pdev *)pdev))) { 12190 qdf_sleep(drain_wait_delay); 12191 if (timeout <= 0) { 12192 dp_info("TX frames are pending %d, abort suspend", 12193 tx_pending); 12194 dp_find_missing_tx_comp(soc); 12195 return QDF_STATUS_E_TIMEOUT; 12196 } 12197 timeout = timeout - drain_wait_delay; 12198 } 12199 12200 if (soc->intr_mode == DP_INTR_POLL) 12201 qdf_timer_stop(&soc->int_timer); 12202 12203 /* Stop monitor reap timer and reap any pending frames in ring */ 12204 dp_monitor_reap_timer_suspend(soc); 12205 12206 return QDF_STATUS_SUCCESS; 12207 } 12208 12209 static QDF_STATUS dp_bus_resume(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 12210 { 12211 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12212 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12213 12214 if (qdf_unlikely(!pdev)) { 12215 dp_err("pdev is NULL"); 12216 return QDF_STATUS_E_INVAL; 12217 } 12218 12219 if (soc->intr_mode == DP_INTR_POLL) 12220 qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); 12221 12222 /* Start monitor reap timer */ 12223 dp_monitor_reap_timer_start(soc, CDP_MON_REAP_SOURCE_ANY); 12224 12225 soc->arch_ops.dp_update_ring_hptp(soc, false); 12226 12227 return QDF_STATUS_SUCCESS; 12228 } 12229 12230 /** 12231 * dp_process_wow_ack_rsp() - process wow ack response 12232 * @soc_hdl: datapath soc handle 12233 * @pdev_id: data path pdev handle id 12234 * 12235 * Return: none 12236 */ 12237 static void dp_process_wow_ack_rsp(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 12238 { 12239 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12240 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12241 12242 if (qdf_unlikely(!pdev)) { 12243 dp_err("pdev is NULL"); 12244 return; 12245 } 12246 12247 /* 12248 * As part of wow enable FW disables the mon status ring and in wow ack 12249 * response from FW reap mon status ring to make sure no packets pending 12250 * in the ring. 12251 */ 12252 dp_monitor_reap_timer_suspend(soc); 12253 } 12254 12255 /** 12256 * dp_process_target_suspend_req() - process target suspend request 12257 * @soc_hdl: datapath soc handle 12258 * @pdev_id: data path pdev handle id 12259 * 12260 * Return: none 12261 */ 12262 static void dp_process_target_suspend_req(struct cdp_soc_t *soc_hdl, 12263 uint8_t pdev_id) 12264 { 12265 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12266 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12267 12268 if (qdf_unlikely(!pdev)) { 12269 dp_err("pdev is NULL"); 12270 return; 12271 } 12272 12273 /* Stop monitor reap timer and reap any pending frames in ring */ 12274 dp_monitor_reap_timer_suspend(soc); 12275 } 12276 12277 static struct cdp_bus_ops dp_ops_bus = { 12278 .bus_suspend = dp_bus_suspend, 12279 .bus_resume = dp_bus_resume, 12280 .process_wow_ack_rsp = dp_process_wow_ack_rsp, 12281 .process_target_suspend_req = dp_process_target_suspend_req 12282 }; 12283 #endif 12284 12285 #ifdef DP_FLOW_CTL 12286 static struct cdp_throttle_ops dp_ops_throttle = { 12287 /* WIFI 3.0 DP NOT IMPLEMENTED YET */ 12288 }; 12289 12290 static struct cdp_cfg_ops dp_ops_cfg = { 12291 /* WIFI 3.0 DP NOT IMPLEMENTED YET */ 12292 }; 12293 #endif 12294 12295 #ifdef DP_PEER_EXTENDED_API 12296 static struct cdp_ocb_ops dp_ops_ocb = { 12297 /* WIFI 3.0 DP NOT IMPLEMENTED YET */ 12298 }; 12299 12300 static struct cdp_mob_stats_ops dp_ops_mob_stats = { 12301 .clear_stats = dp_txrx_clear_dump_stats, 12302 }; 12303 12304 static struct cdp_peer_ops dp_ops_peer = { 12305 .register_peer = dp_register_peer, 12306 .clear_peer = dp_clear_peer, 12307 .find_peer_exist = dp_find_peer_exist, 12308 .find_peer_exist_on_vdev = dp_find_peer_exist_on_vdev, 12309 .find_peer_exist_on_other_vdev = dp_find_peer_exist_on_other_vdev, 12310 .peer_state_update = dp_peer_state_update, 12311 .get_vdevid = dp_get_vdevid, 12312 .get_vdev_by_peer_addr = dp_get_vdev_by_peer_addr, 12313 .peer_get_peer_mac_addr = dp_peer_get_peer_mac_addr, 12314 .get_peer_state = dp_get_peer_state, 12315 .peer_flush_frags = dp_peer_flush_frags, 12316 .set_peer_as_tdls_peer = dp_set_peer_as_tdls_peer, 12317 }; 12318 #endif 12319 12320 static void dp_soc_txrx_ops_attach(struct dp_soc *soc) 12321 { 12322 soc->cdp_soc.ops->cmn_drv_ops = &dp_ops_cmn; 12323 soc->cdp_soc.ops->ctrl_ops = &dp_ops_ctrl; 12324 soc->cdp_soc.ops->me_ops = &dp_ops_me; 12325 soc->cdp_soc.ops->host_stats_ops = &dp_ops_host_stats; 12326 soc->cdp_soc.ops->wds_ops = &dp_ops_wds; 12327 soc->cdp_soc.ops->raw_ops = &dp_ops_raw; 12328 #ifdef PEER_FLOW_CONTROL 12329 soc->cdp_soc.ops->pflow_ops = &dp_ops_pflow; 12330 #endif /* PEER_FLOW_CONTROL */ 12331 #ifdef DP_PEER_EXTENDED_API 12332 soc->cdp_soc.ops->misc_ops = &dp_ops_misc; 12333 soc->cdp_soc.ops->ocb_ops = &dp_ops_ocb; 12334 soc->cdp_soc.ops->peer_ops = &dp_ops_peer; 12335 soc->cdp_soc.ops->mob_stats_ops = &dp_ops_mob_stats; 12336 #endif 12337 #ifdef DP_FLOW_CTL 12338 soc->cdp_soc.ops->cfg_ops = &dp_ops_cfg; 12339 soc->cdp_soc.ops->flowctl_ops = &dp_ops_flowctl; 12340 soc->cdp_soc.ops->l_flowctl_ops = &dp_ops_l_flowctl; 12341 soc->cdp_soc.ops->throttle_ops = &dp_ops_throttle; 12342 #endif 12343 #ifdef IPA_OFFLOAD 12344 soc->cdp_soc.ops->ipa_ops = &dp_ops_ipa; 12345 #endif 12346 #ifdef DP_POWER_SAVE 12347 soc->cdp_soc.ops->bus_ops = &dp_ops_bus; 12348 #endif 12349 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) 12350 soc->cdp_soc.ops->cfr_ops = &dp_ops_cfr; 12351 #endif 12352 #ifdef WLAN_SUPPORT_MSCS 12353 soc->cdp_soc.ops->mscs_ops = &dp_ops_mscs; 12354 #endif 12355 #ifdef WLAN_SUPPORT_MESH_LATENCY 12356 soc->cdp_soc.ops->mesh_latency_ops = &dp_ops_mesh_latency; 12357 #endif 12358 #ifdef CONFIG_SAWF_DEF_QUEUES 12359 soc->cdp_soc.ops->sawf_ops = &dp_ops_sawf; 12360 #endif 12361 #ifdef WLAN_SUPPORT_SCS 12362 soc->cdp_soc.ops->scs_ops = &dp_ops_scs; 12363 #endif 12364 #ifdef WLAN_SUPPORT_RX_FLOW_TAG 12365 soc->cdp_soc.ops->fse_ops = &dp_ops_fse; 12366 #endif 12367 }; 12368 12369 #if defined(QCA_WIFI_QCA8074) || defined(QCA_WIFI_QCA6018) || \ 12370 defined(QCA_WIFI_QCA5018) || defined(QCA_WIFI_QCA9574) || \ 12371 defined(QCA_WIFI_QCA5332) 12372 12373 /** 12374 * dp_soc_attach_wifi3() - Attach txrx SOC 12375 * @ctrl_psoc: Opaque SOC handle from control plane 12376 * @params: SOC attach params 12377 * 12378 * Return: DP SOC handle on success, NULL on failure 12379 */ 12380 struct cdp_soc_t * 12381 dp_soc_attach_wifi3(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, 12382 struct cdp_soc_attach_params *params) 12383 { 12384 struct dp_soc *dp_soc = NULL; 12385 12386 dp_soc = dp_soc_attach(ctrl_psoc, params); 12387 12388 return dp_soc_to_cdp_soc_t(dp_soc); 12389 } 12390 12391 static inline void dp_soc_set_def_pdev(struct dp_soc *soc) 12392 { 12393 int lmac_id; 12394 12395 for (lmac_id = 0; lmac_id < MAX_NUM_LMAC_HW; lmac_id++) { 12396 /*Set default host PDEV ID for lmac_id*/ 12397 wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, 12398 INVALID_PDEV_ID, lmac_id); 12399 } 12400 } 12401 12402 static void dp_soc_unset_qref_debug_list(struct dp_soc *soc) 12403 { 12404 uint32_t max_list_size = soc->wlan_cfg_ctx->qref_control_size; 12405 12406 if (max_list_size == 0) 12407 return; 12408 12409 qdf_mem_free(soc->list_shared_qaddr_del); 12410 qdf_mem_free(soc->reo_write_list); 12411 qdf_mem_free(soc->list_qdesc_addr_free); 12412 qdf_mem_free(soc->list_qdesc_addr_alloc); 12413 } 12414 12415 static void dp_soc_set_qref_debug_list(struct dp_soc *soc) 12416 { 12417 uint32_t max_list_size = soc->wlan_cfg_ctx->qref_control_size; 12418 12419 if (max_list_size == 0) 12420 return; 12421 12422 soc->list_shared_qaddr_del = 12423 (struct test_qaddr_del *) 12424 qdf_mem_malloc(sizeof(struct test_qaddr_del) * 12425 max_list_size); 12426 soc->reo_write_list = 12427 (struct test_qaddr_del *) 12428 qdf_mem_malloc(sizeof(struct test_qaddr_del) * 12429 max_list_size); 12430 soc->list_qdesc_addr_free = 12431 (struct test_mem_free *) 12432 qdf_mem_malloc(sizeof(struct test_mem_free) * 12433 max_list_size); 12434 soc->list_qdesc_addr_alloc = 12435 (struct test_mem_free *) 12436 qdf_mem_malloc(sizeof(struct test_mem_free) * 12437 max_list_size); 12438 } 12439 12440 static uint32_t 12441 dp_get_link_desc_id_start(uint16_t arch_id) 12442 { 12443 switch (arch_id) { 12444 case CDP_ARCH_TYPE_LI: 12445 case CDP_ARCH_TYPE_RH: 12446 return LINK_DESC_ID_START_21_BITS_COOKIE; 12447 case CDP_ARCH_TYPE_BE: 12448 return LINK_DESC_ID_START_20_BITS_COOKIE; 12449 default: 12450 dp_err("unknown arch_id 0x%x", arch_id); 12451 QDF_BUG(0); 12452 return LINK_DESC_ID_START_21_BITS_COOKIE; 12453 } 12454 } 12455 12456 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 12457 static inline 12458 void dp_soc_init_tx_ilp(struct dp_soc *soc) 12459 { 12460 soc->tx_ilp_enable = false; 12461 } 12462 #else 12463 static inline 12464 void dp_soc_init_tx_ilp(struct dp_soc *soc) 12465 { 12466 } 12467 #endif 12468 12469 /** 12470 * dp_soc_attach() - Attach txrx SOC 12471 * @ctrl_psoc: Opaque SOC handle from control plane 12472 * @params: SOC attach params 12473 * 12474 * Return: DP SOC handle on success, NULL on failure 12475 */ 12476 static struct dp_soc * 12477 dp_soc_attach(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, 12478 struct cdp_soc_attach_params *params) 12479 { 12480 struct dp_soc *soc = NULL; 12481 uint16_t arch_id; 12482 struct hif_opaque_softc *hif_handle = params->hif_handle; 12483 qdf_device_t qdf_osdev = params->qdf_osdev; 12484 struct ol_if_ops *ol_ops = params->ol_ops; 12485 uint16_t device_id = params->device_id; 12486 12487 if (!hif_handle) { 12488 dp_err("HIF handle is NULL"); 12489 goto fail0; 12490 } 12491 arch_id = cdp_get_arch_type_from_devid(device_id); 12492 soc = qdf_mem_common_alloc(dp_get_soc_context_size(device_id)); 12493 if (!soc) { 12494 dp_err("DP SOC memory allocation failed"); 12495 goto fail0; 12496 } 12497 12498 dp_info("soc memory allocated %pK", soc); 12499 soc->hif_handle = hif_handle; 12500 soc->hal_soc = hif_get_hal_handle(soc->hif_handle); 12501 if (!soc->hal_soc) 12502 goto fail1; 12503 12504 hif_get_cmem_info(soc->hif_handle, 12505 &soc->cmem_base, 12506 &soc->cmem_total_size); 12507 soc->cmem_avail_size = soc->cmem_total_size; 12508 soc->device_id = device_id; 12509 soc->cdp_soc.ops = 12510 (struct cdp_ops *)qdf_mem_malloc(sizeof(struct cdp_ops)); 12511 if (!soc->cdp_soc.ops) 12512 goto fail1; 12513 12514 dp_soc_txrx_ops_attach(soc); 12515 soc->cdp_soc.ol_ops = ol_ops; 12516 soc->ctrl_psoc = ctrl_psoc; 12517 soc->osdev = qdf_osdev; 12518 soc->num_hw_dscp_tid_map = HAL_MAX_HW_DSCP_TID_MAPS; 12519 dp_soc_init_tx_ilp(soc); 12520 hal_rx_get_tlv_size(soc->hal_soc, &soc->rx_pkt_tlv_size, 12521 &soc->rx_mon_pkt_tlv_size); 12522 soc->idle_link_bm_id = hal_get_idle_link_bm_id(soc->hal_soc, 12523 params->mlo_chip_id); 12524 soc->features.dmac_cmn_src_rxbuf_ring_enabled = 12525 hal_dmac_cmn_src_rxbuf_ring_get(soc->hal_soc); 12526 soc->arch_id = arch_id; 12527 soc->link_desc_id_start = 12528 dp_get_link_desc_id_start(soc->arch_id); 12529 dp_configure_arch_ops(soc); 12530 12531 /* Reset wbm sg list and flags */ 12532 dp_rx_wbm_sg_list_reset(soc); 12533 12534 dp_soc_cfg_history_attach(soc); 12535 dp_soc_tx_hw_desc_history_attach(soc); 12536 dp_soc_rx_history_attach(soc); 12537 dp_soc_mon_status_ring_history_attach(soc); 12538 dp_soc_tx_history_attach(soc); 12539 wlan_set_srng_cfg(&soc->wlan_srng_cfg); 12540 soc->wlan_cfg_ctx = wlan_cfg_soc_attach(soc->ctrl_psoc); 12541 if (!soc->wlan_cfg_ctx) { 12542 dp_err("wlan_cfg_ctx failed"); 12543 goto fail2; 12544 } 12545 12546 /*sync DP soc cfg items with profile support after cfg_soc_attach*/ 12547 wlan_dp_soc_cfg_sync_profile((struct cdp_soc_t *)soc); 12548 12549 soc->arch_ops.soc_cfg_attach(soc); 12550 12551 if (dp_hw_link_desc_pool_banks_alloc(soc, WLAN_INVALID_PDEV_ID)) { 12552 dp_err("failed to allocate link desc pool banks"); 12553 goto fail3; 12554 } 12555 12556 if (dp_hw_link_desc_ring_alloc(soc)) { 12557 dp_err("failed to allocate link_desc_ring"); 12558 goto fail4; 12559 } 12560 12561 if (!QDF_IS_STATUS_SUCCESS(soc->arch_ops.txrx_soc_attach(soc, 12562 params))) { 12563 dp_err("unable to do target specific attach"); 12564 goto fail5; 12565 } 12566 12567 if (dp_soc_srng_alloc(soc)) { 12568 dp_err("failed to allocate soc srng rings"); 12569 goto fail6; 12570 } 12571 12572 if (dp_soc_tx_desc_sw_pools_alloc(soc)) { 12573 dp_err("dp_soc_tx_desc_sw_pools_alloc failed"); 12574 goto fail7; 12575 } 12576 12577 if (!dp_monitor_modularized_enable()) { 12578 if (dp_mon_soc_attach_wrapper(soc)) { 12579 dp_err("failed to attach monitor"); 12580 goto fail8; 12581 } 12582 } 12583 12584 if (hal_reo_shared_qaddr_setup((hal_soc_handle_t)soc->hal_soc, 12585 &soc->reo_qref) 12586 != QDF_STATUS_SUCCESS) { 12587 dp_err("unable to setup reo shared qaddr"); 12588 goto fail9; 12589 } 12590 12591 if (dp_sysfs_initialize_stats(soc) != QDF_STATUS_SUCCESS) { 12592 dp_err("failed to initialize dp stats sysfs file"); 12593 dp_sysfs_deinitialize_stats(soc); 12594 } 12595 12596 dp_soc_swlm_attach(soc); 12597 dp_soc_set_interrupt_mode(soc); 12598 dp_soc_set_def_pdev(soc); 12599 dp_soc_set_qref_debug_list(soc); 12600 12601 dp_info("Mem stats: DMA = %u HEAP = %u SKB = %u", 12602 qdf_dma_mem_stats_read(), 12603 qdf_heap_mem_stats_read(), 12604 qdf_skb_total_mem_stats_read()); 12605 12606 return soc; 12607 fail9: 12608 if (!dp_monitor_modularized_enable()) 12609 dp_mon_soc_detach_wrapper(soc); 12610 fail8: 12611 dp_soc_tx_desc_sw_pools_free(soc); 12612 fail7: 12613 dp_soc_srng_free(soc); 12614 fail6: 12615 soc->arch_ops.txrx_soc_detach(soc); 12616 fail5: 12617 dp_hw_link_desc_ring_free(soc); 12618 fail4: 12619 dp_hw_link_desc_pool_banks_free(soc, WLAN_INVALID_PDEV_ID); 12620 fail3: 12621 wlan_cfg_soc_detach(soc->wlan_cfg_ctx); 12622 fail2: 12623 qdf_mem_free(soc->cdp_soc.ops); 12624 fail1: 12625 qdf_mem_common_free(soc); 12626 fail0: 12627 return NULL; 12628 } 12629 12630 void *dp_soc_init_wifi3(struct cdp_soc_t *cdp_soc, 12631 struct cdp_ctrl_objmgr_psoc *ctrl_psoc, 12632 struct hif_opaque_softc *hif_handle, 12633 HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, 12634 struct ol_if_ops *ol_ops, uint16_t device_id) 12635 { 12636 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 12637 12638 return soc->arch_ops.txrx_soc_init(soc, htc_handle, hif_handle); 12639 } 12640 12641 #endif 12642 12643 void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id) 12644 { 12645 if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) 12646 return (mac_id < MAX_PDEV_CNT) ? soc->pdev_list[mac_id] : NULL; 12647 12648 /* Typically for MCL as there only 1 PDEV*/ 12649 return soc->pdev_list[0]; 12650 } 12651 12652 void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc, 12653 int *max_mac_rings) 12654 { 12655 bool dbs_enable = false; 12656 12657 if (soc->cdp_soc.ol_ops->is_hw_dbs_capable) 12658 dbs_enable = soc->cdp_soc.ol_ops-> 12659 is_hw_dbs_capable((void *)soc->ctrl_psoc); 12660 12661 *max_mac_rings = dbs_enable ? (*max_mac_rings) : 1; 12662 dp_info("dbs_enable %d, max_mac_rings %d", 12663 dbs_enable, *max_mac_rings); 12664 } 12665 12666 qdf_export_symbol(dp_update_num_mac_rings_for_dbs); 12667 12668 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) 12669 /** 12670 * dp_get_cfr_rcc() - get cfr rcc config 12671 * @soc_hdl: Datapath soc handle 12672 * @pdev_id: id of objmgr pdev 12673 * 12674 * Return: true/false based on cfr mode setting 12675 */ 12676 static 12677 bool dp_get_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) 12678 { 12679 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12680 struct dp_pdev *pdev = NULL; 12681 12682 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12683 if (!pdev) { 12684 dp_err("pdev is NULL"); 12685 return false; 12686 } 12687 12688 return pdev->cfr_rcc_mode; 12689 } 12690 12691 /** 12692 * dp_set_cfr_rcc() - enable/disable cfr rcc config 12693 * @soc_hdl: Datapath soc handle 12694 * @pdev_id: id of objmgr pdev 12695 * @enable: Enable/Disable cfr rcc mode 12696 * 12697 * Return: none 12698 */ 12699 static 12700 void dp_set_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, bool enable) 12701 { 12702 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12703 struct dp_pdev *pdev = NULL; 12704 12705 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12706 if (!pdev) { 12707 dp_err("pdev is NULL"); 12708 return; 12709 } 12710 12711 pdev->cfr_rcc_mode = enable; 12712 } 12713 12714 /** 12715 * dp_get_cfr_dbg_stats - Get the debug statistics for CFR 12716 * @soc_hdl: Datapath soc handle 12717 * @pdev_id: id of data path pdev handle 12718 * @cfr_rcc_stats: CFR RCC debug statistics buffer 12719 * 12720 * Return: none 12721 */ 12722 static inline void 12723 dp_get_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, 12724 struct cdp_cfr_rcc_stats *cfr_rcc_stats) 12725 { 12726 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12727 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12728 12729 if (!pdev) { 12730 dp_err("pdev is NULL"); 12731 return; 12732 } 12733 12734 qdf_mem_copy(cfr_rcc_stats, &pdev->stats.rcc, 12735 sizeof(struct cdp_cfr_rcc_stats)); 12736 } 12737 12738 /** 12739 * dp_clear_cfr_dbg_stats - Clear debug statistics for CFR 12740 * @soc_hdl: Datapath soc handle 12741 * @pdev_id: id of data path pdev handle 12742 * 12743 * Return: none 12744 */ 12745 static void dp_clear_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, 12746 uint8_t pdev_id) 12747 { 12748 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 12749 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 12750 12751 if (!pdev) { 12752 dp_err("dp pdev is NULL"); 12753 return; 12754 } 12755 12756 qdf_mem_zero(&pdev->stats.rcc, sizeof(pdev->stats.rcc)); 12757 } 12758 #endif 12759 12760 /** 12761 * dp_bucket_index() - Return index from array 12762 * 12763 * @delay: delay measured 12764 * @array: array used to index corresponding delay 12765 * @delay_in_us: flag to indicate whether the delay in ms or us 12766 * 12767 * Return: index 12768 */ 12769 static uint8_t 12770 dp_bucket_index(uint32_t delay, uint16_t *array, bool delay_in_us) 12771 { 12772 uint8_t i = CDP_DELAY_BUCKET_0; 12773 uint32_t thr_low, thr_high; 12774 12775 for (; i < CDP_DELAY_BUCKET_MAX - 1; i++) { 12776 thr_low = array[i]; 12777 thr_high = array[i + 1]; 12778 12779 if (delay_in_us) { 12780 thr_low = thr_low * USEC_PER_MSEC; 12781 thr_high = thr_high * USEC_PER_MSEC; 12782 } 12783 if (delay >= thr_low && delay <= thr_high) 12784 return i; 12785 } 12786 return (CDP_DELAY_BUCKET_MAX - 1); 12787 } 12788 12789 #ifdef HW_TX_DELAY_STATS_ENABLE 12790 /* 12791 * cdp_fw_to_hw_delay_range 12792 * Fw to hw delay ranges in milliseconds 12793 */ 12794 static uint16_t cdp_fw_to_hw_delay[CDP_DELAY_BUCKET_MAX] = { 12795 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 250, 500}; 12796 #else 12797 static uint16_t cdp_fw_to_hw_delay[CDP_DELAY_BUCKET_MAX] = { 12798 0, 2, 4, 6, 8, 10, 20, 30, 40, 50, 100, 250, 500}; 12799 #endif 12800 12801 /* 12802 * cdp_sw_enq_delay_range 12803 * Software enqueue delay ranges in milliseconds 12804 */ 12805 static uint16_t cdp_sw_enq_delay[CDP_DELAY_BUCKET_MAX] = { 12806 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; 12807 12808 /* 12809 * cdp_intfrm_delay_range 12810 * Interframe delay ranges in milliseconds 12811 */ 12812 static uint16_t cdp_intfrm_delay[CDP_DELAY_BUCKET_MAX] = { 12813 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60}; 12814 12815 /** 12816 * dp_fill_delay_buckets() - Fill delay statistics bucket for each 12817 * type of delay 12818 * @tstats: tid tx stats 12819 * @rstats: tid rx stats 12820 * @delay: delay in ms 12821 * @tid: tid value 12822 * @mode: type of tx delay mode 12823 * @ring_id: ring number 12824 * @delay_in_us: flag to indicate whether the delay in ms or us 12825 * 12826 * Return: pointer to cdp_delay_stats structure 12827 */ 12828 static struct cdp_delay_stats * 12829 dp_fill_delay_buckets(struct cdp_tid_tx_stats *tstats, 12830 struct cdp_tid_rx_stats *rstats, uint32_t delay, 12831 uint8_t tid, uint8_t mode, uint8_t ring_id, 12832 bool delay_in_us) 12833 { 12834 uint8_t delay_index = 0; 12835 struct cdp_delay_stats *stats = NULL; 12836 12837 /* 12838 * Update delay stats in proper bucket 12839 */ 12840 switch (mode) { 12841 /* Software Enqueue delay ranges */ 12842 case CDP_DELAY_STATS_SW_ENQ: 12843 if (!tstats) 12844 break; 12845 12846 delay_index = dp_bucket_index(delay, cdp_sw_enq_delay, 12847 delay_in_us); 12848 tstats->swq_delay.delay_bucket[delay_index]++; 12849 stats = &tstats->swq_delay; 12850 break; 12851 12852 /* Tx Completion delay ranges */ 12853 case CDP_DELAY_STATS_FW_HW_TRANSMIT: 12854 if (!tstats) 12855 break; 12856 12857 delay_index = dp_bucket_index(delay, cdp_fw_to_hw_delay, 12858 delay_in_us); 12859 tstats->hwtx_delay.delay_bucket[delay_index]++; 12860 stats = &tstats->hwtx_delay; 12861 break; 12862 12863 /* Interframe tx delay ranges */ 12864 case CDP_DELAY_STATS_TX_INTERFRAME: 12865 if (!tstats) 12866 break; 12867 12868 delay_index = dp_bucket_index(delay, cdp_intfrm_delay, 12869 delay_in_us); 12870 tstats->intfrm_delay.delay_bucket[delay_index]++; 12871 stats = &tstats->intfrm_delay; 12872 break; 12873 12874 /* Interframe rx delay ranges */ 12875 case CDP_DELAY_STATS_RX_INTERFRAME: 12876 if (!rstats) 12877 break; 12878 12879 delay_index = dp_bucket_index(delay, cdp_intfrm_delay, 12880 delay_in_us); 12881 rstats->intfrm_delay.delay_bucket[delay_index]++; 12882 stats = &rstats->intfrm_delay; 12883 break; 12884 12885 /* Ring reap to indication to network stack */ 12886 case CDP_DELAY_STATS_REAP_STACK: 12887 if (!rstats) 12888 break; 12889 12890 delay_index = dp_bucket_index(delay, cdp_intfrm_delay, 12891 delay_in_us); 12892 rstats->to_stack_delay.delay_bucket[delay_index]++; 12893 stats = &rstats->to_stack_delay; 12894 break; 12895 default: 12896 dp_debug("Incorrect delay mode: %d", mode); 12897 } 12898 12899 return stats; 12900 } 12901 12902 void dp_update_delay_stats(struct cdp_tid_tx_stats *tstats, 12903 struct cdp_tid_rx_stats *rstats, uint32_t delay, 12904 uint8_t tid, uint8_t mode, uint8_t ring_id, 12905 bool delay_in_us) 12906 { 12907 struct cdp_delay_stats *dstats = NULL; 12908 12909 /* 12910 * Delay ranges are different for different delay modes 12911 * Get the correct index to update delay bucket 12912 */ 12913 dstats = dp_fill_delay_buckets(tstats, rstats, delay, tid, mode, 12914 ring_id, delay_in_us); 12915 if (qdf_unlikely(!dstats)) 12916 return; 12917 12918 if (delay != 0) { 12919 /* 12920 * Compute minimum,average and maximum 12921 * delay 12922 */ 12923 if (delay < dstats->min_delay) 12924 dstats->min_delay = delay; 12925 12926 if (delay > dstats->max_delay) 12927 dstats->max_delay = delay; 12928 12929 /* 12930 * Average over delay measured till now 12931 */ 12932 if (!dstats->avg_delay) 12933 dstats->avg_delay = delay; 12934 else 12935 dstats->avg_delay = ((delay + dstats->avg_delay) >> 1); 12936 } 12937 } 12938 12939 uint16_t dp_get_peer_mac_list(ol_txrx_soc_handle soc, uint8_t vdev_id, 12940 u_int8_t newmac[][QDF_MAC_ADDR_SIZE], 12941 u_int16_t mac_cnt, bool limit) 12942 { 12943 struct dp_soc *dp_soc = (struct dp_soc *)soc; 12944 struct dp_vdev *vdev = 12945 dp_vdev_get_ref_by_id(dp_soc, vdev_id, DP_MOD_ID_CDP); 12946 struct dp_peer *peer; 12947 uint16_t new_mac_cnt = 0; 12948 12949 if (!vdev) 12950 return new_mac_cnt; 12951 12952 if (limit && (vdev->num_peers > mac_cnt)) { 12953 dp_vdev_unref_delete(dp_soc, vdev, DP_MOD_ID_CDP); 12954 return 0; 12955 } 12956 12957 qdf_spin_lock_bh(&vdev->peer_list_lock); 12958 TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) { 12959 if (peer->bss_peer) 12960 continue; 12961 if (new_mac_cnt < mac_cnt) { 12962 WLAN_ADDR_COPY(newmac[new_mac_cnt], peer->mac_addr.raw); 12963 new_mac_cnt++; 12964 } 12965 } 12966 qdf_spin_unlock_bh(&vdev->peer_list_lock); 12967 dp_vdev_unref_delete(dp_soc, vdev, DP_MOD_ID_CDP); 12968 return new_mac_cnt; 12969 } 12970 12971 uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac) 12972 { 12973 struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, 12974 mac, 0, vdev_id, 12975 DP_MOD_ID_CDP); 12976 uint16_t peer_id = HTT_INVALID_PEER; 12977 12978 if (!peer) { 12979 dp_cdp_debug("%pK: Peer is NULL!", (struct dp_soc *)soc); 12980 return peer_id; 12981 } 12982 12983 peer_id = peer->peer_id; 12984 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 12985 return peer_id; 12986 } 12987 12988 #ifdef QCA_SUPPORT_WDS_EXTENDED 12989 QDF_STATUS dp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, 12990 uint8_t vdev_id, 12991 uint8_t *mac, 12992 ol_txrx_rx_fp rx, 12993 ol_osif_peer_handle osif_peer) 12994 { 12995 struct dp_txrx_peer *txrx_peer = NULL; 12996 struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, 12997 mac, 0, vdev_id, 12998 DP_MOD_ID_CDP); 12999 QDF_STATUS status = QDF_STATUS_E_INVAL; 13000 13001 if (!peer) { 13002 dp_cdp_debug("%pK: Peer is NULL!", (struct dp_soc *)soc); 13003 return status; 13004 } 13005 13006 txrx_peer = dp_get_txrx_peer(peer); 13007 if (!txrx_peer) { 13008 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 13009 return status; 13010 } 13011 13012 if (rx) { 13013 if (txrx_peer->osif_rx) { 13014 status = QDF_STATUS_E_ALREADY; 13015 } else { 13016 txrx_peer->osif_rx = rx; 13017 status = QDF_STATUS_SUCCESS; 13018 } 13019 } else { 13020 if (txrx_peer->osif_rx) { 13021 txrx_peer->osif_rx = NULL; 13022 status = QDF_STATUS_SUCCESS; 13023 } else { 13024 status = QDF_STATUS_E_ALREADY; 13025 } 13026 } 13027 13028 txrx_peer->wds_ext.osif_peer = osif_peer; 13029 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 13030 13031 return status; 13032 } 13033 13034 QDF_STATUS dp_wds_ext_get_peer_osif_handle( 13035 ol_txrx_soc_handle soc, 13036 uint8_t vdev_id, 13037 uint8_t *mac, 13038 ol_osif_peer_handle *osif_peer) 13039 { 13040 struct dp_soc *dp_soc = (struct dp_soc *)soc; 13041 struct dp_txrx_peer *txrx_peer = NULL; 13042 struct dp_peer *peer = dp_peer_find_hash_find(dp_soc, 13043 mac, 0, vdev_id, 13044 DP_MOD_ID_CDP); 13045 13046 if (!peer) { 13047 dp_cdp_debug("%pK: Peer is NULL!", dp_soc); 13048 return QDF_STATUS_E_INVAL; 13049 } 13050 13051 txrx_peer = dp_get_txrx_peer(peer); 13052 if (!txrx_peer) { 13053 dp_cdp_debug("%pK: TXRX Peer is NULL!", dp_soc); 13054 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 13055 return QDF_STATUS_E_INVAL; 13056 } 13057 13058 *osif_peer = txrx_peer->wds_ext.osif_peer; 13059 dp_peer_unref_delete(peer, DP_MOD_ID_CDP); 13060 13061 return QDF_STATUS_SUCCESS; 13062 } 13063 #endif /* QCA_SUPPORT_WDS_EXTENDED */ 13064 13065 /** 13066 * dp_pdev_srng_deinit() - de-initialize all pdev srng ring including 13067 * monitor rings 13068 * @pdev: Datapath pdev handle 13069 * 13070 */ 13071 static void dp_pdev_srng_deinit(struct dp_pdev *pdev) 13072 { 13073 struct dp_soc *soc = pdev->soc; 13074 uint8_t i; 13075 13076 if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) 13077 dp_srng_deinit(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], 13078 RXDMA_BUF, 13079 pdev->lmac_id); 13080 13081 if (!soc->rxdma2sw_rings_not_supported) { 13082 for (i = 0; 13083 i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { 13084 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, 13085 pdev->pdev_id); 13086 13087 wlan_minidump_remove(soc->rxdma_err_dst_ring[lmac_id]. 13088 base_vaddr_unaligned, 13089 soc->rxdma_err_dst_ring[lmac_id]. 13090 alloc_size, 13091 soc->ctrl_psoc, 13092 WLAN_MD_DP_SRNG_RXDMA_ERR_DST, 13093 "rxdma_err_dst"); 13094 dp_srng_deinit(soc, &soc->rxdma_err_dst_ring[lmac_id], 13095 RXDMA_DST, lmac_id); 13096 } 13097 } 13098 13099 13100 } 13101 13102 /** 13103 * dp_pdev_srng_init() - initialize all pdev srng rings including 13104 * monitor rings 13105 * @pdev: Datapath pdev handle 13106 * 13107 * Return: QDF_STATUS_SUCCESS on success 13108 * QDF_STATUS_E_NOMEM on failure 13109 */ 13110 static QDF_STATUS dp_pdev_srng_init(struct dp_pdev *pdev) 13111 { 13112 struct dp_soc *soc = pdev->soc; 13113 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 13114 uint32_t i; 13115 13116 soc_cfg_ctx = soc->wlan_cfg_ctx; 13117 13118 if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) { 13119 if (dp_srng_init(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], 13120 RXDMA_BUF, 0, pdev->lmac_id)) { 13121 dp_init_err("%pK: dp_srng_init failed rx refill ring", 13122 soc); 13123 goto fail1; 13124 } 13125 } 13126 13127 /* LMAC RxDMA to SW Rings configuration */ 13128 if (!wlan_cfg_per_pdev_lmac_ring(soc_cfg_ctx)) 13129 /* Only valid for MCL */ 13130 pdev = soc->pdev_list[0]; 13131 13132 if (!soc->rxdma2sw_rings_not_supported) { 13133 for (i = 0; 13134 i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { 13135 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, 13136 pdev->pdev_id); 13137 struct dp_srng *srng = 13138 &soc->rxdma_err_dst_ring[lmac_id]; 13139 13140 if (srng->hal_srng) 13141 continue; 13142 13143 if (dp_srng_init(soc, srng, RXDMA_DST, 0, lmac_id)) { 13144 dp_init_err("%pK:" RNG_ERR "rxdma_err_dst_ring", 13145 soc); 13146 goto fail1; 13147 } 13148 wlan_minidump_log(soc->rxdma_err_dst_ring[lmac_id]. 13149 base_vaddr_unaligned, 13150 soc->rxdma_err_dst_ring[lmac_id]. 13151 alloc_size, 13152 soc->ctrl_psoc, 13153 WLAN_MD_DP_SRNG_RXDMA_ERR_DST, 13154 "rxdma_err_dst"); 13155 } 13156 } 13157 return QDF_STATUS_SUCCESS; 13158 13159 fail1: 13160 dp_pdev_srng_deinit(pdev); 13161 return QDF_STATUS_E_NOMEM; 13162 } 13163 13164 /** 13165 * dp_pdev_srng_free() - free all pdev srng rings including monitor rings 13166 * @pdev: Datapath pdev handle 13167 * 13168 */ 13169 static void dp_pdev_srng_free(struct dp_pdev *pdev) 13170 { 13171 struct dp_soc *soc = pdev->soc; 13172 uint8_t i; 13173 13174 if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) 13175 dp_srng_free(soc, &soc->rx_refill_buf_ring[pdev->lmac_id]); 13176 13177 if (!soc->rxdma2sw_rings_not_supported) { 13178 for (i = 0; 13179 i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { 13180 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, 13181 pdev->pdev_id); 13182 13183 dp_srng_free(soc, &soc->rxdma_err_dst_ring[lmac_id]); 13184 } 13185 } 13186 } 13187 13188 /** 13189 * dp_pdev_srng_alloc() - allocate memory for all pdev srng rings including 13190 * monitor rings 13191 * @pdev: Datapath pdev handle 13192 * 13193 * Return: QDF_STATUS_SUCCESS on success 13194 * QDF_STATUS_E_NOMEM on failure 13195 */ 13196 static QDF_STATUS dp_pdev_srng_alloc(struct dp_pdev *pdev) 13197 { 13198 struct dp_soc *soc = pdev->soc; 13199 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 13200 uint32_t ring_size; 13201 uint32_t i; 13202 13203 soc_cfg_ctx = soc->wlan_cfg_ctx; 13204 13205 ring_size = wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); 13206 if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) { 13207 if (dp_srng_alloc(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], 13208 RXDMA_BUF, ring_size, 0)) { 13209 dp_init_err("%pK: dp_srng_alloc failed rx refill ring", 13210 soc); 13211 goto fail1; 13212 } 13213 } 13214 13215 ring_size = wlan_cfg_get_dp_soc_rxdma_err_dst_ring_size(soc_cfg_ctx); 13216 /* LMAC RxDMA to SW Rings configuration */ 13217 if (!wlan_cfg_per_pdev_lmac_ring(soc_cfg_ctx)) 13218 /* Only valid for MCL */ 13219 pdev = soc->pdev_list[0]; 13220 13221 if (!soc->rxdma2sw_rings_not_supported) { 13222 for (i = 0; 13223 i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { 13224 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, 13225 pdev->pdev_id); 13226 struct dp_srng *srng = 13227 &soc->rxdma_err_dst_ring[lmac_id]; 13228 13229 if (srng->base_vaddr_unaligned) 13230 continue; 13231 13232 if (dp_srng_alloc(soc, srng, RXDMA_DST, ring_size, 0)) { 13233 dp_init_err("%pK:" RNG_ERR "rxdma_err_dst_ring", 13234 soc); 13235 goto fail1; 13236 } 13237 } 13238 } 13239 13240 return QDF_STATUS_SUCCESS; 13241 fail1: 13242 dp_pdev_srng_free(pdev); 13243 return QDF_STATUS_E_NOMEM; 13244 } 13245 13246 #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT) 13247 /** 13248 * dp_init_link_peer_stats_enabled() - Init link_peer_stats as per config 13249 * @pdev: DP pdev 13250 * 13251 * Return: None 13252 */ 13253 static inline void 13254 dp_init_link_peer_stats_enabled(struct dp_pdev *pdev) 13255 { 13256 pdev->link_peer_stats = wlan_cfg_is_peer_link_stats_enabled( 13257 pdev->soc->wlan_cfg_ctx); 13258 } 13259 #else 13260 static inline void 13261 dp_init_link_peer_stats_enabled(struct dp_pdev *pdev) 13262 { 13263 } 13264 #endif 13265 13266 static QDF_STATUS dp_pdev_init(struct cdp_soc_t *txrx_soc, 13267 HTC_HANDLE htc_handle, 13268 qdf_device_t qdf_osdev, 13269 uint8_t pdev_id) 13270 { 13271 struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; 13272 int nss_cfg; 13273 void *sojourn_buf; 13274 13275 struct dp_soc *soc = (struct dp_soc *)txrx_soc; 13276 struct dp_pdev *pdev = soc->pdev_list[pdev_id]; 13277 13278 soc_cfg_ctx = soc->wlan_cfg_ctx; 13279 pdev->soc = soc; 13280 pdev->pdev_id = pdev_id; 13281 13282 /* 13283 * Variable to prevent double pdev deinitialization during 13284 * radio detach execution .i.e. in the absence of any vdev. 13285 */ 13286 pdev->pdev_deinit = 0; 13287 13288 if (dp_wdi_event_attach(pdev)) { 13289 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 13290 "dp_wdi_evet_attach failed"); 13291 goto fail0; 13292 } 13293 13294 if (dp_pdev_srng_init(pdev)) { 13295 dp_init_err("%pK: Failed to initialize pdev srng rings", soc); 13296 goto fail1; 13297 } 13298 13299 /* Initialize descriptors in TCL Rings used by IPA */ 13300 if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { 13301 hal_tx_init_data_ring(soc->hal_soc, 13302 soc->tcl_data_ring[IPA_TCL_DATA_RING_IDX].hal_srng); 13303 dp_ipa_hal_tx_init_alt_data_ring(soc); 13304 } 13305 13306 /* 13307 * Initialize command/credit ring descriptor 13308 * Command/CREDIT ring also used for sending DATA cmds 13309 */ 13310 dp_tx_init_cmd_credit_ring(soc); 13311 13312 dp_tx_pdev_init(pdev); 13313 13314 /* 13315 * set nss pdev config based on soc config 13316 */ 13317 nss_cfg = wlan_cfg_get_dp_soc_nss_cfg(soc_cfg_ctx); 13318 wlan_cfg_set_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx, 13319 (nss_cfg & (1 << pdev_id))); 13320 pdev->target_pdev_id = 13321 dp_calculate_target_pdev_id_from_host_pdev_id(soc, pdev_id); 13322 13323 if (soc->preferred_hw_mode == WMI_HOST_HW_MODE_2G_PHYB && 13324 pdev->lmac_id == PHYB_2G_LMAC_ID) { 13325 pdev->target_pdev_id = PHYB_2G_TARGET_PDEV_ID; 13326 } 13327 13328 /* Reset the cpu ring map if radio is NSS offloaded */ 13329 if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { 13330 dp_soc_reset_cpu_ring_map(soc); 13331 dp_soc_reset_intr_mask(soc); 13332 } 13333 13334 /* Reset the cpu ring map if radio is NSS offloaded */ 13335 dp_soc_reset_ipa_vlan_intr_mask(soc); 13336 13337 TAILQ_INIT(&pdev->vdev_list); 13338 qdf_spinlock_create(&pdev->vdev_list_lock); 13339 pdev->vdev_count = 0; 13340 pdev->is_lro_hash_configured = 0; 13341 13342 qdf_spinlock_create(&pdev->tx_mutex); 13343 pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MON_INVALID_LMAC_ID; 13344 pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MON_INVALID_LMAC_ID; 13345 pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MON_INVALID_LMAC_ID; 13346 13347 DP_STATS_INIT(pdev); 13348 13349 dp_local_peer_id_pool_init(pdev); 13350 13351 dp_dscp_tid_map_setup(pdev); 13352 dp_pcp_tid_map_setup(pdev); 13353 13354 /* set the reo destination during initialization */ 13355 dp_pdev_set_default_reo(pdev); 13356 13357 qdf_mem_zero(&pdev->sojourn_stats, sizeof(struct cdp_tx_sojourn_stats)); 13358 13359 pdev->sojourn_buf = qdf_nbuf_alloc(pdev->soc->osdev, 13360 sizeof(struct cdp_tx_sojourn_stats), 0, 4, 13361 TRUE); 13362 13363 if (!pdev->sojourn_buf) { 13364 dp_init_err("%pK: Failed to allocate sojourn buf", soc); 13365 goto fail2; 13366 } 13367 sojourn_buf = qdf_nbuf_data(pdev->sojourn_buf); 13368 qdf_mem_zero(sojourn_buf, sizeof(struct cdp_tx_sojourn_stats)); 13369 13370 qdf_event_create(&pdev->fw_peer_stats_event); 13371 qdf_event_create(&pdev->fw_stats_event); 13372 qdf_event_create(&pdev->fw_obss_stats_event); 13373 13374 pdev->num_tx_allowed = wlan_cfg_get_num_tx_desc(soc->wlan_cfg_ctx); 13375 pdev->num_tx_spl_allowed = 13376 wlan_cfg_get_num_tx_spl_desc(soc->wlan_cfg_ctx); 13377 pdev->num_reg_tx_allowed = 13378 pdev->num_tx_allowed - pdev->num_tx_spl_allowed; 13379 if (dp_rxdma_ring_setup(soc, pdev)) { 13380 dp_init_err("%pK: RXDMA ring config failed", soc); 13381 goto fail3; 13382 } 13383 13384 if (dp_init_ipa_rx_refill_buf_ring(soc, pdev)) 13385 goto fail3; 13386 13387 if (dp_ipa_ring_resource_setup(soc, pdev)) 13388 goto fail4; 13389 13390 if (dp_ipa_uc_attach(soc, pdev) != QDF_STATUS_SUCCESS) { 13391 dp_init_err("%pK: dp_ipa_uc_attach failed", soc); 13392 goto fail4; 13393 } 13394 13395 if (dp_pdev_bkp_stats_attach(pdev) != QDF_STATUS_SUCCESS) { 13396 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 13397 FL("dp_pdev_bkp_stats_attach failed")); 13398 goto fail5; 13399 } 13400 13401 if (dp_monitor_pdev_init(pdev)) { 13402 dp_init_err("%pK: dp_monitor_pdev_init failed", soc); 13403 goto fail6; 13404 } 13405 13406 /* initialize sw rx descriptors */ 13407 dp_rx_pdev_desc_pool_init(pdev); 13408 /* allocate buffers and replenish the RxDMA ring */ 13409 dp_rx_pdev_buffers_alloc(pdev); 13410 13411 dp_init_tso_stats(pdev); 13412 dp_init_link_peer_stats_enabled(pdev); 13413 13414 pdev->rx_fast_flag = false; 13415 dp_info("Mem stats: DMA = %u HEAP = %u SKB = %u", 13416 qdf_dma_mem_stats_read(), 13417 qdf_heap_mem_stats_read(), 13418 qdf_skb_total_mem_stats_read()); 13419 13420 return QDF_STATUS_SUCCESS; 13421 fail6: 13422 dp_pdev_bkp_stats_detach(pdev); 13423 fail5: 13424 dp_ipa_uc_detach(soc, pdev); 13425 fail4: 13426 dp_deinit_ipa_rx_refill_buf_ring(soc, pdev); 13427 fail3: 13428 dp_rxdma_ring_cleanup(soc, pdev); 13429 qdf_nbuf_free(pdev->sojourn_buf); 13430 fail2: 13431 qdf_spinlock_destroy(&pdev->tx_mutex); 13432 qdf_spinlock_destroy(&pdev->vdev_list_lock); 13433 dp_pdev_srng_deinit(pdev); 13434 fail1: 13435 dp_wdi_event_detach(pdev); 13436 fail0: 13437 return QDF_STATUS_E_FAILURE; 13438 } 13439 13440 /** 13441 * dp_pdev_init_wifi3() - Init txrx pdev 13442 * @txrx_soc: 13443 * @htc_handle: HTC handle for host-target interface 13444 * @qdf_osdev: QDF OS device 13445 * @pdev_id: pdev Id 13446 * 13447 * Return: QDF_STATUS 13448 */ 13449 static QDF_STATUS dp_pdev_init_wifi3(struct cdp_soc_t *txrx_soc, 13450 HTC_HANDLE htc_handle, 13451 qdf_device_t qdf_osdev, 13452 uint8_t pdev_id) 13453 { 13454 return dp_pdev_init(txrx_soc, htc_handle, qdf_osdev, pdev_id); 13455 } 13456 13457 #ifdef FEATURE_DIRECT_LINK 13458 struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 13459 uint8_t pdev_id) 13460 { 13461 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 13462 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 13463 13464 if (!pdev) { 13465 dp_err("DP pdev is NULL"); 13466 return NULL; 13467 } 13468 13469 if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring4, 13470 RXDMA_BUF, DIRECT_LINK_REFILL_RING_ENTRIES, false)) { 13471 dp_err("SRNG alloc failed for rx_refill_buf_ring4"); 13472 return NULL; 13473 } 13474 13475 if (dp_srng_init(soc, &pdev->rx_refill_buf_ring4, 13476 RXDMA_BUF, DIRECT_LINK_REFILL_RING_IDX, 0)) { 13477 dp_err("SRNG init failed for rx_refill_buf_ring4"); 13478 dp_srng_free(soc, &pdev->rx_refill_buf_ring4); 13479 return NULL; 13480 } 13481 13482 if (htt_srng_setup(soc->htt_handle, pdev_id, 13483 pdev->rx_refill_buf_ring4.hal_srng, RXDMA_BUF)) { 13484 dp_srng_deinit(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, 13485 DIRECT_LINK_REFILL_RING_IDX); 13486 dp_srng_free(soc, &pdev->rx_refill_buf_ring4); 13487 return NULL; 13488 } 13489 13490 return &pdev->rx_refill_buf_ring4; 13491 } 13492 13493 void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, 13494 uint8_t pdev_id) 13495 { 13496 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 13497 struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 13498 13499 if (!pdev) { 13500 dp_err("DP pdev is NULL"); 13501 return; 13502 } 13503 13504 dp_srng_deinit(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, 0); 13505 dp_srng_free(soc, &pdev->rx_refill_buf_ring4); 13506 } 13507 #endif 13508 13509 #ifdef QCA_MULTIPASS_SUPPORT 13510 QDF_STATUS dp_set_vlan_groupkey(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 13511 uint16_t vlan_id, uint16_t group_key) 13512 { 13513 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 13514 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 13515 DP_MOD_ID_TX_MULTIPASS); 13516 QDF_STATUS status; 13517 13518 dp_info("Try: vdev_id %d, vdev %pK, multipass_en %d, vlan_id %d, group_key %d", 13519 vdev_id, vdev, vdev ? vdev->multipass_en : 0, vlan_id, 13520 group_key); 13521 if (!vdev || !vdev->multipass_en) { 13522 status = QDF_STATUS_E_INVAL; 13523 goto fail; 13524 } 13525 13526 if (!vdev->iv_vlan_map) { 13527 uint16_t vlan_map_size = (sizeof(uint16_t)) * DP_MAX_VLAN_IDS; 13528 13529 vdev->iv_vlan_map = (uint16_t *)qdf_mem_malloc(vlan_map_size); 13530 if (!vdev->iv_vlan_map) { 13531 QDF_TRACE_ERROR(QDF_MODULE_ID_DP, "iv_vlan_map"); 13532 status = QDF_STATUS_E_NOMEM; 13533 goto fail; 13534 } 13535 13536 /* 13537 * 0 is invalid group key. 13538 * Initilalize array with invalid group keys. 13539 */ 13540 qdf_mem_zero(vdev->iv_vlan_map, vlan_map_size); 13541 } 13542 13543 if (vlan_id >= DP_MAX_VLAN_IDS) { 13544 status = QDF_STATUS_E_INVAL; 13545 goto fail; 13546 } 13547 13548 dp_info("Successful setting: vdev_id %d, vlan_id %d, group_key %d", 13549 vdev_id, vlan_id, group_key); 13550 vdev->iv_vlan_map[vlan_id] = group_key; 13551 status = QDF_STATUS_SUCCESS; 13552 fail: 13553 if (vdev) 13554 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_TX_MULTIPASS); 13555 return status; 13556 } 13557 13558 void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf) 13559 { 13560 struct vlan_ethhdr veth_hdr; 13561 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)nbuf->data; 13562 13563 /* 13564 * Extract VLAN header of 4 bytes: 13565 * Frame Format : {dst_addr[6], src_addr[6], 802.1Q header[4], 13566 * EtherType[2], Payload} 13567 * Before Removal : xx xx xx xx xx xx xx xx xx xx xx xx 81 00 00 02 13568 * 08 00 45 00 00... 13569 * After Removal : xx xx xx xx xx xx xx xx xx xx xx xx 08 00 45 00 13570 * 00... 13571 */ 13572 qdf_mem_copy(&veth_hdr, veh, sizeof(veth_hdr)); 13573 qdf_nbuf_pull_head(nbuf, ETHERTYPE_VLAN_LEN); 13574 veh = (struct vlan_ethhdr *)nbuf->data; 13575 qdf_mem_copy(veh, &veth_hdr, 2 * QDF_MAC_ADDR_SIZE); 13576 } 13577 13578 void dp_tx_vdev_multipass_deinit(struct dp_vdev *vdev) 13579 { 13580 struct dp_txrx_peer *txrx_peer = NULL; 13581 13582 qdf_spin_lock_bh(&vdev->mpass_peer_mutex); 13583 TAILQ_FOREACH(txrx_peer, &vdev->mpass_peer_list, mpass_peer_list_elem) 13584 qdf_err("Peers present in mpass list : %d", txrx_peer->peer_id); 13585 qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); 13586 13587 if (vdev->iv_vlan_map) { 13588 qdf_mem_free(vdev->iv_vlan_map); 13589 vdev->iv_vlan_map = NULL; 13590 } 13591 13592 qdf_spinlock_destroy(&vdev->mpass_peer_mutex); 13593 } 13594 13595 void dp_peer_multipass_list_init(struct dp_vdev *vdev) 13596 { 13597 /* 13598 * vdev->iv_vlan_map is allocated when the first configuration command 13599 * is issued to avoid unnecessary allocation for regular mode VAP. 13600 */ 13601 TAILQ_INIT(&vdev->mpass_peer_list); 13602 qdf_spinlock_create(&vdev->mpass_peer_mutex); 13603 } 13604 #endif /* QCA_MULTIPASS_SUPPORT */ 13605