/* * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "dp_types.h" #include "dp_rings.h" #include "dp_internal.h" #include "dp_tx.h" #include "dp_tx_desc.h" #include "dp_rx.h" #ifdef DP_RATETABLE_SUPPORT #include "dp_ratetable.h" #endif #include #include #include #include "cdp_txrx_cmn_struct.h" #include "cdp_txrx_stats_struct.h" #include "cdp_txrx_cmn_reg.h" #include #include "dp_peer.h" #include "htt_stats.h" #include "dp_htt.h" #ifdef WLAN_SUPPORT_RX_FISA #include #endif #include "htt_ppdu_stats.h" #include "qdf_mem.h" /* qdf_mem_malloc,free */ #include "cfg_ucfg_api.h" #include #ifdef QCA_MULTIPASS_SUPPORT #include #endif #ifdef QCA_LL_TX_FLOW_CONTROL_V2 #include "cdp_txrx_flow_ctrl_v2.h" #else static inline void cdp_dump_flow_pool_info(struct cdp_soc_t *soc) { return; } #endif #ifdef WIFI_MONITOR_SUPPORT #include #endif #include "dp_ipa.h" #ifdef FEATURE_WDS #include "dp_txrx_wds.h" #endif #ifdef WLAN_SUPPORT_MSCS #include "dp_mscs.h" #endif #ifdef WLAN_SUPPORT_MESH_LATENCY #include "dp_mesh_latency.h" #endif #ifdef WLAN_SUPPORT_SCS #include "dp_scs.h" #endif #ifdef ATH_SUPPORT_IQUE #include "dp_txrx_me.h" #endif #if defined(DP_CON_MON) #ifndef REMOVE_PKT_LOG #include #include #endif #endif #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR #include #endif #ifdef WLAN_DP_PROFILE_SUPPORT #include #endif #ifdef CONFIG_SAWF_DEF_QUEUES #include "dp_sawf.h" #endif #ifdef WLAN_SUPPORT_RX_FLOW_TAG #include "dp_rx_tag.h" #endif #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF #include #endif #include "qdf_ssr_driver_dump.h" #ifdef WLAN_SUPPORT_DPDK #include #endif #ifdef QCA_DP_ENABLE_TX_COMP_RING4 #define TXCOMP_RING4_NUM 3 #else #define TXCOMP_RING4_NUM WBM2SW_TXCOMP_RING4_NUM #endif #if defined(DP_PEER_EXTENDED_API) || defined(WLAN_DP_PENDING_MEM_FLUSH) #define SET_PEER_REF_CNT_ONE(_peer) \ qdf_atomic_set(&(_peer)->ref_cnt, 1) #else #define SET_PEER_REF_CNT_ONE(_peer) #endif #ifdef WLAN_SYSFS_DP_STATS /* sysfs event wait time for firmware stat request unit milliseconds */ #define WLAN_SYSFS_STAT_REQ_WAIT_MS 3000 #endif #ifdef QCA_DP_TX_FW_METADATA_V2 #define DP_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) \ HTT_TX_TCL_METADATA_V2_PDEV_ID_SET(_var, _val) #else #define DP_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) \ HTT_TX_TCL_METADATA_PDEV_ID_SET(_var, _val) #endif #define MLD_MODE_INVALID 0xFF QDF_COMPILE_TIME_ASSERT(max_rx_rings_check, MAX_REO_DEST_RINGS == CDP_MAX_RX_RINGS); QDF_COMPILE_TIME_ASSERT(max_tx_rings_check, MAX_TCL_DATA_RINGS == CDP_MAX_TX_COMP_RINGS); void dp_configure_arch_ops(struct dp_soc *soc); qdf_size_t dp_get_soc_context_size(uint16_t device_id); /* * The max size of cdp_peer_stats_param_t is limited to 16 bytes. * If the buffer size is exceeding this size limit, * dp_txrx_get_peer_stats is to be used instead. */ QDF_COMPILE_TIME_ASSERT(cdp_peer_stats_param_t_max_size, (sizeof(cdp_peer_stats_param_t) <= 16)); #ifdef WLAN_FEATURE_DP_EVENT_HISTORY /* * If WLAN_CFG_INT_NUM_CONTEXTS is changed, HIF_NUM_INT_CONTEXTS * also should be updated accordingly */ QDF_COMPILE_TIME_ASSERT(num_intr_grps, HIF_NUM_INT_CONTEXTS == WLAN_CFG_INT_NUM_CONTEXTS); /* * HIF_EVENT_HIST_MAX should always be power of 2 */ QDF_COMPILE_TIME_ASSERT(hif_event_history_size, (HIF_EVENT_HIST_MAX & (HIF_EVENT_HIST_MAX - 1)) == 0); #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ /* * If WLAN_CFG_INT_NUM_CONTEXTS is changed, * WLAN_CFG_INT_NUM_CONTEXTS_MAX should also be updated */ QDF_COMPILE_TIME_ASSERT(wlan_cfg_num_int_ctxs, WLAN_CFG_INT_NUM_CONTEXTS_MAX >= WLAN_CFG_INT_NUM_CONTEXTS); static void dp_soc_unset_qref_debug_list(struct dp_soc *soc); static QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl); static QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl); static void dp_pdev_srng_deinit(struct dp_pdev *pdev); static QDF_STATUS dp_pdev_srng_init(struct dp_pdev *pdev); static void dp_pdev_srng_free(struct dp_pdev *pdev); static QDF_STATUS dp_pdev_srng_alloc(struct dp_pdev *pdev); static inline QDF_STATUS dp_pdev_attach_wifi3(struct cdp_soc_t *txrx_soc, struct cdp_pdev_attach_params *params); static int dp_pdev_post_attach_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id); static QDF_STATUS dp_pdev_init_wifi3(struct cdp_soc_t *txrx_soc, HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, uint8_t pdev_id); static QDF_STATUS dp_pdev_deinit_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, int force); static void dp_soc_detach_wifi3(struct cdp_soc_t *txrx_soc); static void dp_soc_deinit_wifi3(struct cdp_soc_t *txrx_soc); static void dp_pdev_detach(struct cdp_pdev *txrx_pdev, int force); static QDF_STATUS dp_pdev_detach_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, int force); static struct dp_soc * dp_soc_attach(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, struct cdp_soc_attach_params *params); static inline QDF_STATUS dp_peer_create_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac_addr, enum cdp_peer_type peer_type); static QDF_STATUS dp_peer_delete_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint32_t bitmap, enum cdp_peer_type peer_type); static void dp_vdev_flush_peers(struct cdp_vdev *vdev_handle, bool unmap_only, bool mlo_peers_only); #ifdef ENABLE_VERBOSE_DEBUG bool is_dp_verbose_debug_enabled; #endif #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) static bool dp_get_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); static void dp_set_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, bool enable); static inline void dp_get_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_cfr_rcc_stats *cfr_rcc_stats); static inline void dp_clear_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); #endif #ifdef DP_UMAC_HW_RESET_SUPPORT static QDF_STATUS dp_umac_reset_action_trigger_recovery(struct dp_soc *soc); static QDF_STATUS dp_umac_reset_handle_pre_reset(struct dp_soc *soc); static QDF_STATUS dp_umac_reset_handle_post_reset(struct dp_soc *soc); static QDF_STATUS dp_umac_reset_handle_post_reset_complete(struct dp_soc *soc); #endif #define MON_VDEV_TIMER_INIT 0x1 #define MON_VDEV_TIMER_RUNNING 0x2 #define DP_MCS_LENGTH (6*MAX_MCS) #define DP_CURR_FW_STATS_AVAIL 19 #define DP_HTT_DBG_EXT_STATS_MAX 256 #define DP_MAX_SLEEP_TIME 100 #ifndef QCA_WIFI_3_0_EMU #define SUSPEND_DRAIN_WAIT 500 #else #define SUSPEND_DRAIN_WAIT 3000 #endif #ifdef IPA_OFFLOAD /* Exclude IPA rings from the interrupt context */ #define TX_RING_MASK_VAL 0xb #define RX_RING_MASK_VAL 0x7 #else #define TX_RING_MASK_VAL 0xF #define RX_RING_MASK_VAL 0xF #endif #define STR_MAXLEN 64 #define RNG_ERR "SRNG setup failed for" /** * enum dp_stats_type - Select the type of statistics * @STATS_FW: Firmware-based statistic * @STATS_HOST: Host-based statistic * @STATS_TYPE_MAX: maximum enumeration */ enum dp_stats_type { STATS_FW = 0, STATS_HOST = 1, STATS_TYPE_MAX = 2, }; /** * enum dp_fw_stats - General Firmware statistics options * @TXRX_FW_STATS_INVALID: statistic is not available */ enum dp_fw_stats { TXRX_FW_STATS_INVALID = -1, }; /* * dp_stats_mapping_table - Firmware and Host statistics * currently supported */ #ifndef WLAN_SOFTUMAC_SUPPORT const int dp_stats_mapping_table[][STATS_TYPE_MAX] = { {HTT_DBG_EXT_STATS_RESET, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_RX, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_HWQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_SCHED, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_ERROR, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TQM, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TQM_CMDQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_DE_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_RATE, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_RX_RATE, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_SELFGEN_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_MU_HWQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_RING_IF_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_SRNG_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_SFM_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_MU, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_ACTIVE_PEERS_LIST, TXRX_HOST_STATS_INVALID}, /* Last ENUM for HTT FW STATS */ {DP_HTT_DBG_EXT_STATS_MAX, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_CLEAR_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_RATE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_TX_RATE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_TX_HOST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_HOST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_AST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SRNG_PTR_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_MON_STATS}, {TXRX_FW_STATS_INVALID, TXRX_REO_QUEUE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_CFG_PARAMS}, {TXRX_FW_STATS_INVALID, TXRX_PDEV_CFG_PARAMS}, {TXRX_FW_STATS_INVALID, TXRX_NAPI_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_INTERRUPT_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_FSE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_HAL_REG_WRITE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_REO_HW_DESC_DUMP}, {TXRX_FW_STATS_INVALID, TXRX_SOC_WBM_IDLE_HPTP_DUMP}, {TXRX_FW_STATS_INVALID, TXRX_SRNG_USAGE_WM_STATS}, {HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_SOUNDING_INFO, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_PEER_STATS}, }; #else const int dp_stats_mapping_table[][STATS_TYPE_MAX] = { {HTT_DBG_EXT_STATS_RESET, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_RX, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_HWQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_SCHED, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_ERROR, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TQM, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TQM_CMDQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_DE_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_RATE, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_RX_RATE, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_SELFGEN_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_MU_HWQ, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_RING_IF_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_SRNG_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_SFM_INFO, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_TX_MU, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_ACTIVE_PEERS_LIST, TXRX_HOST_STATS_INVALID}, /* Last ENUM for HTT FW STATS */ {DP_HTT_DBG_EXT_STATS_MAX, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_CLEAR_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_RATE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_TX_RATE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_TX_HOST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_HOST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_AST_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SRNG_PTR_STATS}, {TXRX_FW_STATS_INVALID, TXRX_RX_MON_STATS}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_SOC_CFG_PARAMS}, {TXRX_FW_STATS_INVALID, TXRX_PDEV_CFG_PARAMS}, {TXRX_FW_STATS_INVALID, TXRX_NAPI_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_INTERRUPT_STATS}, {TXRX_FW_STATS_INVALID, TXRX_SOC_FSE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_HAL_REG_WRITE_STATS}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {TXRX_FW_STATS_INVALID, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, TXRX_HOST_STATS_INVALID}, {HTT_DBG_EXT_STATS_TX_SOUNDING_INFO, TXRX_HOST_STATS_INVALID} }; #endif /* MCL specific functions */ #if defined(DP_CON_MON) #ifdef IPA_OFFLOAD /** * dp_get_num_rx_contexts() - get number of RX contexts * @soc_hdl: cdp opaque soc handle * * Return: number of RX contexts */ static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) { int num_rx_contexts; uint32_t reo_ring_map; struct dp_soc *soc = (struct dp_soc *)soc_hdl; reo_ring_map = wlan_cfg_get_reo_rings_mapping(soc->wlan_cfg_ctx); switch (soc->arch_id) { case CDP_ARCH_TYPE_BE: /* 2 REO rings are used for IPA */ reo_ring_map &= ~(BIT(3) | BIT(7)); break; case CDP_ARCH_TYPE_LI: /* 1 REO ring is used for IPA */ reo_ring_map &= ~BIT(3); break; default: dp_err("unknown arch_id 0x%x", soc->arch_id); QDF_BUG(0); } /* * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled * in future */ num_rx_contexts = qdf_get_hweight32(reo_ring_map); return num_rx_contexts; } #else #ifdef WLAN_SOFTUMAC_SUPPORT static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) { uint32_t rx_rings_config; struct dp_soc *soc = (struct dp_soc *)soc_hdl; rx_rings_config = wlan_cfg_get_rx_rings_mapping(soc->wlan_cfg_ctx); /* * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled * in future */ return qdf_get_hweight32(rx_rings_config); } #else static int dp_get_num_rx_contexts(struct cdp_soc_t *soc_hdl) { int num_rx_contexts; uint32_t reo_config; struct dp_soc *soc = (struct dp_soc *)soc_hdl; reo_config = wlan_cfg_get_reo_rings_mapping(soc->wlan_cfg_ctx); /* * qdf_get_hweight32 prefer over qdf_get_hweight8 in case map is scaled * in future */ num_rx_contexts = qdf_get_hweight32(reo_config); return num_rx_contexts; } #endif /* WLAN_SOFTUMAC_SUPPORT */ #endif #endif #ifdef FEATURE_MEC void dp_peer_mec_flush_entries(struct dp_soc *soc) { unsigned int index; struct dp_mec_entry *mecentry, *mecentry_next; TAILQ_HEAD(, dp_mec_entry) free_list; TAILQ_INIT(&free_list); if (!soc->mec_hash.mask) return; if (!soc->mec_hash.bins) return; if (!qdf_atomic_read(&soc->mec_cnt)) return; qdf_spin_lock_bh(&soc->mec_lock); for (index = 0; index <= soc->mec_hash.mask; index++) { if (!TAILQ_EMPTY(&soc->mec_hash.bins[index])) { TAILQ_FOREACH_SAFE(mecentry, &soc->mec_hash.bins[index], hash_list_elem, mecentry_next) { dp_peer_mec_detach_entry(soc, mecentry, &free_list); } } } qdf_spin_unlock_bh(&soc->mec_lock); dp_peer_mec_free_list(soc, &free_list); } /** * dp_print_mec_stats() - Dump MEC entries in table * @soc: Datapath soc handle * * Return: none */ static void dp_print_mec_stats(struct dp_soc *soc) { int i; uint32_t index; struct dp_mec_entry *mecentry = NULL, *mec_list; uint32_t num_entries = 0; DP_PRINT_STATS("MEC Stats:"); DP_PRINT_STATS(" Entries Added = %d", soc->stats.mec.added); DP_PRINT_STATS(" Entries Deleted = %d", soc->stats.mec.deleted); if (!qdf_atomic_read(&soc->mec_cnt)) return; mec_list = qdf_mem_malloc(sizeof(*mecentry) * DP_PEER_MAX_MEC_ENTRY); if (!mec_list) { dp_peer_warn("%pK: failed to allocate mec_list", soc); return; } DP_PRINT_STATS("MEC Table:"); for (index = 0; index <= soc->mec_hash.mask; index++) { qdf_spin_lock_bh(&soc->mec_lock); if (TAILQ_EMPTY(&soc->mec_hash.bins[index])) { qdf_spin_unlock_bh(&soc->mec_lock); continue; } TAILQ_FOREACH(mecentry, &soc->mec_hash.bins[index], hash_list_elem) { qdf_mem_copy(&mec_list[num_entries], mecentry, sizeof(*mecentry)); num_entries++; } qdf_spin_unlock_bh(&soc->mec_lock); } if (!num_entries) { qdf_mem_free(mec_list); return; } for (i = 0; i < num_entries; i++) { DP_PRINT_STATS("%6d mac_addr = " QDF_MAC_ADDR_FMT " is_active = %d pdev_id = %d vdev_id = %d", i, QDF_MAC_ADDR_REF(mec_list[i].mac_addr.raw), mec_list[i].is_active, mec_list[i].pdev_id, mec_list[i].vdev_id); } qdf_mem_free(mec_list); } #else static void dp_print_mec_stats(struct dp_soc *soc) { } #endif static int dp_peer_add_ast_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, uint32_t flags) { int ret = -1; QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc_hdl, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_peer_debug("Peer is NULL!"); return ret; } status = dp_peer_add_ast((struct dp_soc *)soc_hdl, peer, mac_addr, type, flags); if ((status == QDF_STATUS_SUCCESS) || (status == QDF_STATUS_E_ALREADY) || (status == QDF_STATUS_E_AGAIN)) ret = 0; dp_hmwds_ast_add_notify(peer, mac_addr, type, status, false); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return ret; } static int dp_peer_update_ast_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint8_t *wds_macaddr, uint32_t flags) { int status = -1; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_ast_entry *ast_entry = NULL; struct dp_peer *peer; if (soc->ast_offload_support) return status; peer = dp_peer_find_hash_find((struct dp_soc *)soc_hdl, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_peer_debug("Peer is NULL!"); return status; } qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, wds_macaddr, peer->vdev->pdev->pdev_id); if (ast_entry) { status = dp_peer_update_ast(soc, peer, ast_entry, flags); } qdf_spin_unlock_bh(&soc->ast_lock); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } /** * dp_peer_reset_ast_entries() - Deletes all HMWDS entries for a peer * @soc: Datapath SOC handle * @peer: DP peer * @arg: callback argument * * Return: None */ static void dp_peer_reset_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) { struct dp_ast_entry *ast_entry = NULL; struct dp_ast_entry *tmp_ast_entry; DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, tmp_ast_entry) { if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) || (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)) dp_peer_del_ast(soc, ast_entry); } } /** * dp_wds_reset_ast_wifi3() - Reset the is_active param for ast entry * @soc_hdl: Datapath SOC handle * @wds_macaddr: WDS entry MAC Address * @peer_mac_addr: WDS entry MAC Address * @vdev_id: id of vdev handle * * Return: QDF_STATUS */ static QDF_STATUS dp_wds_reset_ast_wifi3(struct cdp_soc_t *soc_hdl, uint8_t *wds_macaddr, uint8_t *peer_mac_addr, uint8_t vdev_id) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_ast_entry *ast_entry = NULL; struct dp_peer *peer; struct dp_pdev *pdev; struct dp_vdev *vdev; if (soc->ast_offload_support) return QDF_STATUS_E_FAILURE; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; pdev = vdev->pdev; if (peer_mac_addr) { peer = dp_peer_find_hash_find(soc, peer_mac_addr, 0, vdev->vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } qdf_spin_lock_bh(&soc->ast_lock); dp_peer_reset_ast_entries(soc, peer, NULL); qdf_spin_unlock_bh(&soc->ast_lock); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); } else if (wds_macaddr) { qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, wds_macaddr, pdev->pdev_id); if (ast_entry) { if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) || (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)) dp_peer_del_ast(soc, ast_entry); } qdf_spin_unlock_bh(&soc->ast_lock); } dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_wds_reset_ast_table_wifi3() - Reset the is_active param for all ast entry * @soc_hdl: Datapath SOC handle * @vdev_id: id of vdev object * * Return: QDF_STATUS */ static QDF_STATUS dp_wds_reset_ast_table_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = (struct dp_soc *) soc_hdl; if (soc->ast_offload_support) return QDF_STATUS_SUCCESS; qdf_spin_lock_bh(&soc->ast_lock); dp_soc_iterate_peer(soc, dp_peer_reset_ast_entries, NULL, DP_MOD_ID_CDP); qdf_spin_unlock_bh(&soc->ast_lock); return QDF_STATUS_SUCCESS; } /** * dp_peer_flush_ast_entries() - Delete all wds and hmwds ast entries of a peer * @soc: Datapath SOC * @peer: Datapath peer * @arg: arg to callback * * Return: None */ static void dp_peer_flush_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) { struct dp_ast_entry *ase = NULL; struct dp_ast_entry *temp_ase; DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) { if ((ase->type == CDP_TXRX_AST_TYPE_STATIC) || (ase->type == CDP_TXRX_AST_TYPE_SELF) || (ase->type == CDP_TXRX_AST_TYPE_STA_BSS)) continue; dp_peer_del_ast(soc, ase); } } /** * dp_wds_flush_ast_table_wifi3() - Delete all wds and hmwds ast entry * @soc_hdl: Datapath SOC handle * * Return: None */ static void dp_wds_flush_ast_table_wifi3(struct cdp_soc_t *soc_hdl) { struct dp_soc *soc = (struct dp_soc *) soc_hdl; qdf_spin_lock_bh(&soc->ast_lock); dp_soc_iterate_peer(soc, dp_peer_flush_ast_entries, NULL, DP_MOD_ID_CDP); qdf_spin_unlock_bh(&soc->ast_lock); dp_peer_mec_flush_entries(soc); } #if defined(IPA_WDS_EASYMESH_FEATURE) && defined(FEATURE_AST) /** * dp_peer_send_wds_disconnect() - Send Disconnect event to IPA for each peer * @soc: Datapath SOC * @peer: Datapath peer * * Return: None */ static void dp_peer_send_wds_disconnect(struct dp_soc *soc, struct dp_peer *peer) { struct dp_ast_entry *ase = NULL; struct dp_ast_entry *temp_ase; DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) { if (ase->type == CDP_TXRX_AST_TYPE_WDS) { soc->cdp_soc.ol_ops->peer_send_wds_disconnect(soc->ctrl_psoc, ase->mac_addr.raw, ase->vdev_id); } } } #elif defined(FEATURE_AST) static void dp_peer_send_wds_disconnect(struct dp_soc *soc, struct dp_peer *peer) { } #endif /** * dp_peer_check_ast_offload() - check ast offload support is enable or not * @soc: soc handle * * Return: false in case of IPA and true/false in IPQ case * */ #if defined(IPA_OFFLOAD) && defined(QCA_WIFI_QCN9224) static inline bool dp_peer_check_ast_offload(struct dp_soc *soc) { return false; } #else static inline bool dp_peer_check_ast_offload(struct dp_soc *soc) { if (soc->ast_offload_support) return true; return false; } #endif /** * dp_peer_get_ast_info_by_soc_wifi3() - search the soc AST hash table * and return ast entry information * of first ast entry found in the * table with given mac address * @soc_hdl: data path soc handle * @ast_mac_addr: AST entry mac address * @ast_entry_info: ast entry information * * Return: true if ast entry found with ast_mac_addr * false if ast entry not found */ static bool dp_peer_get_ast_info_by_soc_wifi3 (struct cdp_soc_t *soc_hdl, uint8_t *ast_mac_addr, struct cdp_ast_entry_info *ast_entry_info) { struct dp_ast_entry *ast_entry = NULL; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_peer *peer = NULL; if (dp_peer_check_ast_offload(soc)) return false; qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_soc(soc, ast_mac_addr); if ((!ast_entry) || (ast_entry->delete_in_progress && !ast_entry->callback)) { qdf_spin_unlock_bh(&soc->ast_lock); return false; } peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id, DP_MOD_ID_AST); if (!peer) { qdf_spin_unlock_bh(&soc->ast_lock); return false; } ast_entry_info->type = ast_entry->type; ast_entry_info->pdev_id = ast_entry->pdev_id; ast_entry_info->vdev_id = ast_entry->vdev_id; ast_entry_info->peer_id = ast_entry->peer_id; qdf_mem_copy(&ast_entry_info->peer_mac_addr[0], &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE); dp_peer_unref_delete(peer, DP_MOD_ID_AST); qdf_spin_unlock_bh(&soc->ast_lock); return true; } /** * dp_peer_get_ast_info_by_pdevid_wifi3() - search the soc AST hash table * and return ast entry information * if mac address and pdev_id matches * @soc_hdl: data path soc handle * @ast_mac_addr: AST entry mac address * @pdev_id: pdev_id * @ast_entry_info: ast entry information * * Return: true if ast entry found with ast_mac_addr * false if ast entry not found */ static bool dp_peer_get_ast_info_by_pdevid_wifi3 (struct cdp_soc_t *soc_hdl, uint8_t *ast_mac_addr, uint8_t pdev_id, struct cdp_ast_entry_info *ast_entry_info) { struct dp_ast_entry *ast_entry; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_peer *peer = NULL; if (soc->ast_offload_support) return false; qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, ast_mac_addr, pdev_id); if ((!ast_entry) || (ast_entry->delete_in_progress && !ast_entry->callback)) { qdf_spin_unlock_bh(&soc->ast_lock); return false; } peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id, DP_MOD_ID_AST); if (!peer) { qdf_spin_unlock_bh(&soc->ast_lock); return false; } ast_entry_info->type = ast_entry->type; ast_entry_info->pdev_id = ast_entry->pdev_id; ast_entry_info->vdev_id = ast_entry->vdev_id; ast_entry_info->peer_id = ast_entry->peer_id; qdf_mem_copy(&ast_entry_info->peer_mac_addr[0], &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE); dp_peer_unref_delete(peer, DP_MOD_ID_AST); qdf_spin_unlock_bh(&soc->ast_lock); return true; } /** * dp_peer_ast_entry_del_by_soc() - delete the ast entry from soc AST hash table * with given mac address * @soc_handle: data path soc handle * @mac_addr: AST entry mac address * @callback: callback function to called on ast delete response from FW * @cookie: argument to be passed to callback * * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete * is sent * QDF_STATUS_E_INVAL false if ast entry not found */ static QDF_STATUS dp_peer_ast_entry_del_by_soc(struct cdp_soc_t *soc_handle, uint8_t *mac_addr, txrx_ast_free_cb callback, void *cookie) { struct dp_soc *soc = (struct dp_soc *)soc_handle; struct dp_ast_entry *ast_entry = NULL; txrx_ast_free_cb cb = NULL; void *arg = NULL; if (soc->ast_offload_support) return -QDF_STATUS_E_INVAL; qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr); if (!ast_entry) { qdf_spin_unlock_bh(&soc->ast_lock); return -QDF_STATUS_E_INVAL; } if (ast_entry->callback) { cb = ast_entry->callback; arg = ast_entry->cookie; } ast_entry->callback = callback; ast_entry->cookie = cookie; /* * if delete_in_progress is set AST delete is sent to target * and host is waiting for response should not send delete * again */ if (!ast_entry->delete_in_progress) dp_peer_del_ast(soc, ast_entry); qdf_spin_unlock_bh(&soc->ast_lock); if (cb) { cb(soc->ctrl_psoc, dp_soc_to_cdp_soc(soc), arg, CDP_TXRX_AST_DELETE_IN_PROGRESS); } return QDF_STATUS_SUCCESS; } /** * dp_peer_ast_entry_del_by_pdev() - delete the ast entry from soc AST hash * table if mac address and pdev_id matches * @soc_handle: data path soc handle * @mac_addr: AST entry mac address * @pdev_id: pdev id * @callback: callback function to called on ast delete response from FW * @cookie: argument to be passed to callback * * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete * is sent * QDF_STATUS_E_INVAL false if ast entry not found */ static QDF_STATUS dp_peer_ast_entry_del_by_pdev(struct cdp_soc_t *soc_handle, uint8_t *mac_addr, uint8_t pdev_id, txrx_ast_free_cb callback, void *cookie) { struct dp_soc *soc = (struct dp_soc *)soc_handle; struct dp_ast_entry *ast_entry; txrx_ast_free_cb cb = NULL; void *arg = NULL; if (soc->ast_offload_support) return -QDF_STATUS_E_INVAL; qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, mac_addr, pdev_id); if (!ast_entry) { qdf_spin_unlock_bh(&soc->ast_lock); return -QDF_STATUS_E_INVAL; } if (ast_entry->callback) { cb = ast_entry->callback; arg = ast_entry->cookie; } ast_entry->callback = callback; ast_entry->cookie = cookie; /* * if delete_in_progress is set AST delete is sent to target * and host is waiting for response should not sent delete * again */ if (!ast_entry->delete_in_progress) dp_peer_del_ast(soc, ast_entry); qdf_spin_unlock_bh(&soc->ast_lock); if (cb) { cb(soc->ctrl_psoc, dp_soc_to_cdp_soc(soc), arg, CDP_TXRX_AST_DELETE_IN_PROGRESS); } return QDF_STATUS_SUCCESS; } /** * dp_peer_HMWDS_ast_entry_del() - delete the ast entry from soc AST hash * table if HMWDS rem-addr command is issued * * @soc_handle: data path soc handle * @vdev_id: vdev id * @wds_macaddr: AST entry mac address to delete * @type: cdp_txrx_ast_entry_type to send to FW * @delete_in_fw: flag to indicate AST entry deletion in FW * * Return: QDF_STATUS_SUCCESS if ast entry found with ast_mac_addr and delete * is sent * QDF_STATUS_E_INVAL false if ast entry not found */ static QDF_STATUS dp_peer_HMWDS_ast_entry_del(struct cdp_soc_t *soc_handle, uint8_t vdev_id, uint8_t *wds_macaddr, uint8_t type, uint8_t delete_in_fw) { struct dp_soc *soc = (struct dp_soc *)soc_handle; if (soc->ast_offload_support) { dp_del_wds_entry_wrapper(soc, vdev_id, wds_macaddr, type, delete_in_fw); return QDF_STATUS_SUCCESS; } return -QDF_STATUS_E_INVAL; } #ifdef FEATURE_AST /** * dp_print_mlo_ast_stats() - Print AST stats for MLO peers * * @soc: core DP soc context * * Return: void */ static void dp_print_mlo_ast_stats(struct dp_soc *soc) { if (soc->arch_ops.print_mlo_ast_stats) soc->arch_ops.print_mlo_ast_stats(soc); } void dp_print_peer_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) { struct dp_ast_entry *ase, *tmp_ase; uint32_t num_entries = 0; char type[CDP_TXRX_AST_TYPE_MAX][10] = { "NONE", "STATIC", "SELF", "WDS", "HMWDS", "BSS", "DA", "HMWDS_SEC", "MLD"}; DP_PEER_ITERATE_ASE_LIST(peer, ase, tmp_ase) { DP_PRINT_STATS("%6d mac_addr = "QDF_MAC_ADDR_FMT " peer_mac_addr = "QDF_MAC_ADDR_FMT " peer_id = %u" " type = %s" " next_hop = %d" " is_active = %d" " ast_idx = %d" " ast_hash = %d" " delete_in_progress = %d" " pdev_id = %d" " vdev_id = %d", ++num_entries, QDF_MAC_ADDR_REF(ase->mac_addr.raw), QDF_MAC_ADDR_REF(peer->mac_addr.raw), ase->peer_id, type[ase->type], ase->next_hop, ase->is_active, ase->ast_idx, ase->ast_hash_value, ase->delete_in_progress, ase->pdev_id, ase->vdev_id); } } void dp_print_ast_stats(struct dp_soc *soc) { DP_PRINT_STATS("AST Stats:"); DP_PRINT_STATS(" Entries Added = %d", soc->stats.ast.added); DP_PRINT_STATS(" Entries Deleted = %d", soc->stats.ast.deleted); DP_PRINT_STATS(" Entries Agedout = %d", soc->stats.ast.aged_out); DP_PRINT_STATS(" Entries MAP ERR = %d", soc->stats.ast.map_err); DP_PRINT_STATS(" Entries Mismatch ERR = %d", soc->stats.ast.ast_mismatch); DP_PRINT_STATS("AST Table:"); qdf_spin_lock_bh(&soc->ast_lock); dp_soc_iterate_peer(soc, dp_print_peer_ast_entries, NULL, DP_MOD_ID_GENERIC_STATS); qdf_spin_unlock_bh(&soc->ast_lock); dp_print_mlo_ast_stats(soc); } #else void dp_print_ast_stats(struct dp_soc *soc) { DP_PRINT_STATS("AST Stats not available.Enable FEATURE_AST"); return; } #endif /** * dp_print_peer_info() - Dump peer info * @soc: Datapath soc handle * @peer: Datapath peer handle * @arg: argument to iter function * * Return: void */ static void dp_print_peer_info(struct dp_soc *soc, struct dp_peer *peer, void *arg) { struct dp_txrx_peer *txrx_peer = NULL; txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) return; DP_PRINT_STATS(" peer id = %d" " peer_mac_addr = "QDF_MAC_ADDR_FMT " nawds_enabled = %d" " bss_peer = %d" " wds_enabled = %d" " tx_cap_enabled = %d" " rx_cap_enabled = %d", peer->peer_id, QDF_MAC_ADDR_REF(peer->mac_addr.raw), txrx_peer->nawds_enabled, txrx_peer->bss_peer, txrx_peer->wds_enabled, dp_monitor_is_tx_cap_enabled(peer), dp_monitor_is_rx_cap_enabled(peer)); } /** * dp_print_peer_table() - Dump all Peer stats * @vdev: Datapath Vdev handle * * Return: void */ static void dp_print_peer_table(struct dp_vdev *vdev) { DP_PRINT_STATS("Dumping Peer Table Stats:"); dp_vdev_iterate_peer(vdev, dp_print_peer_info, NULL, DP_MOD_ID_GENERIC_STATS); } #ifdef DP_MEM_PRE_ALLOC void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, size_t ctxt_size) { void *ctxt_mem; if (!soc->cdp_soc.ol_ops->dp_prealloc_get_context) { dp_warn("dp_prealloc_get_context null!"); goto dynamic_alloc; } ctxt_mem = soc->cdp_soc.ol_ops->dp_prealloc_get_context(ctxt_type, ctxt_size); if (ctxt_mem) goto end; dynamic_alloc: dp_info("switch to dynamic-alloc for type %d, size %zu", ctxt_type, ctxt_size); ctxt_mem = qdf_mem_malloc(ctxt_size); end: return ctxt_mem; } void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, void *vaddr) { QDF_STATUS status; if (soc->cdp_soc.ol_ops->dp_prealloc_put_context) { status = soc->cdp_soc.ol_ops->dp_prealloc_put_context( ctxt_type, vaddr); } else { dp_warn("dp_prealloc_put_context null!"); status = QDF_STATUS_E_NOSUPPORT; } if (QDF_IS_STATUS_ERROR(status)) { dp_info("Context type %d not pre-allocated", ctxt_type); qdf_mem_free(vaddr); } } static inline void *dp_srng_aligned_mem_alloc_consistent(struct dp_soc *soc, struct dp_srng *srng, uint32_t ring_type) { void *mem; qdf_assert(!srng->is_mem_prealloc); if (!soc->cdp_soc.ol_ops->dp_prealloc_get_consistent) { dp_warn("dp_prealloc_get_consistent is null!"); goto qdf; } mem = soc->cdp_soc.ol_ops->dp_prealloc_get_consistent (&srng->alloc_size, &srng->base_vaddr_unaligned, &srng->base_paddr_unaligned, &srng->base_paddr_aligned, DP_RING_BASE_ALIGN, ring_type); if (mem) { srng->is_mem_prealloc = true; goto end; } qdf: mem = qdf_aligned_mem_alloc_consistent(soc->osdev, &srng->alloc_size, &srng->base_vaddr_unaligned, &srng->base_paddr_unaligned, &srng->base_paddr_aligned, DP_RING_BASE_ALIGN); end: dp_info("%s memory %pK dp_srng %pK ring_type %d alloc_size %d num_entries %d", srng->is_mem_prealloc ? "pre-alloc" : "dynamic-alloc", mem, srng, ring_type, srng->alloc_size, srng->num_entries); return mem; } static inline void dp_srng_mem_free_consistent(struct dp_soc *soc, struct dp_srng *srng) { if (srng->is_mem_prealloc) { if (!soc->cdp_soc.ol_ops->dp_prealloc_put_consistent) { dp_warn("dp_prealloc_put_consistent is null!"); QDF_BUG(0); return; } soc->cdp_soc.ol_ops->dp_prealloc_put_consistent (srng->alloc_size, srng->base_vaddr_unaligned, srng->base_paddr_unaligned); } else { qdf_mem_free_consistent(soc->osdev, soc->osdev->dev, srng->alloc_size, srng->base_vaddr_unaligned, srng->base_paddr_unaligned, 0); } } void dp_desc_multi_pages_mem_alloc(struct dp_soc *soc, enum qdf_dp_desc_type desc_type, struct qdf_mem_multi_page_t *pages, size_t element_size, uint32_t element_num, qdf_dma_context_t memctxt, bool cacheable) { if (!soc->cdp_soc.ol_ops->dp_get_multi_pages) { dp_warn("dp_get_multi_pages is null!"); goto qdf; } pages->num_pages = 0; pages->is_mem_prealloc = 0; soc->cdp_soc.ol_ops->dp_get_multi_pages(desc_type, element_size, element_num, pages, cacheable); if (pages->num_pages) goto end; qdf: qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size, element_num, memctxt, cacheable); end: dp_info("%s desc_type %d element_size %d element_num %d cacheable %d", pages->is_mem_prealloc ? "pre-alloc" : "dynamic-alloc", desc_type, (int)element_size, element_num, cacheable); } void dp_desc_multi_pages_mem_free(struct dp_soc *soc, enum qdf_dp_desc_type desc_type, struct qdf_mem_multi_page_t *pages, qdf_dma_context_t memctxt, bool cacheable) { if (pages->is_mem_prealloc) { if (!soc->cdp_soc.ol_ops->dp_put_multi_pages) { dp_warn("dp_put_multi_pages is null!"); QDF_BUG(0); return; } soc->cdp_soc.ol_ops->dp_put_multi_pages(desc_type, pages); qdf_mem_zero(pages, sizeof(*pages)); } else { qdf_mem_multi_pages_free(soc->osdev, pages, memctxt, cacheable); } } #else static inline void *dp_srng_aligned_mem_alloc_consistent(struct dp_soc *soc, struct dp_srng *srng, uint32_t ring_type) { void *mem; mem = qdf_aligned_mem_alloc_consistent(soc->osdev, &srng->alloc_size, &srng->base_vaddr_unaligned, &srng->base_paddr_unaligned, &srng->base_paddr_aligned, DP_RING_BASE_ALIGN); if (mem) qdf_mem_set(srng->base_vaddr_unaligned, 0, srng->alloc_size); return mem; } static inline void dp_srng_mem_free_consistent(struct dp_soc *soc, struct dp_srng *srng) { qdf_mem_free_consistent(soc->osdev, soc->osdev->dev, srng->alloc_size, srng->base_vaddr_unaligned, srng->base_paddr_unaligned, 0); } #endif /* DP_MEM_PRE_ALLOC */ #ifdef QCA_SUPPORT_WDS_EXTENDED bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev) { return vdev->wds_ext_enabled; } #else bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev) { return false; } #endif void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev) { struct dp_vdev *vdev = NULL; uint8_t rx_fast_flag = true; /* Check if protocol tagging enable */ if (pdev->is_rx_protocol_tagging_enabled) { rx_fast_flag = false; goto update_flag; } qdf_spin_lock_bh(&pdev->vdev_list_lock); TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { /* Check if any VDEV has NAWDS enabled */ if (vdev->nawds_enabled) { rx_fast_flag = false; break; } /* Check if any VDEV has multipass enabled */ if (vdev->multipass_en) { rx_fast_flag = false; break; } /* Check if any VDEV has mesh enabled */ if (vdev->mesh_vdev) { rx_fast_flag = false; break; } } qdf_spin_unlock_bh(&pdev->vdev_list_lock); update_flag: dp_init_info("Updated Rx fast flag to %u", rx_fast_flag); pdev->rx_fast_flag = rx_fast_flag; } void dp_soc_set_interrupt_mode(struct dp_soc *soc) { uint32_t msi_base_data, msi_vector_start; int msi_vector_count, ret; soc->intr_mode = DP_INTR_INTEGRATED; if (!(soc->wlan_cfg_ctx->napi_enabled) || (dp_is_monitor_mode_using_poll(soc) && soc->cdp_soc.ol_ops->get_con_mode && soc->cdp_soc.ol_ops->get_con_mode() == QDF_GLOBAL_MONITOR_MODE)) { soc->intr_mode = DP_INTR_POLL; } else { ret = pld_get_user_msi_assignment(soc->osdev->dev, "DP", &msi_vector_count, &msi_base_data, &msi_vector_start); if (ret) return; soc->intr_mode = DP_INTR_MSI; } } static int dp_srng_calculate_msi_group(struct dp_soc *soc, enum hal_ring_type ring_type, int ring_num, int *reg_msi_grp_num, bool nf_irq_support, int *nf_msi_grp_num) { struct wlan_cfg_dp_soc_ctxt *cfg_ctx = soc->wlan_cfg_ctx; uint8_t *grp_mask, *nf_irq_mask = NULL; bool nf_irq_enabled = false; uint8_t wbm2_sw_rx_rel_ring_id; switch (ring_type) { case WBM2SW_RELEASE: wbm2_sw_rx_rel_ring_id = wlan_cfg_get_rx_rel_ring_id(cfg_ctx); if (ring_num == wbm2_sw_rx_rel_ring_id) { /* dp_rx_wbm_err_process - soc->rx_rel_ring */ grp_mask = &cfg_ctx->int_rx_wbm_rel_ring_mask[0]; ring_num = 0; } else if (ring_num == WBM2_SW_PPE_REL_RING_ID) { grp_mask = &cfg_ctx->int_ppeds_wbm_release_ring_mask[0]; ring_num = 0; } else { /* dp_tx_comp_handler - soc->tx_comp_ring */ grp_mask = &soc->wlan_cfg_ctx->int_tx_ring_mask[0]; nf_irq_mask = dp_srng_get_near_full_irq_mask(soc, ring_type, ring_num); if (nf_irq_mask) nf_irq_enabled = true; /* * Using ring 4 as 4th tx completion ring since ring 3 * is Rx error ring */ if (ring_num == WBM2SW_TXCOMP_RING4_NUM) ring_num = TXCOMP_RING4_NUM; } break; case REO_EXCEPTION: /* dp_rx_err_process - &soc->reo_exception_ring */ grp_mask = &soc->wlan_cfg_ctx->int_rx_err_ring_mask[0]; break; case REO_DST: /* dp_rx_process - soc->reo_dest_ring */ grp_mask = &soc->wlan_cfg_ctx->int_rx_ring_mask[0]; nf_irq_mask = dp_srng_get_near_full_irq_mask(soc, ring_type, ring_num); if (nf_irq_mask) nf_irq_enabled = true; break; case REO_STATUS: /* dp_reo_status_ring_handler - soc->reo_status_ring */ grp_mask = &soc->wlan_cfg_ctx->int_reo_status_ring_mask[0]; break; /* dp_rx_mon_status_srng_process - pdev->rxdma_mon_status_ring*/ case RXDMA_MONITOR_STATUS: /* dp_rx_mon_dest_process - pdev->rxdma_mon_dst_ring */ case RXDMA_MONITOR_DST: /* dp_mon_process */ grp_mask = &soc->wlan_cfg_ctx->int_rx_mon_ring_mask[0]; break; case TX_MONITOR_DST: /* dp_tx_mon_process */ grp_mask = &soc->wlan_cfg_ctx->int_tx_mon_ring_mask[0]; break; case RXDMA_DST: /* dp_rxdma_err_process */ grp_mask = &soc->wlan_cfg_ctx->int_rxdma2host_ring_mask[0]; break; case RXDMA_BUF: grp_mask = &soc->wlan_cfg_ctx->int_host2rxdma_ring_mask[0]; break; case RXDMA_MONITOR_BUF: grp_mask = &soc->wlan_cfg_ctx->int_host2rxdma_mon_ring_mask[0]; break; case TX_MONITOR_BUF: grp_mask = &soc->wlan_cfg_ctx->int_host2txmon_ring_mask[0]; break; case REO2PPE: grp_mask = &soc->wlan_cfg_ctx->int_reo2ppe_ring_mask[0]; break; case PPE2TCL: grp_mask = &soc->wlan_cfg_ctx->int_ppe2tcl_ring_mask[0]; break; case TCL_DATA: /* CMD_CREDIT_RING is used as command in 8074 and credit in 9000 */ case TCL_CMD_CREDIT: case REO_CMD: case SW2WBM_RELEASE: case WBM_IDLE_LINK: /* normally empty SW_TO_HW rings */ return -QDF_STATUS_E_NOENT; break; case TCL_STATUS: case REO_REINJECT: /* misc unused rings */ return -QDF_STATUS_E_NOENT; break; case CE_SRC: case CE_DST: case CE_DST_STATUS: /* CE_rings - currently handled by hif */ default: return -QDF_STATUS_E_NOENT; break; } *reg_msi_grp_num = dp_srng_find_ring_in_mask(ring_num, grp_mask); if (nf_irq_support && nf_irq_enabled) { *nf_msi_grp_num = dp_srng_find_ring_in_mask(ring_num, nf_irq_mask); } return QDF_STATUS_SUCCESS; } #if defined(IPA_OFFLOAD) && defined(IPA_WDI3_VLAN_SUPPORT) static void dp_ipa_vlan_srng_msi_setup(struct hal_srng_params *ring_params, int ring_type, int ring_num) { if (wlan_ipa_is_vlan_enabled()) { if ((ring_type == REO_DST) && (ring_num == IPA_ALT_REO_DEST_RING_IDX)) { ring_params->msi_addr = 0; ring_params->msi_data = 0; ring_params->flags &= ~HAL_SRNG_MSI_INTR; } } } #else static inline void dp_ipa_vlan_srng_msi_setup(struct hal_srng_params *ring_params, int ring_type, int ring_num) { } #endif void dp_srng_msi_setup(struct dp_soc *soc, struct dp_srng *srng, struct hal_srng_params *ring_params, int ring_type, int ring_num) { int reg_msi_grp_num; /* * nf_msi_grp_num needs to be initialized with negative value, * to avoid configuring near-full msi for WBM2SW3 ring */ int nf_msi_grp_num = -1; int msi_data_count; int ret; uint32_t msi_data_start, msi_irq_start, addr_low, addr_high; bool nf_irq_support; int vector; ret = pld_get_user_msi_assignment(soc->osdev->dev, "DP", &msi_data_count, &msi_data_start, &msi_irq_start); if (ret) return; nf_irq_support = hal_srng_is_near_full_irq_supported(soc->hal_soc, ring_type, ring_num); ret = dp_srng_calculate_msi_group(soc, ring_type, ring_num, ®_msi_grp_num, nf_irq_support, &nf_msi_grp_num); if (ret < 0) { dp_init_info("%pK: ring not part of an ext_group; ring_type: %d,ring_num %d", soc, ring_type, ring_num); ring_params->msi_addr = 0; ring_params->msi_data = 0; dp_srng_set_msi2_ring_params(soc, ring_params, 0, 0); return; } if (reg_msi_grp_num < 0) { dp_init_info("%pK: ring not part of an ext_group; ring_type: %d,ring_num %d", soc, ring_type, ring_num); ring_params->msi_addr = 0; ring_params->msi_data = 0; goto configure_msi2; } if (dp_is_msi_group_number_invalid(soc, reg_msi_grp_num, msi_data_count)) { dp_init_warn("%pK: 2 msi_groups will share an msi; msi_group_num %d", soc, reg_msi_grp_num); QDF_ASSERT(0); } pld_get_msi_address(soc->osdev->dev, &addr_low, &addr_high); ring_params->msi_addr = addr_low; ring_params->msi_addr |= (qdf_dma_addr_t)(((uint64_t)addr_high) << 32); ring_params->msi_data = (reg_msi_grp_num % msi_data_count) + msi_data_start; ring_params->flags |= HAL_SRNG_MSI_INTR; dp_ipa_vlan_srng_msi_setup(ring_params, ring_type, ring_num); dp_debug("ring type %u ring_num %u msi->data %u msi_addr %llx", ring_type, ring_num, ring_params->msi_data, (uint64_t)ring_params->msi_addr); vector = msi_irq_start + (reg_msi_grp_num % msi_data_count); /* * During umac reset ppeds interrupts free is not called. * Avoid registering interrupts again. * */ if (dp_check_umac_reset_in_progress(soc)) goto configure_msi2; if (soc->arch_ops.dp_register_ppeds_interrupts) if (soc->arch_ops.dp_register_ppeds_interrupts(soc, srng, vector, ring_type, ring_num)) return; configure_msi2: if (!nf_irq_support) { dp_srng_set_msi2_ring_params(soc, ring_params, 0, 0); return; } dp_srng_msi2_setup(soc, ring_params, ring_type, ring_num, nf_msi_grp_num); } #ifdef WLAN_DP_PER_RING_TYPE_CONFIG /** * dp_srng_configure_interrupt_thresholds() - Retrieve interrupt * threshold values from the wlan_srng_cfg table for each ring type * @soc: device handle * @ring_params: per ring specific parameters * @ring_type: Ring type * @ring_num: Ring number for a given ring type * @num_entries: number of entries to fill * * Fill the ring params with the interrupt threshold * configuration parameters available in the per ring type wlan_srng_cfg * table. * * Return: None */ void dp_srng_configure_interrupt_thresholds(struct dp_soc *soc, struct hal_srng_params *ring_params, int ring_type, int ring_num, int num_entries) { uint8_t wbm2_sw_rx_rel_ring_id; wbm2_sw_rx_rel_ring_id = wlan_cfg_get_rx_rel_ring_id(soc->wlan_cfg_ctx); if (ring_type == REO_DST) { ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_rx(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_rx(soc->wlan_cfg_ctx); } else if (ring_type == WBM2SW_RELEASE && (ring_num == wbm2_sw_rx_rel_ring_id)) { ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_other(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_other(soc->wlan_cfg_ctx); } else { ring_params->intr_timer_thres_us = soc->wlan_srng_cfg[ring_type].timer_threshold; ring_params->intr_batch_cntr_thres_entries = soc->wlan_srng_cfg[ring_type].batch_count_threshold; } ring_params->low_threshold = soc->wlan_srng_cfg[ring_type].low_threshold; if (ring_params->low_threshold) ring_params->flags |= HAL_SRNG_LOW_THRES_INTR_ENABLE; dp_srng_configure_nf_interrupt_thresholds(soc, ring_params, ring_type); } #else void dp_srng_configure_interrupt_thresholds(struct dp_soc *soc, struct hal_srng_params *ring_params, int ring_type, int ring_num, int num_entries) { uint8_t wbm2_sw_rx_rel_ring_id; bool rx_refill_lt_disable; wbm2_sw_rx_rel_ring_id = wlan_cfg_get_rx_rel_ring_id(soc->wlan_cfg_ctx); if (ring_type == REO_DST || ring_type == REO2PPE) { ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_rx(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_rx(soc->wlan_cfg_ctx); } else if (ring_type == WBM2SW_RELEASE && (ring_num < wbm2_sw_rx_rel_ring_id || ring_num == WBM2SW_TXCOMP_RING4_NUM || ring_num == WBM2_SW_PPE_REL_RING_ID)) { ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_tx(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_tx(soc->wlan_cfg_ctx); } else if (ring_type == RXDMA_BUF) { rx_refill_lt_disable = wlan_cfg_get_dp_soc_rxdma_refill_lt_disable (soc->wlan_cfg_ctx); ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_rx(soc->wlan_cfg_ctx); if (!rx_refill_lt_disable) { ring_params->low_threshold = num_entries >> 3; ring_params->flags |= HAL_SRNG_LOW_THRES_INTR_ENABLE; ring_params->intr_batch_cntr_thres_entries = 0; } } else { ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_other(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_other(soc->wlan_cfg_ctx); } /* These rings donot require interrupt to host. Make them zero */ switch (ring_type) { case REO_REINJECT: case REO_CMD: case TCL_DATA: case TCL_CMD_CREDIT: case TCL_STATUS: case WBM_IDLE_LINK: case SW2WBM_RELEASE: case SW2RXDMA_NEW: ring_params->intr_timer_thres_us = 0; ring_params->intr_batch_cntr_thres_entries = 0; break; case PPE2TCL: ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_ppe2tcl(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_ppe2tcl(soc->wlan_cfg_ctx); break; case RXDMA_MONITOR_DST: ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_mon_dest(soc->wlan_cfg_ctx); ring_params->intr_batch_cntr_thres_entries = wlan_cfg_get_int_batch_threshold_mon_dest(soc->wlan_cfg_ctx); break; } /* Enable low threshold interrupts for rx buffer rings (regular and * monitor buffer rings. * TODO: See if this is required for any other ring */ if ((ring_type == RXDMA_MONITOR_BUF) || (ring_type == RXDMA_MONITOR_STATUS || (ring_type == TX_MONITOR_BUF))) { /* TODO: Setting low threshold to 1/8th of ring size * see if this needs to be configurable */ ring_params->low_threshold = num_entries >> 3; ring_params->intr_timer_thres_us = wlan_cfg_get_int_timer_threshold_rx(soc->wlan_cfg_ctx); ring_params->flags |= HAL_SRNG_LOW_THRES_INTR_ENABLE; ring_params->intr_batch_cntr_thres_entries = 0; } /* During initialisation monitor rings are only filled with * MON_BUF_MIN_ENTRIES entries. So low threshold needs to be set to * a value less than that. Low threshold value is reconfigured again * to 1/8th of the ring size when monitor vap is created. */ if (ring_type == RXDMA_MONITOR_BUF) ring_params->low_threshold = MON_BUF_MIN_ENTRIES >> 1; /* In case of PCI chipsets, we dont have PPDU end interrupts, * so MONITOR STATUS ring is reaped by receiving MSI from srng. * Keep batch threshold as 8 so that interrupt is received for * every 4 packets in MONITOR_STATUS ring */ if ((ring_type == RXDMA_MONITOR_STATUS) && (soc->intr_mode == DP_INTR_MSI)) ring_params->intr_batch_cntr_thres_entries = 4; } #endif static int dp_process_rxdma_dst_ring(struct dp_soc *soc, struct dp_intr *int_ctx, int mac_for_pdev, int total_budget) { uint32_t target_type; target_type = hal_get_target_type(soc->hal_soc); if (target_type == TARGET_TYPE_QCN9160) return dp_monitor_process(soc, int_ctx, mac_for_pdev, total_budget); else return dp_rxdma_err_process(int_ctx, soc, mac_for_pdev, total_budget); } /** * dp_process_lmac_rings() - Process LMAC rings * @int_ctx: interrupt context * @total_budget: budget of work which can be done * * Return: work done */ int dp_process_lmac_rings(struct dp_intr *int_ctx, int total_budget) { struct dp_intr_stats *intr_stats = &int_ctx->intr_stats; struct dp_soc *soc = int_ctx->soc; uint32_t remaining_quota = total_budget; struct dp_pdev *pdev = NULL; uint32_t work_done = 0; int budget = total_budget; int ring = 0; bool rx_refill_lt_disable; rx_refill_lt_disable = wlan_cfg_get_dp_soc_rxdma_refill_lt_disable(soc->wlan_cfg_ctx); /* Process LMAC interrupts */ for (ring = 0 ; ring < MAX_NUM_LMAC_HW; ring++) { int mac_for_pdev = ring; pdev = dp_get_pdev_for_lmac_id(soc, mac_for_pdev); if (!pdev) continue; if (int_ctx->rx_mon_ring_mask & (1 << mac_for_pdev)) { work_done = dp_monitor_process(soc, int_ctx, mac_for_pdev, remaining_quota); if (work_done) intr_stats->num_rx_mon_ring_masks++; budget -= work_done; if (budget <= 0) goto budget_done; remaining_quota = budget; } if (int_ctx->tx_mon_ring_mask & (1 << mac_for_pdev)) { work_done = dp_tx_mon_process(soc, int_ctx, mac_for_pdev, remaining_quota); if (work_done) intr_stats->num_tx_mon_ring_masks++; budget -= work_done; if (budget <= 0) goto budget_done; remaining_quota = budget; } if (int_ctx->rxdma2host_ring_mask & (1 << mac_for_pdev)) { work_done = dp_process_rxdma_dst_ring(soc, int_ctx, mac_for_pdev, remaining_quota); if (work_done) intr_stats->num_rxdma2host_ring_masks++; budget -= work_done; if (budget <= 0) goto budget_done; remaining_quota = budget; } if (int_ctx->host2rxdma_ring_mask & (1 << mac_for_pdev)) { struct dp_srng *rx_refill_buf_ring; struct rx_desc_pool *rx_desc_pool; rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev]; if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) rx_refill_buf_ring = &soc->rx_refill_buf_ring[mac_for_pdev]; else rx_refill_buf_ring = &soc->rx_refill_buf_ring[pdev->lmac_id]; intr_stats->num_host2rxdma_ring_masks++; if (!rx_refill_lt_disable) dp_rx_buffers_lt_replenish_simple (soc, mac_for_pdev, rx_refill_buf_ring, rx_desc_pool, false); } } if (int_ctx->host2rxdma_mon_ring_mask) dp_rx_mon_buf_refill(int_ctx); if (int_ctx->host2txmon_ring_mask) dp_tx_mon_buf_refill(int_ctx); budget_done: return total_budget - budget; } uint32_t dp_service_srngs_wrapper(void *dp_ctx, uint32_t dp_budget, int cpu) { struct dp_intr *int_ctx = (struct dp_intr *)dp_ctx; struct dp_soc *soc = int_ctx->soc; return soc->arch_ops.dp_service_srngs(dp_ctx, dp_budget, cpu); } #ifdef QCA_SUPPORT_LEGACY_INTERRUPTS /** * dp_soc_interrupt_map_calculate_wifi3_pci_legacy() - * Calculate interrupt map for legacy interrupts * @soc: DP soc handle * @intr_ctx_num: Interrupt context number * @irq_id_map: IRQ map * @num_irq_r: Number of interrupts assigned for this context * * Return: void */ static void dp_soc_interrupt_map_calculate_wifi3_pci_legacy(struct dp_soc *soc, int intr_ctx_num, int *irq_id_map, int *num_irq_r) { int j; int num_irq = 0; int tx_mask = wlan_cfg_get_tx_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_mask = wlan_cfg_get_rx_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_mon_mask = wlan_cfg_get_rx_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_err_ring_mask = wlan_cfg_get_rx_err_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_wbm_rel_ring_mask = wlan_cfg_get_rx_wbm_rel_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int reo_status_ring_mask = wlan_cfg_get_reo_status_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rxdma2host_ring_mask = wlan_cfg_get_rxdma2host_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_ring_mask = wlan_cfg_get_host2rxdma_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_mon_ring_mask = wlan_cfg_get_host2rxdma_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2txmon_ring_mask = wlan_cfg_get_host2txmon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int txmon2host_mon_ring_mask = wlan_cfg_get_tx_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); soc->intr_mode = DP_INTR_LEGACY_VIRTUAL_IRQ; for (j = 0; j < HIF_MAX_GRP_IRQ; j++) { if (tx_mask & (1 << j)) irq_id_map[num_irq++] = (wbm2sw0_release - j); if (rx_mask & (1 << j)) irq_id_map[num_irq++] = (reo2sw1_intr - j); if (rx_mon_mask & (1 << j)) irq_id_map[num_irq++] = (rxmon2sw_p0_dest0 - j); if (rx_err_ring_mask & (1 << j)) irq_id_map[num_irq++] = (reo2sw0_intr - j); if (rx_wbm_rel_ring_mask & (1 << j)) irq_id_map[num_irq++] = (wbm2sw5_release - j); if (reo_status_ring_mask & (1 << j)) irq_id_map[num_irq++] = (reo_status - j); if (rxdma2host_ring_mask & (1 << j)) irq_id_map[num_irq++] = (rxdma2sw_dst_ring0 - j); if (host2rxdma_ring_mask & (1 << j)) irq_id_map[num_irq++] = (sw2rxdma_0 - j); if (host2rxdma_mon_ring_mask & (1 << j)) irq_id_map[num_irq++] = (sw2rxmon_src_ring - j); if (host2txmon_ring_mask & (1 << j)) irq_id_map[num_irq++] = sw2txmon_src_ring; if (txmon2host_mon_ring_mask & (1 << j)) irq_id_map[num_irq++] = (txmon2sw_p0_dest0 - j); } *num_irq_r = num_irq; } #else static void dp_soc_interrupt_map_calculate_wifi3_pci_legacy(struct dp_soc *soc, int intr_ctx_num, int *irq_id_map, int *num_irq_r) { } #endif static void dp_soc_interrupt_map_calculate_integrated(struct dp_soc *soc, int intr_ctx_num, int *irq_id_map, int *num_irq_r) { int j; int num_irq = 0; int tx_mask = wlan_cfg_get_tx_ring_mask(soc->wlan_cfg_ctx, intr_ctx_num); int rx_mask = wlan_cfg_get_rx_ring_mask(soc->wlan_cfg_ctx, intr_ctx_num); int rx_mon_mask = wlan_cfg_get_rx_mon_ring_mask(soc->wlan_cfg_ctx, intr_ctx_num); int rx_err_ring_mask = wlan_cfg_get_rx_err_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_wbm_rel_ring_mask = wlan_cfg_get_rx_wbm_rel_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int reo_status_ring_mask = wlan_cfg_get_reo_status_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rxdma2host_ring_mask = wlan_cfg_get_rxdma2host_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_ring_mask = wlan_cfg_get_host2rxdma_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_mon_ring_mask = wlan_cfg_get_host2rxdma_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2txmon_ring_mask = wlan_cfg_get_host2txmon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int txmon2host_mon_ring_mask = wlan_cfg_get_tx_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); soc->intr_mode = DP_INTR_INTEGRATED; for (j = 0; j < HIF_MAX_GRP_IRQ; j++) { if (tx_mask & (1 << j)) { irq_id_map[num_irq++] = (wbm2host_tx_completions_ring1 - j); } if (rx_mask & (1 << j)) { irq_id_map[num_irq++] = (reo2host_destination_ring1 - j); } if (rxdma2host_ring_mask & (1 << j)) { irq_id_map[num_irq++] = rxdma2host_destination_ring_mac1 - j; } if (host2rxdma_ring_mask & (1 << j)) { irq_id_map[num_irq++] = host2rxdma_host_buf_ring_mac1 - j; } if (host2rxdma_mon_ring_mask & (1 << j)) { irq_id_map[num_irq++] = host2rxdma_monitor_ring1 - j; } if (rx_mon_mask & (1 << j)) { irq_id_map[num_irq++] = ppdu_end_interrupts_mac1 - j; irq_id_map[num_irq++] = rxdma2host_monitor_status_ring_mac1 - j; irq_id_map[num_irq++] = rxdma2host_monitor_destination_mac1 - j; } if (rx_wbm_rel_ring_mask & (1 << j)) irq_id_map[num_irq++] = wbm2host_rx_release; if (rx_err_ring_mask & (1 << j)) irq_id_map[num_irq++] = reo2host_exception; if (reo_status_ring_mask & (1 << j)) irq_id_map[num_irq++] = reo2host_status; if (host2txmon_ring_mask & (1 << j)) irq_id_map[num_irq++] = host2tx_monitor_ring1; if (txmon2host_mon_ring_mask & (1 << j)) { irq_id_map[num_irq++] = (txmon2host_monitor_destination_mac1 - j); } } *num_irq_r = num_irq; } static void dp_soc_interrupt_map_calculate_msi(struct dp_soc *soc, int intr_ctx_num, int *irq_id_map, int *num_irq_r, int msi_vector_count, int msi_vector_start) { int tx_mask = wlan_cfg_get_tx_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_mask = wlan_cfg_get_rx_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_mon_mask = wlan_cfg_get_rx_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int tx_mon_mask = wlan_cfg_get_tx_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_err_ring_mask = wlan_cfg_get_rx_err_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_wbm_rel_ring_mask = wlan_cfg_get_rx_wbm_rel_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int reo_status_ring_mask = wlan_cfg_get_reo_status_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rxdma2host_ring_mask = wlan_cfg_get_rxdma2host_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_ring_mask = wlan_cfg_get_host2rxdma_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int host2rxdma_mon_ring_mask = wlan_cfg_get_host2rxdma_mon_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); int rx_near_full_grp_1_mask = wlan_cfg_get_rx_near_full_grp_1_mask(soc->wlan_cfg_ctx, intr_ctx_num); int rx_near_full_grp_2_mask = wlan_cfg_get_rx_near_full_grp_2_mask(soc->wlan_cfg_ctx, intr_ctx_num); int tx_ring_near_full_mask = wlan_cfg_get_tx_ring_near_full_mask(soc->wlan_cfg_ctx, intr_ctx_num); int host2txmon_ring_mask = wlan_cfg_get_host2txmon_ring_mask(soc->wlan_cfg_ctx, intr_ctx_num); unsigned int vector = (intr_ctx_num % msi_vector_count) + msi_vector_start; int num_irq = 0; soc->intr_mode = DP_INTR_MSI; if (tx_mask | rx_mask | rx_mon_mask | tx_mon_mask | rx_err_ring_mask | rx_wbm_rel_ring_mask | reo_status_ring_mask | rxdma2host_ring_mask | host2rxdma_ring_mask | host2rxdma_mon_ring_mask | rx_near_full_grp_1_mask | rx_near_full_grp_2_mask | tx_ring_near_full_mask | host2txmon_ring_mask) irq_id_map[num_irq++] = pld_get_msi_irq(soc->osdev->dev, vector); *num_irq_r = num_irq; } void dp_soc_interrupt_map_calculate(struct dp_soc *soc, int intr_ctx_num, int *irq_id_map, int *num_irq) { int msi_vector_count, ret; uint32_t msi_base_data, msi_vector_start; if (pld_get_enable_intx(soc->osdev->dev)) { return dp_soc_interrupt_map_calculate_wifi3_pci_legacy(soc, intr_ctx_num, irq_id_map, num_irq); } ret = pld_get_user_msi_assignment(soc->osdev->dev, "DP", &msi_vector_count, &msi_base_data, &msi_vector_start); if (ret) return dp_soc_interrupt_map_calculate_integrated(soc, intr_ctx_num, irq_id_map, num_irq); else dp_soc_interrupt_map_calculate_msi(soc, intr_ctx_num, irq_id_map, num_irq, msi_vector_count, msi_vector_start); } void dp_srng_free(struct dp_soc *soc, struct dp_srng *srng) { if (srng->alloc_size && srng->base_vaddr_unaligned) { if (!srng->cached) { dp_srng_mem_free_consistent(soc, srng); } else { qdf_mem_free(srng->base_vaddr_unaligned); } srng->alloc_size = 0; srng->base_vaddr_unaligned = NULL; } srng->hal_srng = NULL; } qdf_export_symbol(dp_srng_free); QDF_STATUS dp_srng_init(struct dp_soc *soc, struct dp_srng *srng, int ring_type, int ring_num, int mac_id) { return soc->arch_ops.txrx_srng_init(soc, srng, ring_type, ring_num, mac_id); } qdf_export_symbol(dp_srng_init); QDF_STATUS dp_srng_alloc(struct dp_soc *soc, struct dp_srng *srng, int ring_type, uint32_t num_entries, bool cached) { hal_soc_handle_t hal_soc = soc->hal_soc; uint32_t entry_size = hal_srng_get_entrysize(hal_soc, ring_type); uint32_t max_entries = hal_srng_max_entries(hal_soc, ring_type); if (srng->base_vaddr_unaligned) { dp_init_err("%pK: Ring type: %d, is already allocated", soc, ring_type); return QDF_STATUS_SUCCESS; } num_entries = (num_entries > max_entries) ? max_entries : num_entries; srng->hal_srng = NULL; srng->alloc_size = num_entries * entry_size; srng->num_entries = num_entries; srng->cached = cached; if (!cached) { srng->base_vaddr_aligned = dp_srng_aligned_mem_alloc_consistent(soc, srng, ring_type); } else { srng->base_vaddr_aligned = qdf_aligned_malloc( &srng->alloc_size, &srng->base_vaddr_unaligned, &srng->base_paddr_unaligned, &srng->base_paddr_aligned, DP_RING_BASE_ALIGN); } if (!srng->base_vaddr_aligned) return QDF_STATUS_E_NOMEM; return QDF_STATUS_SUCCESS; } qdf_export_symbol(dp_srng_alloc); void dp_srng_deinit(struct dp_soc *soc, struct dp_srng *srng, int ring_type, int ring_num) { if (!srng->hal_srng) { dp_init_err("%pK: Ring type: %d, num:%d not setup", soc, ring_type, ring_num); return; } if (dp_check_umac_reset_in_progress(soc)) goto srng_cleanup; if (soc->arch_ops.dp_free_ppeds_interrupts) soc->arch_ops.dp_free_ppeds_interrupts(soc, srng, ring_type, ring_num); srng_cleanup: hal_srng_cleanup(soc->hal_soc, srng->hal_srng, dp_check_umac_reset_in_progress(soc)); srng->hal_srng = NULL; } qdf_export_symbol(dp_srng_deinit); /* TODO: Need this interface from HIF */ void *hif_get_hal_handle(struct hif_opaque_softc *hif_handle); #ifdef WLAN_FEATURE_DP_EVENT_HISTORY int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl) { hal_soc_handle_t hal_soc = dp_soc->hal_soc; uint32_t hp, tp; uint8_t ring_id; if (!int_ctx) return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); hal_get_sw_hptp(hal_soc, hal_ring_hdl, &tp, &hp); ring_id = hal_srng_ring_id_get(hal_ring_hdl); hif_record_event(dp_soc->hif_handle, int_ctx->dp_intr_id, ring_id, hp, tp, HIF_EVENT_SRNG_ACCESS_START); return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); } void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl) { hal_soc_handle_t hal_soc = dp_soc->hal_soc; uint32_t hp, tp; uint8_t ring_id; if (!int_ctx) return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); hal_get_sw_hptp(hal_soc, hal_ring_hdl, &tp, &hp); ring_id = hal_srng_ring_id_get(hal_ring_hdl); hif_record_event(dp_soc->hif_handle, int_ctx->dp_intr_id, ring_id, hp, tp, HIF_EVENT_SRNG_ACCESS_END); return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); } static inline void dp_srng_record_timer_entry(struct dp_soc *dp_soc, uint8_t hist_group_id) { hif_record_event(dp_soc->hif_handle, hist_group_id, 0, 0, 0, HIF_EVENT_TIMER_ENTRY); } static inline void dp_srng_record_timer_exit(struct dp_soc *dp_soc, uint8_t hist_group_id) { hif_record_event(dp_soc->hif_handle, hist_group_id, 0, 0, 0, HIF_EVENT_TIMER_EXIT); } #else static inline void dp_srng_record_timer_entry(struct dp_soc *dp_soc, uint8_t hist_group_id) { } static inline void dp_srng_record_timer_exit(struct dp_soc *dp_soc, uint8_t hist_group_id) { } #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ enum timer_yield_status dp_should_timer_irq_yield(struct dp_soc *soc, uint32_t work_done, uint64_t start_time) { uint64_t cur_time = qdf_get_log_timestamp(); if (!work_done) return DP_TIMER_WORK_DONE; if (cur_time - start_time > DP_MAX_TIMER_EXEC_TIME_TICKS) return DP_TIMER_TIME_EXHAUST; return DP_TIMER_NO_YIELD; } qdf_export_symbol(dp_should_timer_irq_yield); void dp_interrupt_timer(void *arg) { struct dp_soc *soc = (struct dp_soc *) arg; struct dp_pdev *pdev = soc->pdev_list[0]; enum timer_yield_status yield = DP_TIMER_NO_YIELD; uint32_t work_done = 0, total_work_done = 0; int budget = 0xffff, i; uint32_t remaining_quota = budget; uint64_t start_time; uint32_t lmac_id = DP_MON_INVALID_LMAC_ID; uint8_t dp_intr_id = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); uint32_t lmac_iter; int max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx); enum reg_wifi_band mon_band; int cpu = dp_srng_get_cpu(); /* * this logic makes all data path interfacing rings (UMAC/LMAC) * and Monitor rings polling mode when NSS offload is disabled */ if (wlan_cfg_is_poll_mode_enabled(soc->wlan_cfg_ctx) && !wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { if (qdf_atomic_read(&soc->cmn_init_done)) { for (i = 0; i < wlan_cfg_get_num_contexts( soc->wlan_cfg_ctx); i++) soc->arch_ops.dp_service_srngs(&soc->intr_ctx[i], 0xffff, cpu); qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); } return; } if (!qdf_atomic_read(&soc->cmn_init_done)) return; if (dp_monitor_is_chan_band_known(pdev)) { mon_band = dp_monitor_get_chan_band(pdev); lmac_id = pdev->ch_band_lmac_id_mapping[mon_band]; if (qdf_likely(lmac_id != DP_MON_INVALID_LMAC_ID)) { dp_intr_id = soc->mon_intr_id_lmac_map[lmac_id]; dp_srng_record_timer_entry(soc, dp_intr_id); } } start_time = qdf_get_log_timestamp(); dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings); while (yield == DP_TIMER_NO_YIELD) { for (lmac_iter = 0; lmac_iter < max_mac_rings; lmac_iter++) { if (lmac_iter == lmac_id) work_done = dp_monitor_process(soc, &soc->intr_ctx[dp_intr_id], lmac_iter, remaining_quota); else work_done = dp_monitor_drop_packets_for_mac(pdev, lmac_iter, remaining_quota); if (work_done) { budget -= work_done; if (budget <= 0) { yield = DP_TIMER_WORK_EXHAUST; goto budget_done; } remaining_quota = budget; total_work_done += work_done; } } yield = dp_should_timer_irq_yield(soc, total_work_done, start_time); total_work_done = 0; } budget_done: if (yield == DP_TIMER_WORK_EXHAUST || yield == DP_TIMER_TIME_EXHAUST) qdf_timer_mod(&soc->int_timer, 1); else qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); if (lmac_id != DP_MON_INVALID_LMAC_ID) dp_srng_record_timer_exit(soc, dp_intr_id); } /** * dp_soc_interrupt_detach_wrapper() - wrapper function for interrupt detach * @txrx_soc: DP SOC handle * * Return: None */ static void dp_soc_interrupt_detach_wrapper(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; return soc->arch_ops.dp_soc_interrupt_detach(txrx_soc); } #if defined(DP_INTR_POLL_BOTH) /** * dp_soc_interrupt_attach_wrapper() - Register handlers for DP interrupts * @txrx_soc: DP SOC handle * * Call the appropriate attach function based on the mode of operation. * This is a WAR for enabling monitor mode. * * Return: 0 for success. nonzero for failure. */ static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; if (!(soc->wlan_cfg_ctx->napi_enabled) || (dp_is_monitor_mode_using_poll(soc) && soc->cdp_soc.ol_ops->get_con_mode && soc->cdp_soc.ol_ops->get_con_mode() == QDF_GLOBAL_MONITOR_MODE)) { dp_info("Poll mode"); return soc->arch_ops.dp_soc_attach_poll(txrx_soc); } else { dp_info("Interrupt mode"); return soc->arch_ops.dp_soc_interrupt_attach(txrx_soc); } } #else #if defined(DP_INTR_POLL_BASED) && DP_INTR_POLL_BASED static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; return soc->arch_ops.dp_soc_attach_poll(txrx_soc); } #else static QDF_STATUS dp_soc_interrupt_attach_wrapper(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; if (wlan_cfg_is_poll_mode_enabled(soc->wlan_cfg_ctx)) return soc->arch_ops.dp_soc_attach_poll(txrx_soc); else return soc->arch_ops.dp_soc_interrupt_attach(txrx_soc); } #endif #endif void dp_link_desc_ring_replenish(struct dp_soc *soc, uint32_t mac_id) { uint32_t cookie = 0; uint32_t page_idx = 0; struct qdf_mem_multi_page_t *pages; struct qdf_mem_dma_page_t *dma_pages; uint32_t offset = 0; uint32_t count = 0; uint32_t desc_id = 0; void *desc_srng; int link_desc_size = hal_get_link_desc_size(soc->hal_soc); uint32_t *total_link_descs_addr; uint32_t total_link_descs; uint32_t scatter_buf_num; uint32_t num_entries_per_buf = 0; uint32_t rem_entries; uint32_t num_descs_per_page; uint32_t num_scatter_bufs = 0; uint8_t *scatter_buf_ptr; void *desc; num_scatter_bufs = soc->num_scatter_bufs; if (mac_id == WLAN_INVALID_PDEV_ID) { pages = &soc->link_desc_pages; total_link_descs = soc->total_link_descs; desc_srng = soc->wbm_idle_link_ring.hal_srng; } else { pages = dp_monitor_get_link_desc_pages(soc, mac_id); /* dp_monitor_get_link_desc_pages returns NULL only * if monitor SOC is NULL */ if (!pages) { dp_err("can not get link desc pages"); QDF_ASSERT(0); return; } total_link_descs_addr = dp_monitor_get_total_link_descs(soc, mac_id); total_link_descs = *total_link_descs_addr; desc_srng = dp_monitor_get_link_desc_ring(soc, mac_id); } dma_pages = pages->dma_pages; do { qdf_mem_zero(dma_pages[page_idx].page_v_addr_start, pages->page_size); page_idx++; } while (page_idx < pages->num_pages); if (desc_srng) { hal_srng_access_start_unlocked(soc->hal_soc, desc_srng); page_idx = 0; count = 0; offset = 0; qdf_assert(pages->num_element_per_page != 0); while ((desc = hal_srng_src_get_next(soc->hal_soc, desc_srng)) && (count < total_link_descs)) { page_idx = count / pages->num_element_per_page; if (desc_id == pages->num_element_per_page) desc_id = 0; offset = count % pages->num_element_per_page; cookie = LINK_DESC_COOKIE(desc_id, page_idx, soc->link_desc_id_start); hal_set_link_desc_addr(soc->hal_soc, desc, cookie, dma_pages[page_idx].page_p_addr + (offset * link_desc_size), soc->idle_link_bm_id); count++; desc_id++; } hal_srng_access_end_unlocked(soc->hal_soc, desc_srng); } else { /* Populate idle list scatter buffers with link descriptor * pointers */ scatter_buf_num = 0; num_entries_per_buf = hal_idle_scatter_buf_num_entries( soc->hal_soc, soc->wbm_idle_scatter_buf_size); scatter_buf_ptr = (uint8_t *)( soc->wbm_idle_scatter_buf_base_vaddr[scatter_buf_num]); rem_entries = num_entries_per_buf; page_idx = 0; count = 0; offset = 0; num_descs_per_page = pages->num_element_per_page; qdf_assert(num_descs_per_page != 0); while (count < total_link_descs) { page_idx = count / num_descs_per_page; offset = count % num_descs_per_page; if (desc_id == pages->num_element_per_page) desc_id = 0; cookie = LINK_DESC_COOKIE(desc_id, page_idx, soc->link_desc_id_start); hal_set_link_desc_addr(soc->hal_soc, (void *)scatter_buf_ptr, cookie, dma_pages[page_idx].page_p_addr + (offset * link_desc_size), soc->idle_link_bm_id); rem_entries--; if (rem_entries) { scatter_buf_ptr += link_desc_size; } else { rem_entries = num_entries_per_buf; scatter_buf_num++; if (scatter_buf_num >= num_scatter_bufs) { scatter_buf_num--; break; } scatter_buf_ptr = (uint8_t *) (soc->wbm_idle_scatter_buf_base_vaddr[ scatter_buf_num]); } count++; desc_id++; } /* Setup link descriptor idle list in HW */ hal_setup_link_idle_list(soc->hal_soc, soc->wbm_idle_scatter_buf_base_paddr, soc->wbm_idle_scatter_buf_base_vaddr, num_scatter_bufs, soc->wbm_idle_scatter_buf_size, (uint32_t)(scatter_buf_ptr - (uint8_t *)(soc->wbm_idle_scatter_buf_base_vaddr[ scatter_buf_num])), total_link_descs); } } qdf_export_symbol(dp_link_desc_ring_replenish); /** * dp_soc_ppeds_stop() - Stop PPE DS processing * @soc_handle: DP SOC handle * * Return: none */ static void dp_soc_ppeds_stop(struct cdp_soc_t *soc_handle) { struct dp_soc *soc = (struct dp_soc *)soc_handle; if (soc->arch_ops.txrx_soc_ppeds_stop) soc->arch_ops.txrx_soc_ppeds_stop(soc); } #ifdef ENABLE_VERBOSE_DEBUG void dp_enable_verbose_debug(struct dp_soc *soc) { struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; soc_cfg_ctx = soc->wlan_cfg_ctx; if (soc_cfg_ctx->per_pkt_trace & dp_verbose_debug_mask) is_dp_verbose_debug_enabled = true; if (soc_cfg_ctx->per_pkt_trace & hal_verbose_debug_mask) hal_set_verbose_debug(true); else hal_set_verbose_debug(false); } #else void dp_enable_verbose_debug(struct dp_soc *soc) { } #endif static QDF_STATUS dp_lro_hash_setup(struct dp_soc *soc, struct dp_pdev *pdev) { struct cdp_lro_hash_config lro_hash; QDF_STATUS status; if (!wlan_cfg_is_lro_enabled(soc->wlan_cfg_ctx) && !wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx) && !wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { dp_err("LRO, GRO and RX hash disabled"); return QDF_STATUS_E_FAILURE; } qdf_mem_zero(&lro_hash, sizeof(lro_hash)); if (wlan_cfg_is_lro_enabled(soc->wlan_cfg_ctx) || wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx)) { lro_hash.lro_enable = 1; lro_hash.tcp_flag = QDF_TCPHDR_ACK; lro_hash.tcp_flag_mask = QDF_TCPHDR_FIN | QDF_TCPHDR_SYN | QDF_TCPHDR_RST | QDF_TCPHDR_ACK | QDF_TCPHDR_URG | QDF_TCPHDR_ECE | QDF_TCPHDR_CWR; } soc->arch_ops.get_rx_hash_key(soc, &lro_hash); qdf_assert(soc->cdp_soc.ol_ops->lro_hash_config); if (!soc->cdp_soc.ol_ops->lro_hash_config) { QDF_BUG(0); dp_err("lro_hash_config not configured"); return QDF_STATUS_E_FAILURE; } status = soc->cdp_soc.ol_ops->lro_hash_config(soc->ctrl_psoc, pdev->pdev_id, &lro_hash); if (!QDF_IS_STATUS_SUCCESS(status)) { dp_err("failed to send lro_hash_config to FW %u", status); return status; } dp_info("LRO CMD config: lro_enable: 0x%x tcp_flag 0x%x tcp_flag_mask 0x%x", lro_hash.lro_enable, lro_hash.tcp_flag, lro_hash.tcp_flag_mask); dp_info("toeplitz_hash_ipv4:"); qdf_trace_hex_dump(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, lro_hash.toeplitz_hash_ipv4, (sizeof(lro_hash.toeplitz_hash_ipv4[0]) * LRO_IPV4_SEED_ARR_SZ)); dp_info("toeplitz_hash_ipv6:"); qdf_trace_hex_dump(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, lro_hash.toeplitz_hash_ipv6, (sizeof(lro_hash.toeplitz_hash_ipv6[0]) * LRO_IPV6_SEED_ARR_SZ)); return status; } #if defined(WLAN_MAX_PDEVS) && (WLAN_MAX_PDEVS == 1) /** * dp_reap_timer_init() - initialize the reap timer * @soc: data path SoC handle * * Return: void */ static void dp_reap_timer_init(struct dp_soc *soc) { /* * Timer to reap rxdma status rings. * Needed until we enable ppdu end interrupts */ dp_monitor_reap_timer_init(soc); dp_monitor_vdev_timer_init(soc); } /** * dp_reap_timer_deinit() - de-initialize the reap timer * @soc: data path SoC handle * * Return: void */ static void dp_reap_timer_deinit(struct dp_soc *soc) { dp_monitor_reap_timer_deinit(soc); } #else /* WIN use case */ static void dp_reap_timer_init(struct dp_soc *soc) { /* Configure LMAC rings in Polled mode */ if (soc->lmac_polled_mode) { /* * Timer to reap lmac rings. */ qdf_timer_init(soc->osdev, &soc->lmac_reap_timer, dp_service_lmac_rings, (void *)soc, QDF_TIMER_TYPE_WAKE_APPS); soc->lmac_timer_init = 1; qdf_timer_mod(&soc->lmac_reap_timer, DP_INTR_POLL_TIMER_MS); } } static void dp_reap_timer_deinit(struct dp_soc *soc) { if (soc->lmac_timer_init) { qdf_timer_stop(&soc->lmac_reap_timer); qdf_timer_free(&soc->lmac_reap_timer); soc->lmac_timer_init = 0; } } #endif #ifdef QCA_HOST2FW_RXBUF_RING /** * dp_rxdma_ring_alloc() - allocate the RXDMA rings * @soc: data path SoC handle * @pdev: Physical device handle * * Return: 0 - success, > 0 - failure */ static int dp_rxdma_ring_alloc(struct dp_soc *soc, struct dp_pdev *pdev) { struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx; int max_mac_rings; int i; int ring_size; pdev_cfg_ctx = pdev->wlan_cfg_ctx; max_mac_rings = wlan_cfg_get_num_mac_rings(pdev_cfg_ctx); ring_size = wlan_cfg_get_rx_dma_buf_ring_size(pdev_cfg_ctx); for (i = 0; i < max_mac_rings; i++) { dp_verbose_debug("pdev_id %d mac_id %d", pdev->pdev_id, i); if (dp_srng_alloc(soc, &pdev->rx_mac_buf_ring[i], RXDMA_BUF, ring_size, 0)) { dp_init_err("%pK: failed rx mac ring setup", soc); return QDF_STATUS_E_FAILURE; } } return QDF_STATUS_SUCCESS; } /** * dp_rxdma_ring_setup() - configure the RXDMA rings * @soc: data path SoC handle * @pdev: Physical device handle * * Return: 0 - success, > 0 - failure */ static int dp_rxdma_ring_setup(struct dp_soc *soc, struct dp_pdev *pdev) { struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx; int max_mac_rings; int i; pdev_cfg_ctx = pdev->wlan_cfg_ctx; max_mac_rings = wlan_cfg_get_num_mac_rings(pdev_cfg_ctx); for (i = 0; i < max_mac_rings; i++) { dp_verbose_debug("pdev_id %d mac_id %d", pdev->pdev_id, i); if (dp_srng_init(soc, &pdev->rx_mac_buf_ring[i], RXDMA_BUF, 1, i)) { dp_init_err("%pK: failed rx mac ring setup", soc); return QDF_STATUS_E_FAILURE; } dp_ssr_dump_srng_register("rx_mac_buf_ring", &pdev->rx_mac_buf_ring[i], i); } return QDF_STATUS_SUCCESS; } /** * dp_rxdma_ring_cleanup() - Deinit the RXDMA rings and reap timer * @soc: data path SoC handle * @pdev: Physical device handle * * Return: void */ static void dp_rxdma_ring_cleanup(struct dp_soc *soc, struct dp_pdev *pdev) { int i; for (i = 0; i < MAX_RX_MAC_RINGS; i++) { dp_ssr_dump_srng_unregister("rx_mac_buf_ring", i); dp_srng_deinit(soc, &pdev->rx_mac_buf_ring[i], RXDMA_BUF, 1); } dp_reap_timer_deinit(soc); } /** * dp_rxdma_ring_free() - Free the RXDMA rings * @pdev: Physical device handle * * Return: void */ static void dp_rxdma_ring_free(struct dp_pdev *pdev) { int i; for (i = 0; i < MAX_RX_MAC_RINGS; i++) dp_srng_free(pdev->soc, &pdev->rx_mac_buf_ring[i]); } #else static int dp_rxdma_ring_alloc(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static int dp_rxdma_ring_setup(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static void dp_rxdma_ring_cleanup(struct dp_soc *soc, struct dp_pdev *pdev) { dp_reap_timer_deinit(soc); } static void dp_rxdma_ring_free(struct dp_pdev *pdev) { } #endif #ifdef IPA_OFFLOAD /** * dp_setup_ipa_rx_refill_buf_ring - Setup second Rx refill buffer ring * @soc: data path instance * @pdev: core txrx pdev context * * Return: QDF_STATUS_SUCCESS: success * QDF_STATUS_E_RESOURCES: Error return */ static int dp_setup_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; int entries; if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { soc_cfg_ctx = soc->wlan_cfg_ctx; entries = wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); /* Setup second Rx refill buffer ring */ if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, entries, 0)) { dp_init_err("%pK: dp_srng_alloc failed second" "rx refill ring", soc); return QDF_STATUS_E_FAILURE; } } return QDF_STATUS_SUCCESS; } #ifdef IPA_WDI3_VLAN_SUPPORT static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; int entries; if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && wlan_ipa_is_vlan_enabled()) { soc_cfg_ctx = soc->wlan_cfg_ctx; entries = wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); /* Setup second Rx refill buffer ring */ if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, entries, 0)) { dp_init_err("%pK: alloc failed for 3rd rx refill ring", soc); return QDF_STATUS_E_FAILURE; } } return QDF_STATUS_SUCCESS; } static int dp_init_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && wlan_ipa_is_vlan_enabled()) { if (dp_srng_init(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, IPA_RX_ALT_REFILL_BUF_RING_IDX, pdev->pdev_id)) { dp_init_err("%pK: init failed for 3rd rx refill ring", soc); return QDF_STATUS_E_FAILURE; } } return QDF_STATUS_SUCCESS; } static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && wlan_ipa_is_vlan_enabled()) dp_srng_deinit(soc, &pdev->rx_refill_buf_ring3, RXDMA_BUF, 0); } static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx) && wlan_ipa_is_vlan_enabled()) dp_srng_free(soc, &pdev->rx_refill_buf_ring3); } #else static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static int dp_init_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } #endif /** * dp_deinit_ipa_rx_refill_buf_ring - deinit second Rx refill buffer ring * @soc: data path instance * @pdev: core txrx pdev context * * Return: void */ static void dp_deinit_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) dp_srng_deinit(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, 0); } /** * dp_init_ipa_rx_refill_buf_ring - Init second Rx refill buffer ring * @soc: data path instance * @pdev: core txrx pdev context * * Return: QDF_STATUS_SUCCESS: success * QDF_STATUS_E_RESOURCES: Error return */ static int dp_init_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { if (dp_srng_init(soc, &pdev->rx_refill_buf_ring2, RXDMA_BUF, IPA_RX_REFILL_BUF_RING_IDX, pdev->pdev_id)) { dp_init_err("%pK: dp_srng_init failed second" "rx refill ring", soc); return QDF_STATUS_E_FAILURE; } } if (dp_init_ipa_rx_alt_refill_buf_ring(soc, pdev)) { dp_deinit_ipa_rx_refill_buf_ring(soc, pdev); return QDF_STATUS_E_FAILURE; } return QDF_STATUS_SUCCESS; } /** * dp_free_ipa_rx_refill_buf_ring - free second Rx refill buffer ring * @soc: data path instance * @pdev: core txrx pdev context * * Return: void */ static void dp_free_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) dp_srng_free(soc, &pdev->rx_refill_buf_ring2); } #else static int dp_setup_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static int dp_init_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static void dp_deinit_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } static void dp_free_ipa_rx_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } static int dp_setup_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static void dp_deinit_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } static void dp_free_ipa_rx_alt_refill_buf_ring(struct dp_soc *soc, struct dp_pdev *pdev) { } #endif #ifdef WLAN_FEATURE_DP_CFG_EVENT_HISTORY /** * dp_soc_cfg_history_attach() - Allocate and attach datapath config events * history * @soc: DP soc handle * * Return: None */ static void dp_soc_cfg_history_attach(struct dp_soc *soc) { dp_soc_frag_history_attach(soc, &soc->cfg_event_history, DP_CFG_EVT_HIST_MAX_SLOTS, DP_CFG_EVT_HIST_PER_SLOT_MAX, sizeof(struct dp_cfg_event), true, DP_CFG_EVENT_HIST_TYPE); } /** * dp_soc_cfg_history_detach() - Detach and free DP config events history * @soc: DP soc handle * * Return: none */ static void dp_soc_cfg_history_detach(struct dp_soc *soc) { dp_soc_frag_history_detach(soc, &soc->cfg_event_history, DP_CFG_EVT_HIST_MAX_SLOTS, true, DP_CFG_EVENT_HIST_TYPE); } #else static void dp_soc_cfg_history_attach(struct dp_soc *soc) { } static void dp_soc_cfg_history_detach(struct dp_soc *soc) { } #endif #ifdef DP_TX_HW_DESC_HISTORY /** * dp_soc_tx_hw_desc_history_attach - Attach TX HW descriptor history * * @soc: DP soc handle * * Return: None */ static void dp_soc_tx_hw_desc_history_attach(struct dp_soc *soc) { dp_soc_frag_history_attach(soc, &soc->tx_hw_desc_history, DP_TX_HW_DESC_HIST_MAX_SLOTS, DP_TX_HW_DESC_HIST_PER_SLOT_MAX, sizeof(struct dp_tx_hw_desc_evt), true, DP_TX_HW_DESC_HIST_TYPE); } static void dp_soc_tx_hw_desc_history_detach(struct dp_soc *soc) { dp_soc_frag_history_detach(soc, &soc->tx_hw_desc_history, DP_TX_HW_DESC_HIST_MAX_SLOTS, true, DP_TX_HW_DESC_HIST_TYPE); } #else /* DP_TX_HW_DESC_HISTORY */ static inline void dp_soc_tx_hw_desc_history_attach(struct dp_soc *soc) { } static inline void dp_soc_tx_hw_desc_history_detach(struct dp_soc *soc) { } #endif /* DP_TX_HW_DESC_HISTORY */ #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY #ifndef RX_DEFRAG_DO_NOT_REINJECT /** * dp_soc_rx_reinject_ring_history_attach - Attach the reo reinject ring * history. * @soc: DP soc handle * * Return: None */ static void dp_soc_rx_reinject_ring_history_attach(struct dp_soc *soc) { soc->rx_reinject_ring_history = dp_context_alloc_mem(soc, DP_RX_REINJECT_RING_HIST_TYPE, sizeof(struct dp_rx_reinject_history)); if (soc->rx_reinject_ring_history) qdf_atomic_init(&soc->rx_reinject_ring_history->index); } #else /* RX_DEFRAG_DO_NOT_REINJECT */ static inline void dp_soc_rx_reinject_ring_history_attach(struct dp_soc *soc) { } #endif /* RX_DEFRAG_DO_NOT_REINJECT */ /** * dp_soc_rx_history_attach() - Attach the ring history record buffers * @soc: DP soc structure * * This function allocates the memory for recording the rx ring, rx error * ring and the reinject ring entries. There is no error returned in case * of allocation failure since the record function checks if the history is * initialized or not. We do not want to fail the driver load in case of * failure to allocate memory for debug history. * * Return: None */ static void dp_soc_rx_history_attach(struct dp_soc *soc) { int i; uint32_t rx_ring_hist_size; uint32_t rx_refill_ring_hist_size; rx_ring_hist_size = sizeof(*soc->rx_ring_history[0]); rx_refill_ring_hist_size = sizeof(*soc->rx_refill_ring_history[0]); for (i = 0; i < MAX_REO_DEST_RINGS; i++) { soc->rx_ring_history[i] = dp_context_alloc_mem( soc, DP_RX_RING_HIST_TYPE, rx_ring_hist_size); if (soc->rx_ring_history[i]) qdf_atomic_init(&soc->rx_ring_history[i]->index); } soc->rx_err_ring_history = dp_context_alloc_mem( soc, DP_RX_ERR_RING_HIST_TYPE, rx_ring_hist_size); if (soc->rx_err_ring_history) qdf_atomic_init(&soc->rx_err_ring_history->index); dp_soc_rx_reinject_ring_history_attach(soc); for (i = 0; i < MAX_PDEV_CNT; i++) { soc->rx_refill_ring_history[i] = dp_context_alloc_mem( soc, DP_RX_REFILL_RING_HIST_TYPE, rx_refill_ring_hist_size); if (soc->rx_refill_ring_history[i]) qdf_atomic_init(&soc->rx_refill_ring_history[i]->index); } } static void dp_soc_rx_history_detach(struct dp_soc *soc) { int i; for (i = 0; i < MAX_REO_DEST_RINGS; i++) dp_context_free_mem(soc, DP_RX_RING_HIST_TYPE, soc->rx_ring_history[i]); dp_context_free_mem(soc, DP_RX_ERR_RING_HIST_TYPE, soc->rx_err_ring_history); /* * No need for a featurized detach since qdf_mem_free takes * care of NULL pointer. */ dp_context_free_mem(soc, DP_RX_REINJECT_RING_HIST_TYPE, soc->rx_reinject_ring_history); for (i = 0; i < MAX_PDEV_CNT; i++) dp_context_free_mem(soc, DP_RX_REFILL_RING_HIST_TYPE, soc->rx_refill_ring_history[i]); } #else static inline void dp_soc_rx_history_attach(struct dp_soc *soc) { } static inline void dp_soc_rx_history_detach(struct dp_soc *soc) { } #endif #ifdef WLAN_FEATURE_DP_MON_STATUS_RING_HISTORY /** * dp_soc_mon_status_ring_history_attach() - Attach the monitor status * buffer record history. * @soc: DP soc handle * * This function allocates memory to track the event for a monitor * status buffer, before its parsed and freed. * * Return: None */ static void dp_soc_mon_status_ring_history_attach(struct dp_soc *soc) { soc->mon_status_ring_history = dp_context_alloc_mem(soc, DP_MON_STATUS_BUF_HIST_TYPE, sizeof(struct dp_mon_status_ring_history)); if (!soc->mon_status_ring_history) { dp_err("Failed to alloc memory for mon status ring history"); return; } } /** * dp_soc_mon_status_ring_history_detach() - Detach the monitor status buffer * record history. * @soc: DP soc handle * * Return: None */ static void dp_soc_mon_status_ring_history_detach(struct dp_soc *soc) { dp_context_free_mem(soc, DP_MON_STATUS_BUF_HIST_TYPE, soc->mon_status_ring_history); } #else static void dp_soc_mon_status_ring_history_attach(struct dp_soc *soc) { } static void dp_soc_mon_status_ring_history_detach(struct dp_soc *soc) { } #endif #ifdef WLAN_FEATURE_DP_TX_DESC_HISTORY /** * dp_soc_tx_history_attach() - Attach the ring history record buffers * @soc: DP soc structure * * This function allocates the memory for recording the tx tcl ring and * the tx comp ring entries. There is no error returned in case * of allocation failure since the record function checks if the history is * initialized or not. We do not want to fail the driver load in case of * failure to allocate memory for debug history. * * Return: None */ static void dp_soc_tx_history_attach(struct dp_soc *soc) { dp_soc_frag_history_attach(soc, &soc->tx_tcl_history, DP_TX_TCL_HIST_MAX_SLOTS, DP_TX_TCL_HIST_PER_SLOT_MAX, sizeof(struct dp_tx_desc_event), true, DP_TX_TCL_HIST_TYPE); dp_soc_frag_history_attach(soc, &soc->tx_comp_history, DP_TX_COMP_HIST_MAX_SLOTS, DP_TX_COMP_HIST_PER_SLOT_MAX, sizeof(struct dp_tx_desc_event), true, DP_TX_COMP_HIST_TYPE); } /** * dp_soc_tx_history_detach() - Detach the ring history record buffers * @soc: DP soc structure * * This function frees the memory for recording the tx tcl ring and * the tx comp ring entries. * * Return: None */ static void dp_soc_tx_history_detach(struct dp_soc *soc) { dp_soc_frag_history_detach(soc, &soc->tx_tcl_history, DP_TX_TCL_HIST_MAX_SLOTS, true, DP_TX_TCL_HIST_TYPE); dp_soc_frag_history_detach(soc, &soc->tx_comp_history, DP_TX_COMP_HIST_MAX_SLOTS, true, DP_TX_COMP_HIST_TYPE); } #else static inline void dp_soc_tx_history_attach(struct dp_soc *soc) { } static inline void dp_soc_tx_history_detach(struct dp_soc *soc) { } #endif /* WLAN_FEATURE_DP_TX_DESC_HISTORY */ #ifdef DP_RX_MSDU_DONE_FAIL_HISTORY static void dp_soc_msdu_done_fail_history_attach(struct dp_soc *soc) { soc->msdu_done_fail_hist = qdf_mem_malloc(sizeof(struct dp_msdu_done_fail_history)); if (soc->msdu_done_fail_hist) qdf_atomic_init(&soc->msdu_done_fail_hist->index); } static void dp_soc_msdu_done_fail_history_detach(struct dp_soc *soc) { if (soc->msdu_done_fail_hist) qdf_mem_free(soc->msdu_done_fail_hist); } #else static inline void dp_soc_msdu_done_fail_history_attach(struct dp_soc *soc) { } static inline void dp_soc_msdu_done_fail_history_detach(struct dp_soc *soc) { } #endif #ifdef DP_RX_PEEK_MSDU_DONE_WAR static void dp_soc_msdu_done_fail_desc_list_attach(struct dp_soc *soc) { qdf_atomic_init(&soc->msdu_done_fail_desc_list.index); qdf_atomic_set(&soc->msdu_done_fail_desc_list.index, DP_MSDU_DONE_FAIL_DESCS_MAX - 1); } #else static void dp_soc_msdu_done_fail_desc_list_attach(struct dp_soc *soc) { } #endif #ifdef WLAN_SUPPORT_RX_FLOW_TAG QDF_STATUS dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) { struct dp_rx_fst *rx_fst = NULL; QDF_STATUS ret = QDF_STATUS_SUCCESS; /* for Lithium the below API is not registered * hence fst attach happens for each pdev */ if (!soc->arch_ops.dp_get_rx_fst) return dp_rx_fst_attach(soc, pdev); rx_fst = soc->arch_ops.dp_get_rx_fst(); /* for BE the FST attach is called only once per * ML context. if rx_fst is already registered * increase the ref count and return. */ if (rx_fst) { soc->rx_fst = rx_fst; pdev->rx_fst = rx_fst; soc->arch_ops.dp_rx_fst_ref(); } else { ret = dp_rx_fst_attach(soc, pdev); if ((ret != QDF_STATUS_SUCCESS) && (ret != QDF_STATUS_E_NOSUPPORT)) return ret; soc->arch_ops.dp_set_rx_fst(soc->rx_fst); soc->arch_ops.dp_rx_fst_ref(); } return ret; } void dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) { struct dp_rx_fst *rx_fst = NULL; /* for Lithium the below API is not registered * hence fst detach happens for each pdev */ if (!soc->arch_ops.dp_get_rx_fst) { dp_rx_fst_detach(soc, pdev); return; } rx_fst = soc->arch_ops.dp_get_rx_fst(); /* for BE the FST detach is called only when last * ref count reaches 1. */ if (rx_fst) { if (soc->arch_ops.dp_rx_fst_deref() == 1) dp_rx_fst_detach(soc, pdev); } pdev->rx_fst = NULL; } #else QDF_STATUS dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } void dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev) { } #endif /** * dp_pdev_attach_wifi3() - attach txrx pdev * @txrx_soc: Datapath SOC handle * @params: Params for PDEV attach * * Return: QDF_STATUS */ static inline QDF_STATUS dp_pdev_attach_wifi3(struct cdp_soc_t *txrx_soc, struct cdp_pdev_attach_params *params) { qdf_size_t pdev_context_size; struct dp_soc *soc = (struct dp_soc *)txrx_soc; struct dp_pdev *pdev = NULL; uint8_t pdev_id = params->pdev_id; struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; int nss_cfg; QDF_STATUS ret; pdev_context_size = soc->arch_ops.txrx_get_context_size(DP_CONTEXT_TYPE_PDEV); if (pdev_context_size) pdev = dp_context_alloc_mem(soc, DP_PDEV_TYPE, pdev_context_size); if (!pdev) { dp_init_err("%pK: DP PDEV memory allocation failed", soc); goto fail0; } wlan_minidump_log(pdev, sizeof(*pdev), soc->ctrl_psoc, WLAN_MD_DP_PDEV, "dp_pdev"); soc_cfg_ctx = soc->wlan_cfg_ctx; pdev->wlan_cfg_ctx = wlan_cfg_pdev_attach(soc->ctrl_psoc); if (!pdev->wlan_cfg_ctx) { dp_init_err("%pK: pdev cfg_attach failed", soc); goto fail1; } pdev->soc = soc; pdev->pdev_id = pdev_id; soc->pdev_list[pdev_id] = pdev; pdev->lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, pdev_id); soc->pdev_count++; dp_ssr_dump_pdev_register(pdev, pdev_id); /*sync DP pdev cfg items with profile support after cfg_pdev_attach*/ wlan_dp_pdev_cfg_sync_profile((struct cdp_soc_t *)soc, pdev_id); /* * set nss pdev config based on soc config */ nss_cfg = wlan_cfg_get_dp_soc_nss_cfg(soc_cfg_ctx); wlan_cfg_set_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx, (nss_cfg & (1 << pdev_id))); /* Allocate memory for pdev srng rings */ if (dp_pdev_srng_alloc(pdev)) { dp_init_err("%pK: dp_pdev_srng_alloc failed", soc); goto fail2; } /* Setup second Rx refill buffer ring */ if (dp_setup_ipa_rx_refill_buf_ring(soc, pdev)) { dp_init_err("%pK: dp_srng_alloc failed rxrefill2 ring", soc); goto fail3; } /* Allocate memory for pdev rxdma rings */ if (dp_rxdma_ring_alloc(soc, pdev)) { dp_init_err("%pK: dp_rxdma_ring_alloc failed", soc); goto fail4; } /* Rx specific init */ if (dp_rx_pdev_desc_pool_alloc(pdev)) { dp_init_err("%pK: dp_rx_pdev_attach failed", soc); goto fail4; } if (dp_monitor_pdev_attach(pdev)) { dp_init_err("%pK: dp_monitor_pdev_attach failed", soc); goto fail5; } soc->arch_ops.txrx_pdev_attach(pdev, params); /* Setup third Rx refill buffer ring */ if (dp_setup_ipa_rx_alt_refill_buf_ring(soc, pdev)) { dp_init_err("%pK: dp_srng_alloc failed rxrefill3 ring", soc); goto fail6; } ret = dp_rx_fst_attach_wrapper(soc, pdev); if ((ret != QDF_STATUS_SUCCESS) && (ret != QDF_STATUS_E_NOSUPPORT)) { dp_init_err("%pK: RX FST attach failed: pdev %d err %d", soc, pdev_id, ret); goto fail7; } return QDF_STATUS_SUCCESS; fail7: dp_free_ipa_rx_alt_refill_buf_ring(soc, pdev); fail6: dp_monitor_pdev_detach(pdev); fail5: dp_rx_pdev_desc_pool_free(pdev); fail4: dp_rxdma_ring_free(pdev); dp_free_ipa_rx_refill_buf_ring(soc, pdev); fail3: dp_pdev_srng_free(pdev); fail2: wlan_cfg_pdev_detach(pdev->wlan_cfg_ctx); fail1: soc->pdev_list[pdev_id] = NULL; qdf_mem_free(pdev); fail0: return QDF_STATUS_E_FAILURE; } /** * dp_pdev_flush_pending_vdevs() - Flush all delete pending vdevs in pdev * @pdev: Datapath PDEV handle * * This is the last chance to flush all pending dp vdevs/peers, * some peer/vdev leak case like Non-SSR + peer unmap missing * will be covered here. * * Return: None */ static void dp_pdev_flush_pending_vdevs(struct dp_pdev *pdev) { struct dp_soc *soc = pdev->soc; struct dp_vdev *vdev_arr[MAX_VDEV_CNT] = {0}; uint32_t i = 0; uint32_t num_vdevs = 0; struct dp_vdev *vdev = NULL; if (TAILQ_EMPTY(&soc->inactive_vdev_list)) return; qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); TAILQ_FOREACH(vdev, &soc->inactive_vdev_list, inactive_list_elem) { if (vdev->pdev != pdev) continue; vdev_arr[num_vdevs] = vdev; num_vdevs++; /* take reference to free */ dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CDP); } qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); for (i = 0; i < num_vdevs; i++) { dp_vdev_flush_peers((struct cdp_vdev *)vdev_arr[i], 0, 0); dp_vdev_unref_delete(soc, vdev_arr[i], DP_MOD_ID_CDP); } } #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT /** * dp_vdev_stats_hw_offload_target_config() - Send HTT command to FW * for enable/disable of HW vdev stats * @soc: Datapath soc handle * @pdev_id: INVALID_PDEV_ID for all pdevs or 0,1,2 for individual pdev * @enable: flag to represent enable/disable of hw vdev stats * * Return: none */ static void dp_vdev_stats_hw_offload_target_config(struct dp_soc *soc, uint8_t pdev_id, bool enable) { /* Check SOC level config for HW offload vdev stats support */ if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { dp_debug("%pK: HW vdev offload stats is disabled", soc); return; } /* Send HTT command to FW for enable of stats */ dp_h2t_hw_vdev_stats_config_send(soc, pdev_id, enable, false, 0); } /** * dp_vdev_stats_hw_offload_target_clear() - Clear HW vdev stats on target * @soc: Datapath soc handle * @pdev_id: pdev_id (0,1,2) * @vdev_id_bitmask: bitmask with vdev_id(s) for which stats are to be * cleared on HW * * Return: none */ static void dp_vdev_stats_hw_offload_target_clear(struct dp_soc *soc, uint8_t pdev_id, uint64_t vdev_id_bitmask) { /* Check SOC level config for HW offload vdev stats support */ if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { dp_debug("%pK: HW vdev offload stats is disabled", soc); return; } /* Send HTT command to FW for reset of stats */ dp_h2t_hw_vdev_stats_config_send(soc, pdev_id, true, true, vdev_id_bitmask); } #else static void dp_vdev_stats_hw_offload_target_config(struct dp_soc *soc, uint8_t pdev_id, bool enable) { } static void dp_vdev_stats_hw_offload_target_clear(struct dp_soc *soc, uint8_t pdev_id, uint64_t vdev_id_bitmask) { } #endif /*QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT */ /** * dp_pdev_deinit() - Deinit txrx pdev * @txrx_pdev: Datapath PDEV handle * @force: Force deinit * * Return: None */ static void dp_pdev_deinit(struct cdp_pdev *txrx_pdev, int force) { struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; qdf_nbuf_t curr_nbuf, next_nbuf; if (pdev->pdev_deinit) return; dp_tx_me_exit(pdev); dp_rx_pdev_buffers_free(pdev); dp_rx_pdev_desc_pool_deinit(pdev); dp_pdev_bkp_stats_detach(pdev); qdf_event_destroy(&pdev->fw_peer_stats_event); qdf_event_destroy(&pdev->fw_stats_event); qdf_event_destroy(&pdev->fw_obss_stats_event); if (pdev->sojourn_buf) qdf_nbuf_free(pdev->sojourn_buf); dp_pdev_flush_pending_vdevs(pdev); dp_tx_desc_flush(pdev, NULL, true); qdf_spinlock_destroy(&pdev->tx_mutex); qdf_spinlock_destroy(&pdev->vdev_list_lock); dp_monitor_pdev_deinit(pdev); dp_pdev_srng_deinit(pdev); dp_ipa_uc_detach(pdev->soc, pdev); dp_deinit_ipa_rx_alt_refill_buf_ring(pdev->soc, pdev); dp_deinit_ipa_rx_refill_buf_ring(pdev->soc, pdev); dp_rxdma_ring_cleanup(pdev->soc, pdev); curr_nbuf = pdev->invalid_peer_head_msdu; while (curr_nbuf) { next_nbuf = qdf_nbuf_next(curr_nbuf); dp_rx_nbuf_free(curr_nbuf); curr_nbuf = next_nbuf; } pdev->invalid_peer_head_msdu = NULL; pdev->invalid_peer_tail_msdu = NULL; dp_wdi_event_detach(pdev); pdev->pdev_deinit = 1; } /** * dp_pdev_deinit_wifi3() - Deinit txrx pdev * @psoc: Datapath psoc handle * @pdev_id: Id of datapath PDEV handle * @force: Force deinit * * Return: QDF_STATUS */ static QDF_STATUS dp_pdev_deinit_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, int force) { struct dp_pdev *txrx_pdev; txrx_pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)psoc, pdev_id); if (!txrx_pdev) return QDF_STATUS_E_FAILURE; dp_pdev_deinit((struct cdp_pdev *)txrx_pdev, force); return QDF_STATUS_SUCCESS; } /** * dp_pdev_post_attach() - Do post pdev attach after dev_alloc_name * @txrx_pdev: Datapath PDEV handle * * Return: None */ static void dp_pdev_post_attach(struct cdp_pdev *txrx_pdev) { struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; dp_monitor_tx_capture_debugfs_init(pdev); if (dp_pdev_htt_stats_dbgfs_init(pdev)) { dp_init_err("%pK: Failed to initialize pdev HTT stats debugfs", pdev->soc); } } /** * dp_pdev_post_attach_wifi3() - attach txrx pdev post * @soc: Datapath soc handle * @pdev_id: pdev id of pdev * * Return: QDF_STATUS */ static int dp_pdev_post_attach_wifi3(struct cdp_soc_t *soc, uint8_t pdev_id) { struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) { dp_init_err("%pK: DP PDEV is Null for pdev id %d", (struct dp_soc *)soc, pdev_id); return QDF_STATUS_E_FAILURE; } dp_pdev_post_attach((struct cdp_pdev *)pdev); return QDF_STATUS_SUCCESS; } /** * dp_pdev_detach() - Complete rest of pdev detach * @txrx_pdev: Datapath PDEV handle * @force: Force deinit * * Return: None */ static void dp_pdev_detach(struct cdp_pdev *txrx_pdev, int force) { struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev; struct dp_soc *soc = pdev->soc; dp_rx_fst_detach_wrapper(soc, pdev); dp_pdev_htt_stats_dbgfs_deinit(pdev); dp_rx_pdev_desc_pool_free(pdev); dp_monitor_pdev_detach(pdev); dp_rxdma_ring_free(pdev); dp_free_ipa_rx_refill_buf_ring(soc, pdev); dp_free_ipa_rx_alt_refill_buf_ring(soc, pdev); dp_pdev_srng_free(pdev); soc->pdev_count--; soc->pdev_list[pdev->pdev_id] = NULL; wlan_cfg_pdev_detach(pdev->wlan_cfg_ctx); wlan_minidump_remove(pdev, sizeof(*pdev), soc->ctrl_psoc, WLAN_MD_DP_PDEV, "dp_pdev"); dp_context_free_mem(soc, DP_PDEV_TYPE, pdev); } /** * dp_pdev_detach_wifi3() - detach txrx pdev * @psoc: Datapath soc handle * @pdev_id: pdev id of pdev * @force: Force detach * * Return: QDF_STATUS */ static QDF_STATUS dp_pdev_detach_wifi3(struct cdp_soc_t *psoc, uint8_t pdev_id, int force) { struct dp_pdev *pdev; struct dp_soc *soc = (struct dp_soc *)psoc; pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)psoc, pdev_id); if (!pdev) { dp_init_err("%pK: DP PDEV is Null for pdev id %d", (struct dp_soc *)psoc, pdev_id); return QDF_STATUS_E_FAILURE; } dp_ssr_dump_pdev_unregister(pdev_id); soc->arch_ops.txrx_pdev_detach(pdev); dp_pdev_detach((struct cdp_pdev *)pdev, force); return QDF_STATUS_SUCCESS; } void dp_soc_print_inactive_objects(struct dp_soc *soc) { struct dp_peer *peer = NULL; struct dp_peer *tmp_peer = NULL; struct dp_vdev *vdev = NULL; struct dp_vdev *tmp_vdev = NULL; int i = 0; uint32_t count; if (TAILQ_EMPTY(&soc->inactive_peer_list) && TAILQ_EMPTY(&soc->inactive_vdev_list)) return; TAILQ_FOREACH_SAFE(peer, &soc->inactive_peer_list, inactive_list_elem, tmp_peer) { for (i = 0; i < DP_MOD_ID_MAX; i++) { count = qdf_atomic_read(&peer->mod_refs[i]); if (count) DP_PRINT_STATS("peer %pK Module id %u ==> %u", peer, i, count); } } TAILQ_FOREACH_SAFE(vdev, &soc->inactive_vdev_list, inactive_list_elem, tmp_vdev) { for (i = 0; i < DP_MOD_ID_MAX; i++) { count = qdf_atomic_read(&vdev->mod_refs[i]); if (count) DP_PRINT_STATS("vdev %pK Module id %u ==> %u", vdev, i, count); } } QDF_BUG(0); } /** * dp_soc_deinit_wifi3() - Deinitialize txrx SOC * @txrx_soc: Opaque DP SOC handle * * Return: None */ static void dp_soc_deinit_wifi3(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; soc->arch_ops.txrx_soc_deinit(soc); } /** * dp_soc_detach() - Detach rest of txrx SOC * @txrx_soc: DP SOC handle, struct cdp_soc_t is first element of struct dp_soc. * * Return: None */ static void dp_soc_detach(struct cdp_soc_t *txrx_soc) { struct dp_soc *soc = (struct dp_soc *)txrx_soc; soc->arch_ops.txrx_soc_detach(soc); qdf_ssr_driver_dump_unregister_region("wlan_cfg_ctx"); qdf_ssr_driver_dump_unregister_region("dp_soc"); qdf_ssr_driver_dump_unregister_region("tcl_wbm_map_array"); qdf_nbuf_ssr_unregister_region(); dp_runtime_deinit(); dp_soc_unset_qref_debug_list(soc); dp_sysfs_deinitialize_stats(soc); dp_soc_swlm_detach(soc); dp_soc_tx_desc_sw_pools_free(soc); dp_soc_srng_free(soc); dp_hw_link_desc_ring_free(soc); dp_hw_link_desc_pool_banks_free(soc, WLAN_INVALID_PDEV_ID); wlan_cfg_soc_detach(soc->wlan_cfg_ctx); dp_soc_tx_hw_desc_history_detach(soc); dp_soc_tx_history_detach(soc); dp_soc_mon_status_ring_history_detach(soc); dp_soc_rx_history_detach(soc); dp_soc_cfg_history_detach(soc); dp_soc_msdu_done_fail_history_detach(soc); if (!dp_monitor_modularized_enable()) { dp_mon_soc_detach_wrapper(soc); } qdf_mem_free(soc->cdp_soc.ops); qdf_mem_common_free(soc); } /** * dp_soc_detach_wifi3() - Detach txrx SOC * @txrx_soc: DP SOC handle, struct cdp_soc_t is first element of struct dp_soc. * * Return: None */ static void dp_soc_detach_wifi3(struct cdp_soc_t *txrx_soc) { dp_soc_detach(txrx_soc); } #ifdef QCA_HOST2FW_RXBUF_RING #ifdef IPA_WDI3_VLAN_SUPPORT static inline void dp_rxdma_setup_refill_ring3(struct dp_soc *soc, struct dp_pdev *pdev, uint8_t idx) { if (pdev->rx_refill_buf_ring3.hal_srng) htt_srng_setup(soc->htt_handle, idx, pdev->rx_refill_buf_ring3.hal_srng, RXDMA_BUF); } #else static inline void dp_rxdma_setup_refill_ring3(struct dp_soc *soc, struct dp_pdev *pdev, uint8_t idx) { } #endif #ifdef WIFI_MONITOR_SUPPORT static inline QDF_STATUS dp_lpc_tx_config(struct dp_pdev *pdev) { return dp_local_pkt_capture_tx_config(pdev); } #else static inline QDF_STATUS dp_lpc_tx_config(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } #endif /** * dp_rxdma_ring_config() - configure the RX DMA rings * @soc: data path SoC handle * * This function is used to configure the MAC rings. * On MCL host provides buffers in Host2FW ring * FW refills (copies) buffers to the ring and updates * ring_idx in register * * Return: zero on success, non-zero on failure */ static QDF_STATUS dp_rxdma_ring_config(struct dp_soc *soc) { int i; QDF_STATUS status = QDF_STATUS_SUCCESS; for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_pdev *pdev = soc->pdev_list[i]; if (pdev) { int mac_id; int max_mac_rings = wlan_cfg_get_num_mac_rings (pdev->wlan_cfg_ctx); int lmac_id = dp_get_lmac_id_for_pdev_id(soc, 0, i); htt_srng_setup(soc->htt_handle, i, soc->rx_refill_buf_ring[lmac_id] .hal_srng, RXDMA_BUF); if (pdev->rx_refill_buf_ring2.hal_srng) htt_srng_setup(soc->htt_handle, i, pdev->rx_refill_buf_ring2 .hal_srng, RXDMA_BUF); dp_rxdma_setup_refill_ring3(soc, pdev, i); dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings); dp_lpc_tx_config(pdev); dp_info("pdev_id %d max_mac_rings %d", pdev->pdev_id, max_mac_rings); for (mac_id = 0; mac_id < max_mac_rings; mac_id++) { int mac_for_pdev = dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); /* * Obtain lmac id from pdev to access the LMAC * ring in soc context */ lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id, pdev->pdev_id); dp_info("mac_id %d", mac_for_pdev); htt_srng_setup(soc->htt_handle, mac_for_pdev, pdev->rx_mac_buf_ring[mac_id] .hal_srng, RXDMA_BUF); if (!soc->rxdma2sw_rings_not_supported) dp_htt_setup_rxdma_err_dst_ring(soc, mac_for_pdev, lmac_id); /* Configure monitor mode rings */ status = dp_monitor_htt_srng_setup(soc, pdev, lmac_id, mac_for_pdev); if (status != QDF_STATUS_SUCCESS) { dp_err("Failed to send htt monitor messages to target"); return status; } } } } dp_reap_timer_init(soc); return status; } #else /* This is only for WIN */ static QDF_STATUS dp_rxdma_ring_config(struct dp_soc *soc) { int i; QDF_STATUS status = QDF_STATUS_SUCCESS; int mac_for_pdev; int lmac_id; /* Configure monitor mode rings */ dp_monitor_soc_htt_srng_setup(soc); for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_pdev *pdev = soc->pdev_list[i]; if (!pdev) continue; mac_for_pdev = i; lmac_id = dp_get_lmac_id_for_pdev_id(soc, 0, i); if (soc->rx_refill_buf_ring[lmac_id].hal_srng) htt_srng_setup(soc->htt_handle, mac_for_pdev, soc->rx_refill_buf_ring[lmac_id]. hal_srng, RXDMA_BUF); /* Configure monitor mode rings */ dp_monitor_htt_srng_setup(soc, pdev, lmac_id, mac_for_pdev); if (!soc->rxdma2sw_rings_not_supported) htt_srng_setup(soc->htt_handle, mac_for_pdev, soc->rxdma_err_dst_ring[lmac_id].hal_srng, RXDMA_DST); } dp_reap_timer_init(soc); return status; } #endif /** * dp_rx_target_fst_config() - configure the RXOLE Flow Search Engine * * This function is used to configure the FSE HW block in RX OLE on a * per pdev basis. Here, we will be programming parameters related to * the Flow Search Table. * * @soc: data path SoC handle * * Return: zero on success, non-zero on failure */ #ifdef WLAN_SUPPORT_RX_FLOW_TAG static QDF_STATUS dp_rx_target_fst_config(struct dp_soc *soc) { int i; QDF_STATUS status = QDF_STATUS_SUCCESS; for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_pdev *pdev = soc->pdev_list[i]; /* Flow search is not enabled if NSS offload is enabled */ if (pdev && !wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) { status = dp_rx_flow_send_fst_fw_setup(pdev->soc, pdev); if (status != QDF_STATUS_SUCCESS) break; } } return status; } #else static inline QDF_STATUS dp_rx_target_fst_config(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif #ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR static inline QDF_STATUS dp_print_swlm_stats(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */ #ifdef WLAN_SUPPORT_PPEDS /** * dp_soc_target_ppe_rxole_rxdma_cfg() - Configure the RxOLe and RxDMA for PPE * @soc: DP Tx/Rx handle * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_target_ppe_rxole_rxdma_cfg(struct dp_soc *soc) { struct dp_htt_rxdma_rxole_ppe_config htt_cfg = {0}; QDF_STATUS status; /* * Program RxDMA to override the reo destination indication * with REO2PPE_DST_IND, when use_ppe is set to 1 in RX_MSDU_END, * thereby driving the packet to REO2PPE ring. * If the MSDU is spanning more than 1 buffer, then this * override is not done. */ htt_cfg.override = 1; htt_cfg.reo_destination_indication = REO2PPE_DST_IND; htt_cfg.multi_buffer_msdu_override_en = 0; /* * Override use_ppe to 0 in RxOLE for the following * cases. */ htt_cfg.intra_bss_override = 1; htt_cfg.decap_raw_override = 1; htt_cfg.decap_nwifi_override = 1; htt_cfg.ip_frag_override = 1; status = dp_htt_rxdma_rxole_ppe_cfg_set(soc, &htt_cfg); if (status != QDF_STATUS_SUCCESS) dp_err("RxOLE and RxDMA PPE config failed %d", status); return status; } #else static inline QDF_STATUS dp_soc_target_ppe_rxole_rxdma_cfg(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif /* WLAN_SUPPORT_PPEDS */ #ifdef DP_UMAC_HW_RESET_SUPPORT static void dp_register_umac_reset_handlers(struct dp_soc *soc) { dp_umac_reset_register_rx_action_callback(soc, dp_umac_reset_action_trigger_recovery, UMAC_RESET_ACTION_DO_TRIGGER_RECOVERY); dp_umac_reset_register_rx_action_callback(soc, dp_umac_reset_handle_pre_reset, UMAC_RESET_ACTION_DO_PRE_RESET); dp_umac_reset_register_rx_action_callback(soc, dp_umac_reset_handle_post_reset, UMAC_RESET_ACTION_DO_POST_RESET_START); dp_umac_reset_register_rx_action_callback(soc, dp_umac_reset_handle_post_reset_complete, UMAC_RESET_ACTION_DO_POST_RESET_COMPLETE); } #else static void dp_register_umac_reset_handlers(struct dp_soc *soc) { } #endif /** * dp_soc_attach_target_wifi3() - SOC initialization in the target * @cdp_soc: Opaque Datapath SOC handle * * Return: zero on success, non-zero on failure */ static QDF_STATUS dp_soc_attach_target_wifi3(struct cdp_soc_t *cdp_soc) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; QDF_STATUS status = QDF_STATUS_SUCCESS; struct hal_reo_params reo_params; htt_soc_attach_target(soc->htt_handle); status = dp_soc_target_ppe_rxole_rxdma_cfg(soc); if (status != QDF_STATUS_SUCCESS) { dp_err("Failed to send htt RxOLE and RxDMA messages to target"); return status; } status = dp_rxdma_ring_config(soc); if (status != QDF_STATUS_SUCCESS) { dp_err("Failed to send htt srng setup messages to target"); return status; } status = soc->arch_ops.dp_rxdma_ring_sel_cfg(soc); if (status != QDF_STATUS_SUCCESS) { dp_err("Failed to send htt ring config message to target"); return status; } status = dp_soc_umac_reset_init(cdp_soc); if (status != QDF_STATUS_SUCCESS && status != QDF_STATUS_E_NOSUPPORT) { dp_err("Failed to initialize UMAC reset"); return status; } dp_register_umac_reset_handlers(soc); status = dp_rx_target_fst_config(soc); if (status != QDF_STATUS_SUCCESS && status != QDF_STATUS_E_NOSUPPORT) { dp_err("Failed to send htt fst setup config message to target"); return status; } DP_STATS_INIT(soc); dp_runtime_init(soc); /* Enable HW vdev offload stats if feature is supported */ dp_vdev_stats_hw_offload_target_config(soc, INVALID_PDEV_ID, true); /* initialize work queue for stats processing */ qdf_create_work(0, &soc->htt_stats.work, htt_t2h_stats_handler, soc); wlan_cfg_soc_update_tgt_params(soc->wlan_cfg_ctx, soc->ctrl_psoc); /* Setup HW REO */ qdf_mem_zero(&reo_params, sizeof(reo_params)); if (wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { /* * Reo ring remap is not required if both radios * are offloaded to NSS */ if (soc->arch_ops.reo_remap_config(soc, &reo_params.remap0, &reo_params.remap1, &reo_params.remap2)) reo_params.rx_hash_enabled = true; else reo_params.rx_hash_enabled = false; } /* * set the fragment destination ring */ dp_reo_frag_dst_set(soc, &reo_params.frag_dst_ring); if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) reo_params.alt_dst_ind_0 = REO_REMAP_RELEASE; reo_params.reo_qref = &soc->reo_qref; hal_reo_setup(soc->hal_soc, &reo_params, 1); hal_reo_set_err_dst_remap(soc->hal_soc); soc->features.pn_in_reo_dest = hal_reo_enable_pn_in_dest(soc->hal_soc); return QDF_STATUS_SUCCESS; } /** * dp_vdev_id_map_tbl_add() - Add vdev into vdev_id table * @soc: SoC handle * @vdev: vdev handle * @vdev_id: vdev_id * * Return: None */ static void dp_vdev_id_map_tbl_add(struct dp_soc *soc, struct dp_vdev *vdev, uint8_t vdev_id) { QDF_ASSERT(vdev_id <= MAX_VDEV_CNT); qdf_spin_lock_bh(&soc->vdev_map_lock); if (dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CONFIG) != QDF_STATUS_SUCCESS) { dp_vdev_info("%pK: unable to get vdev reference at MAP vdev %pK vdev_id %u", soc, vdev, vdev_id); qdf_spin_unlock_bh(&soc->vdev_map_lock); return; } if (!soc->vdev_id_map[vdev_id]) soc->vdev_id_map[vdev_id] = vdev; else QDF_ASSERT(0); qdf_spin_unlock_bh(&soc->vdev_map_lock); } /** * dp_vdev_id_map_tbl_remove() - remove vdev from vdev_id table * @soc: SoC handle * @vdev: vdev handle * * Return: None */ static void dp_vdev_id_map_tbl_remove(struct dp_soc *soc, struct dp_vdev *vdev) { qdf_spin_lock_bh(&soc->vdev_map_lock); QDF_ASSERT(soc->vdev_id_map[vdev->vdev_id] == vdev); soc->vdev_id_map[vdev->vdev_id] = NULL; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); qdf_spin_unlock_bh(&soc->vdev_map_lock); } /** * dp_vdev_pdev_list_add() - add vdev into pdev's list * @soc: soc handle * @pdev: pdev handle * @vdev: vdev handle * * Return: none */ static void dp_vdev_pdev_list_add(struct dp_soc *soc, struct dp_pdev *pdev, struct dp_vdev *vdev) { qdf_spin_lock_bh(&pdev->vdev_list_lock); if (dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CONFIG) != QDF_STATUS_SUCCESS) { dp_vdev_info("%pK: unable to get vdev reference at MAP vdev %pK", soc, vdev); qdf_spin_unlock_bh(&pdev->vdev_list_lock); return; } /* add this vdev into the pdev's list */ TAILQ_INSERT_TAIL(&pdev->vdev_list, vdev, vdev_list_elem); qdf_spin_unlock_bh(&pdev->vdev_list_lock); } /** * dp_vdev_pdev_list_remove() - remove vdev from pdev's list * @soc: SoC handle * @pdev: pdev handle * @vdev: VDEV handle * * Return: none */ static void dp_vdev_pdev_list_remove(struct dp_soc *soc, struct dp_pdev *pdev, struct dp_vdev *vdev) { uint8_t found = 0; struct dp_vdev *tmpvdev = NULL; qdf_spin_lock_bh(&pdev->vdev_list_lock); TAILQ_FOREACH(tmpvdev, &pdev->vdev_list, vdev_list_elem) { if (tmpvdev == vdev) { found = 1; break; } } if (found) { TAILQ_REMOVE(&pdev->vdev_list, vdev, vdev_list_elem); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); } else { dp_vdev_debug("%pK: vdev:%pK not found in pdev:%pK vdevlist:%pK", soc, vdev, pdev, &pdev->vdev_list); QDF_ASSERT(0); } qdf_spin_unlock_bh(&pdev->vdev_list_lock); } #ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT /** * dp_vdev_init_rx_eapol() - initializing osif_rx_eapol * @vdev: Datapath VDEV handle * * Return: None */ static inline void dp_vdev_init_rx_eapol(struct dp_vdev *vdev) { vdev->osif_rx_eapol = NULL; } /** * dp_vdev_register_rx_eapol() - Register VDEV operations for rx_eapol * @vdev: DP vdev handle * @txrx_ops: Tx and Rx operations * * Return: None */ static inline void dp_vdev_register_rx_eapol(struct dp_vdev *vdev, struct ol_txrx_ops *txrx_ops) { vdev->osif_rx_eapol = txrx_ops->rx.rx_eapol; } #else static inline void dp_vdev_init_rx_eapol(struct dp_vdev *vdev) { } static inline void dp_vdev_register_rx_eapol(struct dp_vdev *vdev, struct ol_txrx_ops *txrx_ops) { } #endif #ifdef WLAN_FEATURE_11BE_MLO static inline void dp_vdev_save_mld_addr(struct dp_vdev *vdev, struct cdp_vdev_info *vdev_info) { if (vdev_info->mld_mac_addr) qdf_mem_copy(&vdev->mld_mac_addr.raw[0], vdev_info->mld_mac_addr, QDF_MAC_ADDR_SIZE); } #ifdef WLAN_MLO_MULTI_CHIP static inline void dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, struct cdp_vdev_info *vdev_info) { if (vdev_info->is_bridge_vap) vdev->is_bridge_vdev = 1; dp_info("is_bridge_link = %d vdev id = %d chip id = %d", vdev->is_bridge_vdev, vdev->vdev_id, dp_get_chip_id(vdev->pdev->soc)); } #else static inline void dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, struct cdp_vdev_info *vdev_info) { } #endif /* WLAN_MLO_MULTI_CHIP */ #else static inline void dp_vdev_save_mld_addr(struct dp_vdev *vdev, struct cdp_vdev_info *vdev_info) { } static inline void dp_vdev_update_bridge_vdev_param(struct dp_vdev *vdev, struct cdp_vdev_info *vdev_info) { } #endif #ifdef DP_TRAFFIC_END_INDICATION /** * dp_tx_vdev_traffic_end_indication_attach() - Initialize data end indication * related members in VDEV * @vdev: DP vdev handle * * Return: None */ static inline void dp_tx_vdev_traffic_end_indication_attach(struct dp_vdev *vdev) { qdf_nbuf_queue_init(&vdev->end_ind_pkt_q); } /** * dp_tx_vdev_traffic_end_indication_detach() - De-init data end indication * related members in VDEV * @vdev: DP vdev handle * * Return: None */ static inline void dp_tx_vdev_traffic_end_indication_detach(struct dp_vdev *vdev) { qdf_nbuf_t nbuf; while ((nbuf = qdf_nbuf_queue_remove(&vdev->end_ind_pkt_q)) != NULL) qdf_nbuf_free(nbuf); } #else static inline void dp_tx_vdev_traffic_end_indication_attach(struct dp_vdev *vdev) {} static inline void dp_tx_vdev_traffic_end_indication_detach(struct dp_vdev *vdev) {} #endif #ifdef WLAN_DP_VDEV_NO_SELF_PEER static inline bool dp_vdev_self_peer_required(struct dp_soc *soc, struct dp_vdev *vdev) { return false; } #else static inline bool dp_vdev_self_peer_required(struct dp_soc *soc, struct dp_vdev *vdev) { if (wlan_op_mode_sta == vdev->opmode) return true; return false; } #endif /** * dp_vdev_attach_wifi3() - attach txrx vdev * @cdp_soc: CDP SoC context * @pdev_id: PDEV ID for vdev creation * @vdev_info: parameters used for vdev creation * * Return: status */ static QDF_STATUS dp_vdev_attach_wifi3(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, struct cdp_vdev_info *vdev_info) { int i = 0; qdf_size_t vdev_context_size; struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); struct dp_vdev *vdev; uint8_t *vdev_mac_addr = vdev_info->vdev_mac_addr; uint8_t vdev_id = vdev_info->vdev_id; enum wlan_op_mode op_mode = vdev_info->op_mode; enum wlan_op_subtype subtype = vdev_info->subtype; enum QDF_OPMODE qdf_opmode = vdev_info->qdf_opmode; uint8_t vdev_stats_id = vdev_info->vdev_stats_id; vdev_context_size = soc->arch_ops.txrx_get_context_size(DP_CONTEXT_TYPE_VDEV); vdev = qdf_mem_malloc(vdev_context_size); if (!pdev) { dp_init_err("%pK: DP PDEV is Null for pdev id %d", cdp_soc, pdev_id); qdf_mem_free(vdev); goto fail0; } if (!vdev) { dp_init_err("%pK: DP VDEV memory allocation failed", cdp_soc); goto fail0; } wlan_minidump_log(vdev, sizeof(*vdev), soc->ctrl_psoc, WLAN_MD_DP_VDEV, "dp_vdev"); vdev->pdev = pdev; vdev->vdev_id = vdev_id; vdev->vdev_stats_id = vdev_stats_id; vdev->opmode = op_mode; vdev->subtype = subtype; vdev->qdf_opmode = qdf_opmode; vdev->osdev = soc->osdev; vdev->osif_rx = NULL; vdev->osif_rsim_rx_decap = NULL; vdev->osif_get_key = NULL; vdev->osif_tx_free_ext = NULL; vdev->osif_vdev = NULL; vdev->delete.pending = 0; vdev->safemode = 0; vdev->drop_unenc = 1; vdev->sec_type = cdp_sec_type_none; vdev->multipass_en = false; vdev->wrap_vdev = false; dp_vdev_init_rx_eapol(vdev); qdf_atomic_init(&vdev->ref_cnt); for (i = 0; i < DP_MOD_ID_MAX; i++) qdf_atomic_init(&vdev->mod_refs[i]); /* Take one reference for create*/ qdf_atomic_inc(&vdev->ref_cnt); qdf_atomic_inc(&vdev->mod_refs[DP_MOD_ID_CONFIG]); vdev->num_peers = 0; #ifdef notyet vdev->filters_num = 0; #endif vdev->lmac_id = pdev->lmac_id; qdf_mem_copy(&vdev->mac_addr.raw[0], vdev_mac_addr, QDF_MAC_ADDR_SIZE); dp_vdev_update_bridge_vdev_param(vdev, vdev_info); dp_vdev_save_mld_addr(vdev, vdev_info); /* TODO: Initialize default HTT meta data that will be used in * TCL descriptors for packets transmitted from this VDEV */ qdf_spinlock_create(&vdev->peer_list_lock); TAILQ_INIT(&vdev->peer_list); dp_peer_multipass_list_init(vdev); if ((soc->intr_mode == DP_INTR_POLL) && wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx) != 0) { if ((pdev->vdev_count == 0) || (wlan_op_mode_monitor == vdev->opmode)) qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); } else if (dp_soc_get_con_mode(soc) == QDF_GLOBAL_MISSION_MODE && soc->intr_mode == DP_INTR_MSI && wlan_op_mode_monitor == vdev->opmode && !dp_mon_mode_local_pkt_capture(soc)) { /* Timer to reap status ring in mission mode */ dp_monitor_vdev_timer_start(soc); } dp_vdev_id_map_tbl_add(soc, vdev, vdev_id); if (wlan_op_mode_monitor == vdev->opmode) { if (dp_monitor_vdev_attach(vdev) == QDF_STATUS_SUCCESS) { dp_monitor_pdev_set_mon_vdev(vdev); return dp_monitor_vdev_set_monitor_mode_buf_rings(pdev); } return QDF_STATUS_E_FAILURE; } vdev->tx_encap_type = wlan_cfg_pkt_type(soc->wlan_cfg_ctx); vdev->rx_decap_type = wlan_cfg_pkt_type(soc->wlan_cfg_ctx); vdev->dscp_tid_map_id = 0; vdev->mcast_enhancement_en = 0; vdev->igmp_mcast_enhanc_en = 0; vdev->raw_mode_war = wlan_cfg_get_raw_mode_war(soc->wlan_cfg_ctx); vdev->prev_tx_enq_tstamp = 0; vdev->prev_rx_deliver_tstamp = 0; vdev->skip_sw_tid_classification = DP_TX_HW_DSCP_TID_MAP_VALID; dp_tx_vdev_traffic_end_indication_attach(vdev); dp_vdev_pdev_list_add(soc, pdev, vdev); pdev->vdev_count++; if (wlan_op_mode_sta != vdev->opmode && wlan_op_mode_ndi != vdev->opmode) vdev->ap_bridge_enabled = true; else vdev->ap_bridge_enabled = false; dp_init_info("%pK: wlan_cfg_ap_bridge_enabled %d", cdp_soc, vdev->ap_bridge_enabled); dp_tx_vdev_attach(vdev); dp_monitor_vdev_attach(vdev); if (!pdev->is_lro_hash_configured) { if (QDF_IS_STATUS_SUCCESS(dp_lro_hash_setup(soc, pdev))) pdev->is_lro_hash_configured = true; else dp_err("LRO hash setup failure!"); } dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_ATTACH, vdev); dp_info("Created vdev %pK ("QDF_MAC_ADDR_FMT") vdev_id %d", vdev, QDF_MAC_ADDR_REF(vdev->mac_addr.raw), vdev->vdev_id); DP_STATS_INIT(vdev); if (QDF_IS_STATUS_ERROR(soc->arch_ops.txrx_vdev_attach(soc, vdev))) goto fail0; if (dp_vdev_self_peer_required(soc, vdev)) dp_peer_create_wifi3((struct cdp_soc_t *)soc, vdev_id, vdev->mac_addr.raw, CDP_LINK_PEER_TYPE); dp_pdev_update_fast_rx_flag(soc, pdev); return QDF_STATUS_SUCCESS; fail0: return QDF_STATUS_E_FAILURE; } #ifndef QCA_HOST_MODE_WIFI_DISABLED /** * dp_vdev_fetch_tx_handler() - Fetch Tx handlers * @vdev: struct dp_vdev * * @soc: struct dp_soc * * @ctx: struct ol_txrx_hardtart_ctxt * */ static inline void dp_vdev_fetch_tx_handler(struct dp_vdev *vdev, struct dp_soc *soc, struct ol_txrx_hardtart_ctxt *ctx) { /* Enable vdev_id check only for ap, if flag is enabled */ if (vdev->mesh_vdev) ctx->tx = dp_tx_send_mesh; else if ((wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx)) && (vdev->opmode == wlan_op_mode_ap)) { ctx->tx = dp_tx_send_vdev_id_check; ctx->tx_fast = dp_tx_send_vdev_id_check; } else { ctx->tx = dp_tx_send; ctx->tx_fast = soc->arch_ops.dp_tx_send_fast; } /* Avoid check in regular exception Path */ if ((wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx)) && (vdev->opmode == wlan_op_mode_ap)) ctx->tx_exception = dp_tx_send_exception_vdev_id_check; else ctx->tx_exception = dp_tx_send_exception; } /** * dp_vdev_register_tx_handler() - Register Tx handler * @vdev: struct dp_vdev * * @soc: struct dp_soc * * @txrx_ops: struct ol_txrx_ops * */ static inline void dp_vdev_register_tx_handler(struct dp_vdev *vdev, struct dp_soc *soc, struct ol_txrx_ops *txrx_ops) { struct ol_txrx_hardtart_ctxt ctx = {0}; dp_vdev_fetch_tx_handler(vdev, soc, &ctx); txrx_ops->tx.tx = ctx.tx; txrx_ops->tx.tx_fast = ctx.tx_fast; txrx_ops->tx.tx_exception = ctx.tx_exception; dp_info("Configure tx_vdev_id_chk_handler Feature Flag: %d and mode:%d for vdev_id:%d", wlan_cfg_is_tx_per_pkt_vdev_id_check_enabled(soc->wlan_cfg_ctx), vdev->opmode, vdev->vdev_id); } #else /* QCA_HOST_MODE_WIFI_DISABLED */ static inline void dp_vdev_register_tx_handler(struct dp_vdev *vdev, struct dp_soc *soc, struct ol_txrx_ops *txrx_ops) { } static inline void dp_vdev_fetch_tx_handler(struct dp_vdev *vdev, struct dp_soc *soc, struct ol_txrx_hardtart_ctxt *ctx) { } #endif /* QCA_HOST_MODE_WIFI_DISABLED */ /** * dp_vdev_register_wifi3() - Register VDEV operations from osif layer * @soc_hdl: Datapath soc handle * @vdev_id: id of Datapath VDEV handle * @osif_vdev: OSIF vdev handle * @txrx_ops: Tx and Rx operations * * Return: DP VDEV handle on success, NULL on failure */ static QDF_STATUS dp_vdev_register_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, ol_osif_vdev_handle osif_vdev, struct ol_txrx_ops *txrx_ops) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; vdev->osif_vdev = osif_vdev; vdev->osif_rx = txrx_ops->rx.rx; vdev->osif_rx_stack = txrx_ops->rx.rx_stack; vdev->osif_rx_flush = txrx_ops->rx.rx_flush; vdev->osif_gro_flush = txrx_ops->rx.rx_gro_flush; vdev->osif_rsim_rx_decap = txrx_ops->rx.rsim_rx_decap; vdev->osif_fisa_rx = txrx_ops->rx.osif_fisa_rx; vdev->osif_fisa_flush = txrx_ops->rx.osif_fisa_flush; vdev->osif_get_key = txrx_ops->get_key; dp_monitor_vdev_register_osif(vdev, txrx_ops); vdev->osif_tx_free_ext = txrx_ops->tx.tx_free_ext; vdev->tx_comp = txrx_ops->tx.tx_comp; vdev->stats_cb = txrx_ops->rx.stats_rx; vdev->tx_classify_critical_pkt_cb = txrx_ops->tx.tx_classify_critical_pkt_cb; #ifdef notyet #if ATH_SUPPORT_WAPI vdev->osif_check_wai = txrx_ops->rx.wai_check; #endif #endif #ifdef UMAC_SUPPORT_PROXY_ARP vdev->osif_proxy_arp = txrx_ops->proxy_arp; #endif vdev->me_convert = txrx_ops->me_convert; vdev->get_tsf_time = txrx_ops->get_tsf_time; vdev->vdev_del_notify = txrx_ops->vdev_del_notify; dp_vdev_register_rx_eapol(vdev, txrx_ops); dp_vdev_register_tx_handler(vdev, soc, txrx_ops); dp_init_info("%pK: DP Vdev Register success", soc); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #ifdef WLAN_FEATURE_11BE_MLO void dp_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) { if (!peer->valid) return; dp_peer_delete_wifi3((struct cdp_soc_t *)soc, peer->vdev->vdev_id, peer->mac_addr.raw, 0, peer->peer_type); } #else void dp_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) { if (!peer->valid) return; dp_peer_delete_wifi3((struct cdp_soc_t *)soc, peer->vdev->vdev_id, peer->mac_addr.raw, 0, CDP_LINK_PEER_TYPE); } #endif #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) static uint8_t dp_mlo_get_num_link_peer(struct dp_soc *soc, struct dp_peer *peer) { if (soc->cdp_soc.ol_ops->peer_get_num_mlo_links) return soc->cdp_soc.ol_ops->peer_get_num_mlo_links( soc->ctrl_psoc, peer->vdev->vdev_id, peer->mac_addr.raw, IS_MLO_DP_MLD_PEER(peer)); return 0; } void dp_mlo_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) { if (!peer->valid) return; /* skip deleting the SLO peers */ if (dp_mlo_get_num_link_peer(soc, peer) == 1) return; if (IS_MLO_DP_LINK_PEER(peer)) dp_peer_delete_wifi3((struct cdp_soc_t *)soc, peer->vdev->vdev_id, peer->mac_addr.raw, 0, CDP_LINK_PEER_TYPE); } /** * dp_mlo_link_peer_flush() - flush all the link peers * @soc: Datapath soc handle * @peer: DP peer handle to be checked * * Return: None */ static void dp_mlo_link_peer_flush(struct dp_soc *soc, struct dp_peer *peer) { int cnt = 0; struct dp_peer *link_peer = NULL; struct dp_mld_link_peers link_peers_info = {NULL}; if (!IS_MLO_DP_MLD_PEER(peer)) return; /* get link peers with reference */ dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_CDP); for (cnt = 0; cnt < link_peers_info.num_links; cnt++) { link_peer = link_peers_info.link_peers[cnt]; if (!link_peer) continue; /* delete all the link peers */ dp_mlo_peer_delete(link_peer->vdev->pdev->soc, link_peer, NULL); /* unmap all the link peers */ dp_rx_peer_unmap_handler(link_peer->vdev->pdev->soc, link_peer->peer_id, link_peer->vdev->vdev_id, link_peer->mac_addr.raw, 0, DP_PEER_WDS_COUNT_INVALID); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); } #else static uint8_t dp_mlo_get_num_link_peer(struct dp_soc *soc, struct dp_peer *peer) { return 0; } void dp_mlo_peer_delete(struct dp_soc *soc, struct dp_peer *peer, void *arg) { } static void dp_mlo_link_peer_flush(struct dp_soc *soc, struct dp_peer *peer) { } #endif /** * dp_vdev_flush_peers() - Forcibily Flush peers of vdev * @vdev_handle: Datapath VDEV handle * @unmap_only: Flag to indicate "only unmap" * @mlo_peers_only: true if only MLO peers should be flushed * * Return: void */ static void dp_vdev_flush_peers(struct cdp_vdev *vdev_handle, bool unmap_only, bool mlo_peers_only) { struct dp_vdev *vdev = (struct dp_vdev *)vdev_handle; struct dp_pdev *pdev = vdev->pdev; struct dp_soc *soc = pdev->soc; struct dp_peer *peer; uint32_t i = 0; if (!unmap_only) { if (!mlo_peers_only) dp_vdev_iterate_peer_lock_safe(vdev, dp_peer_delete, NULL, DP_MOD_ID_CDP); else dp_vdev_iterate_peer_lock_safe(vdev, dp_mlo_peer_delete, NULL, DP_MOD_ID_CDP); } for (i = 0; i < soc->max_peer_id ; i++) { peer = __dp_peer_get_ref_by_id(soc, i, DP_MOD_ID_CDP); if (!peer) continue; if (peer->vdev != vdev) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); continue; } if (!mlo_peers_only) { dp_info("peer: " QDF_MAC_ADDR_FMT " is getting unmap", QDF_MAC_ADDR_REF(peer->mac_addr.raw)); dp_mlo_link_peer_flush(soc, peer); dp_rx_peer_unmap_handler(soc, i, vdev->vdev_id, peer->mac_addr.raw, 0, DP_PEER_WDS_COUNT_INVALID); if (!IS_MLO_DP_MLD_PEER(peer)) SET_PEER_REF_CNT_ONE(peer); } else if (IS_MLO_DP_LINK_PEER(peer) || IS_MLO_DP_MLD_PEER(peer)) { dp_info("peer: " QDF_MAC_ADDR_FMT " is getting unmap", QDF_MAC_ADDR_REF(peer->mac_addr.raw)); /* skip deleting the SLO peers */ if (dp_mlo_get_num_link_peer(soc, peer) == 1) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); continue; } dp_mlo_link_peer_flush(soc, peer); dp_rx_peer_unmap_handler(soc, i, vdev->vdev_id, peer->mac_addr.raw, 0, DP_PEER_WDS_COUNT_INVALID); if (!IS_MLO_DP_MLD_PEER(peer)) SET_PEER_REF_CNT_ONE(peer); } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); } } #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT /** * dp_txrx_alloc_vdev_stats_id()- Allocate vdev_stats_id * @soc_hdl: Datapath soc handle * @vdev_stats_id: Address of vdev_stats_id * * Return: QDF_STATUS */ static QDF_STATUS dp_txrx_alloc_vdev_stats_id(struct cdp_soc_t *soc_hdl, uint8_t *vdev_stats_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); uint8_t id = 0; if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { *vdev_stats_id = CDP_INVALID_VDEV_STATS_ID; return QDF_STATUS_E_FAILURE; } while (id < CDP_MAX_VDEV_STATS_ID) { if (!qdf_atomic_test_and_set_bit(id, &soc->vdev_stats_id_map)) { *vdev_stats_id = id; return QDF_STATUS_SUCCESS; } id++; } *vdev_stats_id = CDP_INVALID_VDEV_STATS_ID; return QDF_STATUS_E_FAILURE; } /** * dp_txrx_reset_vdev_stats_id() - Reset vdev_stats_id in dp_soc * @soc_hdl: Datapath soc handle * @vdev_stats_id: vdev_stats_id to reset in dp_soc * * Return: none */ static void dp_txrx_reset_vdev_stats_id(struct cdp_soc_t *soc_hdl, uint8_t vdev_stats_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); if ((!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) || (vdev_stats_id >= CDP_MAX_VDEV_STATS_ID)) return; qdf_atomic_clear_bit(vdev_stats_id, &soc->vdev_stats_id_map); } #else static void dp_txrx_reset_vdev_stats_id(struct cdp_soc_t *soc, uint8_t vdev_stats_id) {} #endif /** * dp_vdev_detach_wifi3() - Detach txrx vdev * @cdp_soc: Datapath soc handle * @vdev_id: VDEV Id * @callback: Callback OL_IF on completion of detach * @cb_context: Callback context * */ static QDF_STATUS dp_vdev_detach_wifi3(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, ol_txrx_vdev_delete_cb callback, void *cb_context) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct dp_pdev *pdev; struct dp_neighbour_peer *peer = NULL; struct dp_peer *vap_self_peer = NULL; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; soc->arch_ops.txrx_vdev_detach(soc, vdev); pdev = vdev->pdev; vap_self_peer = dp_sta_vdev_self_peer_ref_n_get(soc, vdev, DP_MOD_ID_CONFIG); if (vap_self_peer) { qdf_spin_lock_bh(&soc->ast_lock); if (vap_self_peer->self_ast_entry) { dp_peer_del_ast(soc, vap_self_peer->self_ast_entry); vap_self_peer->self_ast_entry = NULL; } qdf_spin_unlock_bh(&soc->ast_lock); dp_peer_delete_wifi3((struct cdp_soc_t *)soc, vdev->vdev_id, vap_self_peer->mac_addr.raw, 0, CDP_LINK_PEER_TYPE); dp_peer_unref_delete(vap_self_peer, DP_MOD_ID_CONFIG); } /* * If Target is hung, flush all peers before detaching vdev * this will free all references held due to missing * unmap commands from Target */ if (!hif_is_target_ready(HIF_GET_SOFTC(soc->hif_handle))) dp_vdev_flush_peers((struct cdp_vdev *)vdev, false, false); else if (hif_get_target_status(soc->hif_handle) == TARGET_STATUS_RESET) dp_vdev_flush_peers((struct cdp_vdev *)vdev, true, false); /* indicate that the vdev needs to be deleted */ vdev->delete.pending = 1; dp_rx_vdev_detach(vdev); /* * move it after dp_rx_vdev_detach(), * as the call back done in dp_rx_vdev_detach() * still need to get vdev pointer by vdev_id. */ dp_vdev_id_map_tbl_remove(soc, vdev); dp_monitor_neighbour_peer_list_remove(pdev, vdev, peer); dp_txrx_reset_vdev_stats_id(cdp_soc, vdev->vdev_stats_id); dp_tx_vdev_multipass_deinit(vdev); dp_tx_vdev_traffic_end_indication_detach(vdev); if (vdev->vdev_dp_ext_handle) { qdf_mem_free(vdev->vdev_dp_ext_handle); vdev->vdev_dp_ext_handle = NULL; } vdev->delete.callback = callback; vdev->delete.context = cb_context; if (vdev->opmode != wlan_op_mode_monitor) dp_vdev_pdev_list_remove(soc, pdev, vdev); pdev->vdev_count--; /* release reference taken above for find */ dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); TAILQ_INSERT_TAIL(&soc->inactive_vdev_list, vdev, inactive_list_elem); qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_DETACH, vdev); dp_info("detach vdev %pK id %d pending refs %d", vdev, vdev->vdev_id, qdf_atomic_read(&vdev->ref_cnt)); /* release reference taken at dp_vdev_create */ dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CONFIG); return QDF_STATUS_SUCCESS; } #ifdef WLAN_FEATURE_11BE_MLO /** * is_dp_peer_can_reuse() - check if the dp_peer match condition to be reused * @vdev: Target DP vdev handle * @peer: DP peer handle to be checked * @peer_mac_addr: Target peer mac address * @peer_type: Target peer type * * Return: true - if match, false - not match */ static inline bool is_dp_peer_can_reuse(struct dp_vdev *vdev, struct dp_peer *peer, uint8_t *peer_mac_addr, enum cdp_peer_type peer_type) { if (peer->bss_peer && (peer->vdev == vdev) && (peer->peer_type == peer_type) && (qdf_mem_cmp(peer_mac_addr, peer->mac_addr.raw, QDF_MAC_ADDR_SIZE) == 0)) return true; return false; } #else static inline bool is_dp_peer_can_reuse(struct dp_vdev *vdev, struct dp_peer *peer, uint8_t *peer_mac_addr, enum cdp_peer_type peer_type) { if (peer->bss_peer && (peer->vdev == vdev) && (qdf_mem_cmp(peer_mac_addr, peer->mac_addr.raw, QDF_MAC_ADDR_SIZE) == 0)) return true; return false; } #endif static inline struct dp_peer *dp_peer_can_reuse(struct dp_vdev *vdev, uint8_t *peer_mac_addr, enum cdp_peer_type peer_type) { struct dp_peer *peer; struct dp_soc *soc = vdev->pdev->soc; qdf_spin_lock_bh(&soc->inactive_peer_list_lock); TAILQ_FOREACH(peer, &soc->inactive_peer_list, inactive_list_elem) { /* reuse bss peer only when vdev matches*/ if (is_dp_peer_can_reuse(vdev, peer, peer_mac_addr, peer_type)) { /* increment ref count for cdp_peer_create*/ if (dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG) == QDF_STATUS_SUCCESS) { TAILQ_REMOVE(&soc->inactive_peer_list, peer, inactive_list_elem); qdf_spin_unlock_bh (&soc->inactive_peer_list_lock); return peer; } } } qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); return NULL; } #ifdef FEATURE_AST static inline void dp_peer_ast_handle_roam_del(struct dp_soc *soc, struct dp_pdev *pdev, uint8_t *peer_mac_addr) { struct dp_ast_entry *ast_entry; if (soc->ast_offload_support) return; qdf_spin_lock_bh(&soc->ast_lock); if (soc->ast_override_support) ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, peer_mac_addr, pdev->pdev_id); else ast_entry = dp_peer_ast_hash_find_soc(soc, peer_mac_addr); if (ast_entry && ast_entry->next_hop && !ast_entry->delete_in_progress) dp_peer_del_ast(soc, ast_entry); qdf_spin_unlock_bh(&soc->ast_lock); } #else static inline void dp_peer_ast_handle_roam_del(struct dp_soc *soc, struct dp_pdev *pdev, uint8_t *peer_mac_addr) { } #endif #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT /** * dp_peer_hw_txrx_stats_init() - Initialize hw_txrx_stats_en in dp_peer * @soc: Datapath soc handle * @txrx_peer: Datapath peer handle * * Return: none */ static inline void dp_peer_hw_txrx_stats_init(struct dp_soc *soc, struct dp_txrx_peer *txrx_peer) { txrx_peer->hw_txrx_stats_en = wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx); } #else static inline void dp_peer_hw_txrx_stats_init(struct dp_soc *soc, struct dp_txrx_peer *txrx_peer) { txrx_peer->hw_txrx_stats_en = 0; } #endif static QDF_STATUS dp_txrx_peer_detach(struct dp_soc *soc, struct dp_peer *peer) { struct dp_txrx_peer *txrx_peer; struct dp_pdev *pdev; struct cdp_txrx_peer_params_update params = {0}; /* dp_txrx_peer exists for mld peer and legacy peer */ if (peer->txrx_peer) { txrx_peer = peer->txrx_peer; peer->txrx_peer = NULL; pdev = txrx_peer->vdev->pdev; if ((peer->vdev->opmode != wlan_op_mode_sta) && !peer->bss_peer) { params.vdev_id = peer->vdev->vdev_id; params.peer_mac = peer->mac_addr.raw; dp_wdi_event_handler(WDI_EVENT_PEER_DELETE, soc, (void *)¶ms, peer->peer_id, WDI_NO_VAL, pdev->pdev_id); } dp_peer_defrag_rx_tids_deinit(txrx_peer); /* * Deallocate the extended stats contenxt */ dp_peer_delay_stats_ctx_dealloc(soc, txrx_peer); dp_peer_rx_bufq_resources_deinit(txrx_peer); dp_peer_jitter_stats_ctx_dealloc(pdev, txrx_peer); dp_peer_sawf_stats_ctx_free(soc, txrx_peer); qdf_mem_free(txrx_peer); } return QDF_STATUS_SUCCESS; } static inline uint8_t dp_txrx_peer_calculate_stats_size(struct dp_soc *soc, struct dp_peer *peer) { if ((wlan_cfg_is_peer_link_stats_enabled(soc->wlan_cfg_ctx)) && IS_MLO_DP_MLD_PEER(peer)) { return (DP_MAX_MLO_LINKS + 1); } return 1; } static QDF_STATUS dp_txrx_peer_attach(struct dp_soc *soc, struct dp_peer *peer) { struct dp_txrx_peer *txrx_peer; struct dp_pdev *pdev; struct cdp_txrx_peer_params_update params = {0}; uint8_t stats_arr_size = 0; stats_arr_size = dp_txrx_peer_calculate_stats_size(soc, peer); txrx_peer = (struct dp_txrx_peer *)qdf_mem_malloc(sizeof(*txrx_peer) + (stats_arr_size * sizeof(struct dp_peer_stats))); if (!txrx_peer) return QDF_STATUS_E_NOMEM; /* failure */ txrx_peer->peer_id = HTT_INVALID_PEER; /* initialize the peer_id */ txrx_peer->vdev = peer->vdev; pdev = peer->vdev->pdev; txrx_peer->stats_arr_size = stats_arr_size; DP_TXRX_PEER_STATS_INIT(txrx_peer, (txrx_peer->stats_arr_size * sizeof(struct dp_peer_stats))); if (!IS_DP_LEGACY_PEER(peer)) txrx_peer->is_mld_peer = 1; dp_wds_ext_peer_init(txrx_peer); dp_peer_rx_bufq_resources_init(txrx_peer); dp_peer_hw_txrx_stats_init(soc, txrx_peer); /* * Allocate peer extended stats context. Fall through in * case of failure as its not an implicit requirement to have * this object for regular statistics updates. */ if (dp_peer_delay_stats_ctx_alloc(soc, txrx_peer) != QDF_STATUS_SUCCESS) dp_warn("peer delay_stats ctx alloc failed"); /* * Alloctate memory for jitter stats. Fall through in * case of failure as its not an implicit requirement to have * this object for regular statistics updates. */ if (dp_peer_jitter_stats_ctx_alloc(pdev, txrx_peer) != QDF_STATUS_SUCCESS) dp_warn("peer jitter_stats ctx alloc failed"); dp_set_peer_isolation(txrx_peer, false); dp_peer_defrag_rx_tids_init(txrx_peer); if (dp_peer_sawf_stats_ctx_alloc(soc, txrx_peer) != QDF_STATUS_SUCCESS) dp_warn("peer sawf stats alloc failed"); dp_txrx_peer_attach_add(soc, peer, txrx_peer); if ((peer->vdev->opmode == wlan_op_mode_sta) || peer->bss_peer) return QDF_STATUS_SUCCESS; params.peer_mac = peer->mac_addr.raw; params.vdev_id = peer->vdev->vdev_id; params.chip_id = dp_get_chip_id(soc); params.pdev_id = peer->vdev->pdev->pdev_id; dp_wdi_event_handler(WDI_EVENT_TXRX_PEER_CREATE, soc, (void *)¶ms, peer->peer_id, WDI_NO_VAL, params.pdev_id); return QDF_STATUS_SUCCESS; } static inline void dp_txrx_peer_stats_clr(struct dp_txrx_peer *txrx_peer) { if (!txrx_peer) return; txrx_peer->tx_failed = 0; txrx_peer->comp_pkt.num = 0; txrx_peer->comp_pkt.bytes = 0; txrx_peer->to_stack.num = 0; txrx_peer->to_stack.bytes = 0; DP_TXRX_PEER_STATS_CLR(txrx_peer, (txrx_peer->stats_arr_size * sizeof(struct dp_peer_stats))); dp_peer_delay_stats_ctx_clr(txrx_peer); dp_peer_jitter_stats_ctx_clr(txrx_peer); } #if defined WLAN_FEATURE_11BE_MLO && defined DP_MLO_LINK_STATS_SUPPORT /** * dp_txrx_peer_reset_local_link_id() - Reset local link id * @txrx_peer: txrx peer handle * * Return: None */ static inline void dp_txrx_peer_reset_local_link_id(struct dp_txrx_peer *txrx_peer) { int i; for (i = 0; i <= DP_MAX_MLO_LINKS; i++) txrx_peer->ll_band[i] = DP_BAND_INVALID; } #else static inline void dp_txrx_peer_reset_local_link_id(struct dp_txrx_peer *txrx_peer) { } #endif /** * dp_peer_create_wifi3() - attach txrx peer * @soc_hdl: Datapath soc handle * @vdev_id: id of vdev * @peer_mac_addr: Peer MAC address * @peer_type: link or MLD peer type * * Return: 0 on success, -1 on failure */ static QDF_STATUS dp_peer_create_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac_addr, enum cdp_peer_type peer_type) { struct dp_peer *peer; int i; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_pdev *pdev; enum cdp_txrx_ast_entry_type ast_type = CDP_TXRX_AST_TYPE_STATIC; struct dp_vdev *vdev = NULL; if (!peer_mac_addr) return QDF_STATUS_E_FAILURE; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; pdev = vdev->pdev; soc = pdev->soc; /* * If a peer entry with given MAC address already exists, * reuse the peer and reset the state of peer. */ peer = dp_peer_can_reuse(vdev, peer_mac_addr, peer_type); if (peer) { qdf_atomic_init(&peer->is_default_route_set); dp_peer_cleanup(vdev, peer); dp_peer_vdev_list_add(soc, vdev, peer); dp_peer_find_hash_add(soc, peer); if (dp_peer_rx_tids_create(peer) != QDF_STATUS_SUCCESS) { dp_alert("RX tid alloc fail for peer %pK (" QDF_MAC_ADDR_FMT ")", peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } if (IS_MLO_DP_MLD_PEER(peer)) dp_mld_peer_init_link_peers_info(peer); qdf_spin_lock_bh(&soc->ast_lock); dp_peer_delete_ast_entries(soc, peer); qdf_spin_unlock_bh(&soc->ast_lock); if ((vdev->opmode == wlan_op_mode_sta) && !qdf_mem_cmp(peer_mac_addr, &vdev->mac_addr.raw[0], QDF_MAC_ADDR_SIZE)) { ast_type = CDP_TXRX_AST_TYPE_SELF; } dp_peer_add_ast(soc, peer, peer_mac_addr, ast_type, 0); peer->valid = 1; peer->is_tdls_peer = false; dp_local_peer_id_alloc(pdev, peer); qdf_spinlock_create(&peer->peer_info_lock); DP_STATS_INIT(peer); /* * In tx_monitor mode, filter may be set for unassociated peer * when unassociated peer get associated peer need to * update tx_cap_enabled flag to support peer filter. */ if (!IS_MLO_DP_MLD_PEER(peer)) { dp_monitor_peer_tx_capture_filter_check(pdev, peer); dp_monitor_peer_reset_stats(soc, peer); } if (peer->txrx_peer) { dp_peer_rx_bufq_resources_init(peer->txrx_peer); dp_txrx_peer_stats_clr(peer->txrx_peer); dp_set_peer_isolation(peer->txrx_peer, false); dp_wds_ext_peer_init(peer->txrx_peer); dp_peer_hw_txrx_stats_init(soc, peer->txrx_peer); dp_txrx_peer_reset_local_link_id(peer->txrx_peer); } dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_CREATE, peer, vdev, 1); dp_info("vdev %pK Reused peer %pK ("QDF_MAC_ADDR_FMT ") vdev_ref_cnt " "%d peer_ref_cnt: %d", vdev, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), qdf_atomic_read(&vdev->ref_cnt), qdf_atomic_read(&peer->ref_cnt)); dp_peer_update_state(soc, peer, DP_PEER_STATE_INIT); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } else { /* * When a STA roams from RPTR AP to ROOT AP and vice versa, we * need to remove the AST entry which was earlier added as a WDS * entry. * If an AST entry exists, but no peer entry exists with a given * MAC addresses, we could deduce it as a WDS entry */ dp_peer_ast_handle_roam_del(soc, pdev, peer_mac_addr); } #ifdef notyet peer = (struct dp_peer *)qdf_mempool_alloc(soc->osdev, soc->mempool_ol_ath_peer); #else peer = (struct dp_peer *)qdf_mem_malloc(sizeof(*peer)); #endif wlan_minidump_log(peer, sizeof(*peer), soc->ctrl_psoc, WLAN_MD_DP_PEER, "dp_peer"); if (!peer) { dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; /* failure */ } qdf_mem_zero(peer, sizeof(struct dp_peer)); /* store provided params */ peer->vdev = vdev; /* initialize the peer_id */ peer->peer_id = HTT_INVALID_PEER; qdf_mem_copy( &peer->mac_addr.raw[0], peer_mac_addr, QDF_MAC_ADDR_SIZE); DP_PEER_SET_TYPE(peer, peer_type); if (IS_MLO_DP_MLD_PEER(peer)) { if (dp_txrx_peer_attach(soc, peer) != QDF_STATUS_SUCCESS) goto fail; /* failure */ dp_mld_peer_init_link_peers_info(peer); } if (dp_monitor_peer_attach(soc, peer) != QDF_STATUS_SUCCESS) dp_warn("peer monitor ctx alloc failed"); TAILQ_INIT(&peer->ast_entry_list); /* get the vdev reference for new peer */ dp_vdev_get_ref(soc, vdev, DP_MOD_ID_CHILD); if ((vdev->opmode == wlan_op_mode_sta) && !qdf_mem_cmp(peer_mac_addr, &vdev->mac_addr.raw[0], QDF_MAC_ADDR_SIZE)) { ast_type = CDP_TXRX_AST_TYPE_SELF; } qdf_spinlock_create(&peer->peer_state_lock); dp_peer_add_ast(soc, peer, peer_mac_addr, ast_type, 0); qdf_spinlock_create(&peer->peer_info_lock); /* reset the ast index to flowid table */ dp_peer_reset_flowq_map(peer); qdf_atomic_init(&peer->ref_cnt); for (i = 0; i < DP_MOD_ID_MAX; i++) qdf_atomic_init(&peer->mod_refs[i]); /* keep one reference for attach */ qdf_atomic_inc(&peer->ref_cnt); qdf_atomic_inc(&peer->mod_refs[DP_MOD_ID_CONFIG]); dp_peer_vdev_list_add(soc, vdev, peer); /* TODO: See if hash based search is required */ dp_peer_find_hash_add(soc, peer); /* Initialize the peer state */ peer->state = OL_TXRX_PEER_STATE_DISC; dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_CREATE, peer, vdev, 0); dp_info("vdev %pK created peer %pK ("QDF_MAC_ADDR_FMT") vdev_ref_cnt " "%d peer_ref_cnt: %d", vdev, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), qdf_atomic_read(&vdev->ref_cnt), qdf_atomic_read(&peer->ref_cnt)); /* * For every peer MAp message search and set if bss_peer */ if (qdf_mem_cmp(peer->mac_addr.raw, vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE) == 0 && (wlan_op_mode_sta != vdev->opmode)) { dp_info("vdev bss_peer!!"); peer->bss_peer = 1; if (peer->txrx_peer) peer->txrx_peer->bss_peer = 1; } if (wlan_op_mode_sta == vdev->opmode && qdf_mem_cmp(peer->mac_addr.raw, vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE) == 0) { peer->sta_self_peer = 1; } if (dp_peer_rx_tids_create(peer) != QDF_STATUS_SUCCESS) { dp_alert("RX tid alloc fail for peer %pK (" QDF_MAC_ADDR_FMT ")", peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); goto fail; } peer->valid = 1; dp_local_peer_id_alloc(pdev, peer); DP_STATS_INIT(peer); if (dp_peer_sawf_ctx_alloc(soc, peer) != QDF_STATUS_SUCCESS) dp_warn("peer sawf context alloc failed"); dp_peer_update_state(soc, peer, DP_PEER_STATE_INIT); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; fail: qdf_mem_free(peer); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } QDF_STATUS dp_peer_legacy_setup(struct dp_soc *soc, struct dp_peer *peer) { /* txrx_peer might exist already in peer reuse case */ if (peer->txrx_peer) return QDF_STATUS_SUCCESS; if (dp_txrx_peer_attach(soc, peer) != QDF_STATUS_SUCCESS) { dp_err("peer txrx ctx alloc failed"); return QDF_STATUS_E_FAILURE; } return QDF_STATUS_SUCCESS; } #ifdef WLAN_FEATURE_11BE_MLO static QDF_STATUS dp_mld_peer_change_vdev(struct dp_soc *soc, struct dp_peer *mld_peer, uint8_t new_vdev_id) { struct dp_vdev *prev_vdev; prev_vdev = mld_peer->vdev; /* release the ref to original dp_vdev */ dp_vdev_unref_delete(soc, mld_peer->vdev, DP_MOD_ID_CHILD); /* * get the ref to new dp_vdev, * increase dp_vdev ref_cnt */ mld_peer->vdev = dp_vdev_get_ref_by_id(soc, new_vdev_id, DP_MOD_ID_CHILD); mld_peer->txrx_peer->vdev = mld_peer->vdev; dp_info("Change vdev for ML peer " QDF_MAC_ADDR_FMT " old vdev %pK id %d new vdev %pK id %d", QDF_MAC_ADDR_REF(mld_peer->mac_addr.raw), prev_vdev, prev_vdev->vdev_id, mld_peer->vdev, new_vdev_id); dp_cfg_event_record_mlo_setup_vdev_update_evt( soc, mld_peer, prev_vdev, mld_peer->vdev); return QDF_STATUS_SUCCESS; } QDF_STATUS dp_peer_mlo_setup( struct dp_soc *soc, struct dp_peer *peer, uint8_t vdev_id, struct cdp_peer_setup_info *setup_info) { struct dp_peer *mld_peer = NULL; struct cdp_txrx_peer_params_update params = {0}; /* Non-MLO connection */ if (!setup_info || !setup_info->mld_peer_mac) { /* To handle downgrade scenarios */ if (peer->vdev->opmode == wlan_op_mode_sta) { struct cdp_txrx_peer_params_update params = {0}; params.chip_id = dp_get_chip_id(soc); params.pdev_id = peer->vdev->pdev->pdev_id; params.vdev_id = peer->vdev->vdev_id; dp_wdi_event_handler( WDI_EVENT_STA_PRIMARY_UMAC_UPDATE, soc, (void *)¶ms, peer->peer_id, WDI_NO_VAL, params.pdev_id); } return QDF_STATUS_SUCCESS; } dp_cfg_event_record_peer_setup_evt(soc, DP_CFG_EVENT_MLO_SETUP, peer, NULL, vdev_id, setup_info); /* if this is the first link peer */ if (setup_info->is_first_link) /* create MLD peer */ dp_peer_create_wifi3((struct cdp_soc_t *)soc, vdev_id, setup_info->mld_peer_mac, CDP_MLD_PEER_TYPE); if (peer->vdev->opmode == wlan_op_mode_sta && setup_info->is_primary_link) { struct cdp_txrx_peer_params_update params = {0}; params.chip_id = dp_get_chip_id(soc); params.pdev_id = peer->vdev->pdev->pdev_id; params.vdev_id = peer->vdev->vdev_id; dp_wdi_event_handler( WDI_EVENT_STA_PRIMARY_UMAC_UPDATE, soc, (void *)¶ms, peer->peer_id, WDI_NO_VAL, params.pdev_id); } peer->first_link = setup_info->is_first_link; peer->primary_link = setup_info->is_primary_link; mld_peer = dp_mld_peer_find_hash_find(soc, setup_info->mld_peer_mac, 0, vdev_id, DP_MOD_ID_CDP); dp_info("Peer %pK MAC " QDF_MAC_ADDR_FMT " mld peer %pK MAC " QDF_MAC_ADDR_FMT " first_link %d, primary_link %d", peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), mld_peer, QDF_MAC_ADDR_REF(setup_info->mld_peer_mac), peer->first_link, peer->primary_link); if (mld_peer) { if (setup_info->is_first_link) { /* assign rx_tid to mld peer */ mld_peer->rx_tid = peer->rx_tid; /* no cdp_peer_setup for MLD peer, * set it for addba processing */ qdf_atomic_set(&mld_peer->is_default_route_set, 1); } else { /* free link peer original rx_tids mem */ dp_peer_rx_tids_destroy(peer); /* assign mld peer rx_tid to link peer */ peer->rx_tid = mld_peer->rx_tid; } if (setup_info->is_primary_link && !setup_info->is_first_link) { /* * if first link is not the primary link, * then need to change mld_peer->vdev as * primary link dp_vdev is not same one * during mld peer creation. */ dp_info("Primary link is not the first link. vdev: %pK " "vdev_id %d vdev_ref_cnt %d", mld_peer->vdev, vdev_id, qdf_atomic_read(&mld_peer->vdev->ref_cnt)); dp_mld_peer_change_vdev(soc, mld_peer, vdev_id); params.vdev_id = peer->vdev->vdev_id; params.peer_mac = mld_peer->mac_addr.raw; params.chip_id = dp_get_chip_id(soc); params.pdev_id = peer->vdev->pdev->pdev_id; dp_wdi_event_handler( WDI_EVENT_PEER_PRIMARY_UMAC_UPDATE, soc, (void *)¶ms, peer->peer_id, WDI_NO_VAL, params.pdev_id); } /* associate mld and link peer */ dp_link_peer_add_mld_peer(peer, mld_peer); dp_mld_peer_add_link_peer(mld_peer, peer, setup_info->is_bridge_peer); mld_peer->txrx_peer->is_mld_peer = 1; dp_peer_unref_delete(mld_peer, DP_MOD_ID_CDP); } else { peer->mld_peer = NULL; dp_err("mld peer" QDF_MAC_ADDR_FMT "not found!", QDF_MAC_ADDR_REF(setup_info->mld_peer_mac)); return QDF_STATUS_E_FAILURE; } return QDF_STATUS_SUCCESS; } /** * dp_mlo_peer_authorize() - authorize MLO peer * @soc: soc handle * @peer: pointer to link peer * * Return: void */ static void dp_mlo_peer_authorize(struct dp_soc *soc, struct dp_peer *peer) { int i; struct dp_peer *link_peer = NULL; struct dp_peer *mld_peer = peer->mld_peer; struct dp_mld_link_peers link_peers_info; if (!mld_peer) return; /* get link peers with reference */ dp_get_link_peers_ref_from_mld_peer(soc, mld_peer, &link_peers_info, DP_MOD_ID_CDP); for (i = 0; i < link_peers_info.num_links; i++) { link_peer = link_peers_info.link_peers[i]; if (!link_peer->authorize) { dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); mld_peer->authorize = false; return; } } /* if we are here all link peers are authorized, * authorize ml_peer also */ mld_peer->authorize = true; /* release link peers reference */ dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); } #endif /** * dp_peer_setup_wifi3_wrapper() - initialize the peer * @soc_hdl: soc handle object * @vdev_id : vdev_id of vdev object * @peer_mac: Peer's mac address * @setup_info: peer setup info for MLO * * Return: QDF_STATUS */ static QDF_STATUS dp_peer_setup_wifi3_wrapper(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_setup_info *setup_info) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; return soc->arch_ops.txrx_peer_setup(soc_hdl, vdev_id, peer_mac, setup_info); } /** * dp_cp_peer_del_resp_handler() - Handle the peer delete response * @soc_hdl: Datapath SOC handle * @vdev_id: id of virtual device object * @mac_addr: Mac address of the peer * * Return: QDF_STATUS */ static QDF_STATUS dp_cp_peer_del_resp_handler(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *mac_addr) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_ast_entry *ast_entry = NULL; txrx_ast_free_cb cb = NULL; void *cookie; if (soc->ast_offload_support) return QDF_STATUS_E_INVAL; qdf_spin_lock_bh(&soc->ast_lock); ast_entry = dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, vdev_id); /* in case of qwrap we have multiple BSS peers * with same mac address * * AST entry for this mac address will be created * only for one peer hence it will be NULL here */ if ((!ast_entry || !ast_entry->delete_in_progress) || (ast_entry->peer_id != HTT_INVALID_PEER)) { qdf_spin_unlock_bh(&soc->ast_lock); return QDF_STATUS_E_FAILURE; } if (ast_entry->is_mapped) soc->ast_table[ast_entry->ast_idx] = NULL; DP_STATS_INC(soc, ast.deleted, 1); dp_peer_ast_hash_remove(soc, ast_entry); cb = ast_entry->callback; cookie = ast_entry->cookie; ast_entry->callback = NULL; ast_entry->cookie = NULL; soc->num_ast_entries--; qdf_spin_unlock_bh(&soc->ast_lock); if (cb) { cb(soc->ctrl_psoc, dp_soc_to_cdp_soc(soc), cookie, CDP_TXRX_AST_DELETED); } qdf_mem_free(ast_entry); return QDF_STATUS_SUCCESS; } #ifdef WLAN_SUPPORT_MSCS /** * dp_record_mscs_params() - Record MSCS parameters sent by the STA in * the MSCS Request to the AP. * @soc_hdl: Datapath soc handle * @peer_mac: STA Mac address * @vdev_id: ID of the vdev handle * @mscs_params: Structure having MSCS parameters obtained * from handshake * @active: Flag to set MSCS active/inactive * * The AP makes a note of these parameters while comparing the MSDUs * sent by the STA, to send the downlink traffic with correct User * priority. * * Return: QDF_STATUS - Success/Invalid */ static QDF_STATUS dp_record_mscs_params(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, uint8_t vdev_id, struct cdp_mscs_params *mscs_params, bool active) { struct dp_peer *peer; struct dp_peer *tgt_peer; QDF_STATUS status = QDF_STATUS_E_INVAL; struct dp_soc *soc = (struct dp_soc *)soc_hdl; peer = dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_err("Peer is NULL!"); goto fail; } tgt_peer = dp_get_tgt_peer_from_peer(peer); if (!tgt_peer) goto fail; if (!active) { dp_info("MSCS Procedure is terminated"); tgt_peer->mscs_active = active; goto fail; } if (mscs_params->classifier_type == IEEE80211_TCLAS_MASK_CLA_TYPE_4) { /* Populate entries inside IPV4 database first */ tgt_peer->mscs_ipv4_parameter.user_priority_bitmap = mscs_params->user_pri_bitmap; tgt_peer->mscs_ipv4_parameter.user_priority_limit = mscs_params->user_pri_limit; tgt_peer->mscs_ipv4_parameter.classifier_mask = mscs_params->classifier_mask; /* Populate entries inside IPV6 database */ tgt_peer->mscs_ipv6_parameter.user_priority_bitmap = mscs_params->user_pri_bitmap; tgt_peer->mscs_ipv6_parameter.user_priority_limit = mscs_params->user_pri_limit; tgt_peer->mscs_ipv6_parameter.classifier_mask = mscs_params->classifier_mask; tgt_peer->mscs_active = 1; dp_info("\n\tMSCS Procedure request based parameters for "QDF_MAC_ADDR_FMT"\n" "\tClassifier_type = %d\tUser priority bitmap = %x\n" "\tUser priority limit = %x\tClassifier mask = %x", QDF_MAC_ADDR_REF(peer_mac), mscs_params->classifier_type, tgt_peer->mscs_ipv4_parameter.user_priority_bitmap, tgt_peer->mscs_ipv4_parameter.user_priority_limit, tgt_peer->mscs_ipv4_parameter.classifier_mask); } status = QDF_STATUS_SUCCESS; fail: if (peer) dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } #endif /** * dp_get_sec_type() - Get the security type * @soc: soc handle * @vdev_id: id of dp handle * @peer_mac: mac of datapath PEER handle * @sec_idx: Security id (mcast, ucast) * * return sec_type: Security type */ static int dp_get_sec_type(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, uint8_t sec_idx) { int sec_type = 0; struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find((struct dp_soc *)soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_cdp_err("%pK: Peer is NULL!", (struct dp_soc *)soc); return sec_type; } if (!peer->txrx_peer) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); dp_peer_debug("%pK: txrx peer is NULL!", soc); return sec_type; } sec_type = peer->txrx_peer->security[sec_idx].sec_type; dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return sec_type; } /** * dp_peer_authorize() - authorize txrx peer * @soc_hdl: soc handle * @vdev_id: id of dp handle * @peer_mac: mac of datapath PEER handle * @authorize: * * Return: QDF_STATUS * */ static QDF_STATUS dp_peer_authorize(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint32_t authorize) { QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_cdp_debug("%pK: Peer is NULL!", soc); status = QDF_STATUS_E_FAILURE; } else { peer->authorize = authorize ? 1 : 0; if (peer->txrx_peer) peer->txrx_peer->authorize = peer->authorize; if (!peer->authorize) dp_peer_flush_frags(soc_hdl, vdev_id, peer_mac); dp_mlo_peer_authorize(soc, peer); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); } return status; } /** * dp_peer_get_authorize() - get peer authorize status * @soc_hdl: soc handle * @vdev_id: id of dp handle * @peer_mac: mac of datapath PEER handle * * Return: true is peer is authorized, false otherwise */ static bool dp_peer_get_authorize(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; bool authorize = false; struct dp_peer *peer = dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_cdp_debug("%pK: Peer is NULL!", soc); return authorize; } authorize = peer->authorize; dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return authorize; } void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev, enum dp_mod_id mod_id) { ol_txrx_vdev_delete_cb vdev_delete_cb = NULL; void *vdev_delete_context = NULL; ol_txrx_vdev_delete_cb vdev_del_notify = NULL; void *vdev_del_noitfy_ctx = NULL; uint8_t vdev_id = vdev->vdev_id; struct dp_pdev *pdev = vdev->pdev; struct dp_vdev *tmp_vdev = NULL; uint8_t found = 0; QDF_ASSERT(qdf_atomic_dec_return(&vdev->mod_refs[mod_id]) >= 0); /* Return if this is not the last reference*/ if (!qdf_atomic_dec_and_test(&vdev->ref_cnt)) return; /* * This should be set as last reference need to released * after cdp_vdev_detach() is called * * if this assert is hit there is a ref count issue */ QDF_ASSERT(vdev->delete.pending); vdev_delete_cb = vdev->delete.callback; vdev_delete_context = vdev->delete.context; vdev_del_notify = vdev->vdev_del_notify; vdev_del_noitfy_ctx = vdev->osif_vdev; dp_info("deleting vdev object %pK (" QDF_MAC_ADDR_FMT ")%s", vdev, QDF_MAC_ADDR_REF(vdev->mac_addr.raw), vdev_del_notify ? " with del_notify" : ""); if (wlan_op_mode_monitor == vdev->opmode) { dp_monitor_vdev_delete(soc, vdev); goto free_vdev; } /* all peers are gone, go ahead and delete it */ dp_tx_flow_pool_unmap_handler(pdev, vdev_id, FLOW_TYPE_VDEV, vdev_id); dp_tx_vdev_detach(vdev); dp_monitor_vdev_detach(vdev); free_vdev: qdf_spinlock_destroy(&vdev->peer_list_lock); qdf_spin_lock_bh(&soc->inactive_vdev_list_lock); TAILQ_FOREACH(tmp_vdev, &soc->inactive_vdev_list, inactive_list_elem) { if (tmp_vdev == vdev) { found = 1; break; } } if (found) TAILQ_REMOVE(&soc->inactive_vdev_list, vdev, inactive_list_elem); /* delete this peer from the list */ qdf_spin_unlock_bh(&soc->inactive_vdev_list_lock); dp_cfg_event_record_vdev_evt(soc, DP_CFG_EVENT_VDEV_UNREF_DEL, vdev); wlan_minidump_remove(vdev, sizeof(*vdev), soc->ctrl_psoc, WLAN_MD_DP_VDEV, "dp_vdev"); qdf_mem_free(vdev); vdev = NULL; if (vdev_delete_cb) vdev_delete_cb(vdev_delete_context); if (vdev_del_notify) vdev_del_notify(vdev_del_noitfy_ctx); } qdf_export_symbol(dp_vdev_unref_delete); void dp_peer_unref_delete(struct dp_peer *peer, enum dp_mod_id mod_id) { struct dp_vdev *vdev = peer->vdev; struct dp_pdev *pdev = vdev->pdev; struct dp_soc *soc = pdev->soc; uint16_t peer_id; struct dp_peer *tmp_peer; bool found = false; if (mod_id > DP_MOD_ID_RX) QDF_ASSERT(qdf_atomic_dec_return(&peer->mod_refs[mod_id]) >= 0); /* * Hold the lock all the way from checking if the peer ref count * is zero until the peer references are removed from the hash * table and vdev list (if the peer ref count is zero). * This protects against a new HL tx operation starting to use the * peer object just after this function concludes it's done being used. * Furthermore, the lock needs to be held while checking whether the * vdev's list of peers is empty, to make sure that list is not modified * concurrently with the empty check. */ if (qdf_atomic_dec_and_test(&peer->ref_cnt)) { peer_id = peer->peer_id; /* * Make sure that the reference to the peer in * peer object map is removed */ QDF_ASSERT(peer_id == HTT_INVALID_PEER); dp_peer_info("Deleting peer %pK ("QDF_MAC_ADDR_FMT")", peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); dp_peer_sawf_ctx_free(soc, peer); wlan_minidump_remove(peer, sizeof(*peer), soc->ctrl_psoc, WLAN_MD_DP_PEER, "dp_peer"); qdf_spin_lock_bh(&soc->inactive_peer_list_lock); TAILQ_FOREACH(tmp_peer, &soc->inactive_peer_list, inactive_list_elem) { if (tmp_peer == peer) { found = 1; break; } } if (found) TAILQ_REMOVE(&soc->inactive_peer_list, peer, inactive_list_elem); /* delete this peer from the list */ qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); DP_AST_ASSERT(TAILQ_EMPTY(&peer->ast_entry_list)); dp_peer_update_state(soc, peer, DP_PEER_STATE_FREED); /* cleanup the peer data */ dp_peer_cleanup(vdev, peer); dp_monitor_peer_detach(soc, peer); qdf_spinlock_destroy(&peer->peer_state_lock); dp_txrx_peer_detach(soc, peer); dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_UNREF_DEL, peer, vdev, 0); qdf_mem_free(peer); /* * Decrement ref count taken at peer create */ dp_peer_info("Deleted peer. Unref vdev %pK, vdev_ref_cnt %d", vdev, qdf_atomic_read(&vdev->ref_cnt)); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CHILD); } } qdf_export_symbol(dp_peer_unref_delete); void dp_txrx_peer_unref_delete(dp_txrx_ref_handle handle, enum dp_mod_id mod_id) { dp_peer_unref_delete((struct dp_peer *)handle, mod_id); } qdf_export_symbol(dp_txrx_peer_unref_delete); /** * dp_peer_delete_wifi3() - Delete txrx peer * @soc_hdl: soc handle * @vdev_id: id of dp handle * @peer_mac: mac of datapath PEER handle * @bitmap: bitmap indicating special handling of request. * @peer_type: peer type (link or MLD) * */ static QDF_STATUS dp_peer_delete_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint32_t bitmap, enum cdp_peer_type peer_type) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_peer *peer; struct cdp_peer_info peer_info = { 0 }; struct dp_vdev *vdev = NULL; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, peer_type); peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CDP); /* Peer can be null for monitor vap mac address */ if (!peer) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, "%s: Invalid peer\n", __func__); return QDF_STATUS_E_FAILURE; } if (!peer->valid) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); dp_err("Invalid peer: "QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(peer_mac)); return QDF_STATUS_E_ALREADY; } vdev = peer->vdev; if (!vdev) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } peer->valid = 0; dp_cfg_event_record_peer_evt(soc, DP_CFG_EVENT_PEER_DELETE, peer, vdev, 0); dp_init_info("%pK: peer %pK (" QDF_MAC_ADDR_FMT ") pending-refs %d", soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), qdf_atomic_read(&peer->ref_cnt)); dp_peer_rx_reo_shared_qaddr_delete(soc, peer); dp_local_peer_id_free(peer->vdev->pdev, peer); /* Drop all rx packets before deleting peer */ dp_clear_peer_internal(soc, peer); qdf_spinlock_destroy(&peer->peer_info_lock); dp_peer_multipass_list_remove(peer); /* remove the reference to the peer from the hash table */ dp_peer_find_hash_remove(soc, peer); dp_peer_vdev_list_remove(soc, vdev, peer); dp_peer_mlo_delete(peer); qdf_spin_lock_bh(&soc->inactive_peer_list_lock); TAILQ_INSERT_TAIL(&soc->inactive_peer_list, peer, inactive_list_elem); qdf_spin_unlock_bh(&soc->inactive_peer_list_lock); /* * Remove the reference added during peer_attach. * The peer will still be left allocated until the * PEER_UNMAP message arrives to remove the other * reference, added by the PEER_MAP message. */ dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); /* * Remove the reference taken above */ dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #ifdef DP_RX_UDP_OVER_PEER_ROAM static QDF_STATUS dp_update_roaming_peer_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, uint32_t auth_status) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; vdev->roaming_peer_status = auth_status; qdf_mem_copy(vdev->roaming_peer_mac.raw, peer_mac, QDF_MAC_ADDR_SIZE); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #endif /** * dp_get_vdev_mac_addr_wifi3() - Detach txrx peer * @soc_hdl: Datapath soc handle * @vdev_id: virtual interface id * * Return: MAC address on success, NULL on failure. * */ static uint8_t *dp_get_vdev_mac_addr_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); uint8_t *mac = NULL; if (!vdev) return NULL; mac = vdev->mac_addr.raw; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return mac; } /** * dp_vdev_set_wds() - Enable per packet stats * @soc_hdl: DP soc handle * @vdev_id: id of DP VDEV handle * @val: value * * Return: none */ static int dp_vdev_set_wds(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint32_t val) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id((struct dp_soc *)soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; vdev->wds_enabled = val; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } static int dp_get_opmode(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); int opmode; if (!vdev) { dp_err_rl("vdev for id %d is NULL", vdev_id); return -EINVAL; } opmode = vdev->opmode; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return opmode; } /** * dp_get_os_rx_handles_from_vdev_wifi3() - Get os rx handles for a vdev * @soc_hdl: ol_txrx_soc_handle handle * @vdev_id: vdev id for which os rx handles are needed * @stack_fn_p: pointer to stack function pointer * @osif_vdev_p: pointer to ol_osif_vdev_handle * * Return: void */ static void dp_get_os_rx_handles_from_vdev_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, ol_txrx_rx_fp *stack_fn_p, ol_osif_vdev_handle *osif_vdev_p) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (qdf_unlikely(!vdev)) { *stack_fn_p = NULL; *osif_vdev_p = NULL; return; } *stack_fn_p = vdev->osif_rx_stack; *osif_vdev_p = vdev->osif_vdev; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } /** * dp_get_ctrl_pdev_from_vdev_wifi3() - Get control pdev of vdev * @soc_hdl: datapath soc handle * @vdev_id: virtual device/interface id * * Return: Handle to control pdev */ static struct cdp_cfg *dp_get_ctrl_pdev_from_vdev_wifi3( struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); struct dp_pdev *pdev; if (!vdev) return NULL; pdev = vdev->pdev; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return pdev ? (struct cdp_cfg *)pdev->wlan_cfg_ctx : NULL; } int32_t dp_get_tx_pending(struct cdp_pdev *pdev_handle) { struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle; return qdf_atomic_read(&pdev->num_tx_outstanding); } /** * dp_get_peer_mac_from_peer_id() - get peer mac * @soc: CDP SoC handle * @peer_id: Peer ID * @peer_mac: MAC addr of PEER * * Return: QDF_STATUS */ static QDF_STATUS dp_get_peer_mac_from_peer_id(struct cdp_soc_t *soc, uint32_t peer_id, uint8_t *peer_mac) { struct dp_peer *peer; if (soc && peer_mac) { peer = dp_peer_get_ref_by_id((struct dp_soc *)soc, (uint16_t)peer_id, DP_MOD_ID_CDP); if (peer) { qdf_mem_copy(peer_mac, peer->mac_addr.raw, QDF_MAC_ADDR_SIZE); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } } return QDF_STATUS_E_FAILURE; } #ifdef MESH_MODE_SUPPORT static void dp_vdev_set_mesh_mode(struct cdp_vdev *vdev_hdl, uint32_t val) { struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); vdev->mesh_vdev = val; if (val) vdev->skip_sw_tid_classification |= DP_TX_MESH_ENABLED; else vdev->skip_sw_tid_classification &= ~DP_TX_MESH_ENABLED; } /** * dp_vdev_set_mesh_rx_filter() - to set the mesh rx filter * @vdev_hdl: virtual device object * @val: value to be set * * Return: void */ static void dp_vdev_set_mesh_rx_filter(struct cdp_vdev *vdev_hdl, uint32_t val) { struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); vdev->mesh_rx_filter = val; } #endif /** * dp_vdev_set_hlos_tid_override() - to set hlos tid override * @vdev: virtual device object * @val: value to be set * * Return: void */ static void dp_vdev_set_hlos_tid_override(struct dp_vdev *vdev, uint32_t val) { dp_cdp_info("%pK: val %d", vdev->pdev->soc, val); if (val) vdev->skip_sw_tid_classification |= DP_TXRX_HLOS_TID_OVERRIDE_ENABLED; else vdev->skip_sw_tid_classification &= ~DP_TXRX_HLOS_TID_OVERRIDE_ENABLED; } /** * dp_vdev_get_hlos_tid_override() - to get hlos tid override flag * @vdev_hdl: virtual device object * * Return: 1 if this flag is set */ static uint8_t dp_vdev_get_hlos_tid_override(struct cdp_vdev *vdev_hdl) { struct dp_vdev *vdev = (struct dp_vdev *)vdev_hdl; return !!(vdev->skip_sw_tid_classification & DP_TXRX_HLOS_TID_OVERRIDE_ENABLED); } #ifdef VDEV_PEER_PROTOCOL_COUNT static void dp_enable_vdev_peer_protocol_count(struct cdp_soc_t *soc_hdl, int8_t vdev_id, bool enable) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return; dp_info("enable %d vdev_id %d", enable, vdev_id); vdev->peer_protocol_count_track = enable; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } static void dp_enable_vdev_peer_protocol_drop_mask(struct cdp_soc_t *soc_hdl, int8_t vdev_id, int drop_mask) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return; dp_info("drop_mask %d vdev_id %d", drop_mask, vdev_id); vdev->peer_protocol_count_dropmask = drop_mask; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } static int dp_is_vdev_peer_protocol_count_enabled(struct cdp_soc_t *soc_hdl, int8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev; int peer_protocol_count_track; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return 0; dp_info("enable %d vdev_id %d", vdev->peer_protocol_count_track, vdev_id); peer_protocol_count_track = vdev->peer_protocol_count_track; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return peer_protocol_count_track; } static int dp_get_vdev_peer_protocol_drop_mask(struct cdp_soc_t *soc_hdl, int8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev; int peer_protocol_count_dropmask; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return 0; dp_info("drop_mask %d vdev_id %d", vdev->peer_protocol_count_dropmask, vdev_id); peer_protocol_count_dropmask = vdev->peer_protocol_count_dropmask; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return peer_protocol_count_dropmask; } #endif bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data) { uint8_t pdev_count; for (pdev_count = 0; pdev_count < MAX_PDEV_CNT; pdev_count++) { if (soc->pdev_list[pdev_count] && soc->pdev_list[pdev_count] == data) return true; } return false; } void dp_aggregate_vdev_stats(struct dp_vdev *vdev, struct cdp_vdev_stats *vdev_stats, enum dp_pkt_xmit_type xmit_type) { if (!vdev || !vdev->pdev) return; dp_update_vdev_ingress_stats(vdev); dp_copy_vdev_stats_to_tgt_buf(vdev_stats, &vdev->stats, xmit_type); dp_vdev_iterate_peer(vdev, dp_update_vdev_stats, vdev_stats, DP_MOD_ID_GENERIC_STATS); dp_update_vdev_rate_stats(vdev_stats, &vdev->stats); #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, vdev->pdev->soc, vdev_stats, vdev->vdev_id, UPDATE_VDEV_STATS, vdev->pdev->pdev_id); #endif } void dp_aggregate_pdev_stats(struct dp_pdev *pdev) { struct dp_vdev *vdev = NULL; struct dp_soc *soc; struct cdp_vdev_stats *vdev_stats = qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); if (!vdev_stats) { dp_cdp_err("%pK: DP alloc failure - unable to get alloc vdev stats", pdev->soc); return; } soc = pdev->soc; qdf_mem_zero(&pdev->stats.tx, sizeof(pdev->stats.tx)); qdf_mem_zero(&pdev->stats.rx, sizeof(pdev->stats.rx)); qdf_mem_zero(&pdev->stats.tx_i, sizeof(pdev->stats.tx_i)); qdf_mem_zero(&pdev->stats.rx_i, sizeof(pdev->stats.rx_i)); if (dp_monitor_is_enable_mcopy_mode(pdev)) dp_monitor_invalid_peer_update_pdev_stats(soc, pdev); qdf_spin_lock_bh(&pdev->vdev_list_lock); TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { dp_aggregate_vdev_stats(vdev, vdev_stats, DP_XMIT_TOTAL); dp_update_pdev_stats(pdev, vdev_stats); dp_update_pdev_ingress_stats(pdev, vdev); } qdf_spin_unlock_bh(&pdev->vdev_list_lock); qdf_mem_free(vdev_stats); #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc, &pdev->stats, pdev->pdev_id, UPDATE_PDEV_STATS, pdev->pdev_id); #endif } /** * dp_vdev_getstats() - get vdev packet level stats * @vdev_handle: Datapath VDEV handle * @stats: cdp network device stats structure * * Return: QDF_STATUS */ static QDF_STATUS dp_vdev_getstats(struct cdp_vdev *vdev_handle, struct cdp_dev_stats *stats) { struct dp_vdev *vdev = (struct dp_vdev *)vdev_handle; struct dp_pdev *pdev; struct dp_soc *soc; struct cdp_vdev_stats *vdev_stats; if (!vdev) return QDF_STATUS_E_FAILURE; pdev = vdev->pdev; if (!pdev) return QDF_STATUS_E_FAILURE; soc = pdev->soc; vdev_stats = qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); if (!vdev_stats) { dp_err("%pK: DP alloc failure - unable to get alloc vdev stats", soc); return QDF_STATUS_E_FAILURE; } dp_aggregate_vdev_stats(vdev, vdev_stats, DP_XMIT_LINK); stats->tx_packets = vdev_stats->tx.comp_pkt.num; stats->tx_bytes = vdev_stats->tx.comp_pkt.bytes; stats->tx_errors = vdev_stats->tx.tx_failed; stats->tx_dropped = vdev_stats->tx_i.dropped.dropped_pkt.num + vdev_stats->tx_i.sg.dropped_host.num + vdev_stats->tx_i.mcast_en.dropped_map_error + vdev_stats->tx_i.mcast_en.dropped_self_mac + vdev_stats->tx_i.mcast_en.dropped_send_fail + vdev_stats->tx.nawds_mcast_drop; if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { stats->rx_packets = vdev_stats->rx.to_stack.num; stats->rx_bytes = vdev_stats->rx.to_stack.bytes; } else { stats->rx_packets = vdev_stats->rx_i.reo_rcvd_pkt.num + vdev_stats->rx_i.null_q_desc_pkt.num + vdev_stats->rx_i.routed_eapol_pkt.num; stats->rx_bytes = vdev_stats->rx_i.reo_rcvd_pkt.bytes + vdev_stats->rx_i.null_q_desc_pkt.bytes + vdev_stats->rx_i.routed_eapol_pkt.bytes; } stats->rx_errors = vdev_stats->rx.err.mic_err + vdev_stats->rx.err.decrypt_err + vdev_stats->rx.err.fcserr + vdev_stats->rx.err.pn_err + vdev_stats->rx.err.oor_err + vdev_stats->rx.err.jump_2k_err + vdev_stats->rx.err.rxdma_wifi_parse_err; stats->rx_dropped = vdev_stats->rx.mec_drop.num + vdev_stats->rx.multipass_rx_pkt_drop + vdev_stats->rx.peer_unauth_rx_pkt_drop + vdev_stats->rx.policy_check_drop + vdev_stats->rx.nawds_mcast_drop + vdev_stats->rx.mcast_3addr_drop + vdev_stats->rx.ppeds_drop.num; qdf_mem_free(vdev_stats); return QDF_STATUS_SUCCESS; } /** * dp_pdev_getstats() - get pdev packet level stats * @pdev_handle: Datapath PDEV handle * @stats: cdp network device stats structure * * Return: QDF_STATUS */ static void dp_pdev_getstats(struct cdp_pdev *pdev_handle, struct cdp_dev_stats *stats) { struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle; dp_aggregate_pdev_stats(pdev); stats->tx_packets = pdev->stats.tx.comp_pkt.num; stats->tx_bytes = pdev->stats.tx.comp_pkt.bytes; stats->tx_errors = pdev->stats.tx.tx_failed; stats->tx_dropped = pdev->stats.tx_i.dropped.dropped_pkt.num + pdev->stats.tx_i.sg.dropped_host.num + pdev->stats.tx_i.mcast_en.dropped_map_error + pdev->stats.tx_i.mcast_en.dropped_self_mac + pdev->stats.tx_i.mcast_en.dropped_send_fail + pdev->stats.tx.nawds_mcast_drop + pdev->stats.tso_stats.dropped_host.num; if (!wlan_cfg_get_vdev_stats_hw_offload_config(pdev->soc->wlan_cfg_ctx)) { stats->rx_packets = pdev->stats.rx.to_stack.num; stats->rx_bytes = pdev->stats.rx.to_stack.bytes; } else { stats->rx_packets = pdev->stats.rx_i.reo_rcvd_pkt.num + pdev->stats.rx_i.null_q_desc_pkt.num + pdev->stats.rx_i.routed_eapol_pkt.num; stats->rx_bytes = pdev->stats.rx_i.reo_rcvd_pkt.bytes + pdev->stats.rx_i.null_q_desc_pkt.bytes + pdev->stats.rx_i.routed_eapol_pkt.bytes; } stats->rx_errors = pdev->stats.err.ip_csum_err + pdev->stats.err.tcp_udp_csum_err + pdev->stats.rx.err.mic_err + pdev->stats.rx.err.decrypt_err + pdev->stats.rx.err.fcserr + pdev->stats.rx.err.pn_err + pdev->stats.rx.err.oor_err + pdev->stats.rx.err.jump_2k_err + pdev->stats.rx.err.rxdma_wifi_parse_err; stats->rx_dropped = pdev->stats.dropped.msdu_not_done + pdev->stats.dropped.mec + pdev->stats.dropped.mesh_filter + pdev->stats.dropped.wifi_parse + pdev->stats.dropped.mon_rx_drop + pdev->stats.dropped.mon_radiotap_update_err + pdev->stats.rx.mec_drop.num + pdev->stats.rx.ppeds_drop.num + pdev->stats.rx.multipass_rx_pkt_drop + pdev->stats.rx.peer_unauth_rx_pkt_drop + pdev->stats.rx.policy_check_drop + pdev->stats.rx.nawds_mcast_drop + pdev->stats.rx.mcast_3addr_drop; } /** * dp_get_device_stats() - get interface level packet stats * @soc_hdl: soc handle * @id: vdev_id or pdev_id based on type * @stats: cdp network device stats structure * @type: device type pdev/vdev * * Return: QDF_STATUS */ static QDF_STATUS dp_get_device_stats(struct cdp_soc_t *soc_hdl, uint8_t id, struct cdp_dev_stats *stats, uint8_t type) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); QDF_STATUS status = QDF_STATUS_E_FAILURE; struct dp_vdev *vdev; switch (type) { case UPDATE_VDEV_STATS: vdev = dp_vdev_get_ref_by_id(soc, id, DP_MOD_ID_CDP); if (vdev) { status = dp_vdev_getstats((struct cdp_vdev *)vdev, stats); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } return status; case UPDATE_PDEV_STATS: { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3( (struct dp_soc *)soc, id); if (pdev) { dp_pdev_getstats((struct cdp_pdev *)pdev, stats); return QDF_STATUS_SUCCESS; } } break; default: QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "apstats cannot be updated for this input " "type %d", type); break; } return QDF_STATUS_E_FAILURE; } const char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type) { switch (ring_type) { case REO_DST: return "Reo_dst"; case REO_EXCEPTION: return "Reo_exception"; case REO_CMD: return "Reo_cmd"; case REO_REINJECT: return "Reo_reinject"; case REO_STATUS: return "Reo_status"; case WBM2SW_RELEASE: return "wbm2sw_release"; case TCL_DATA: return "tcl_data"; case TCL_CMD_CREDIT: return "tcl_cmd_credit"; case TCL_STATUS: return "tcl_status"; case SW2WBM_RELEASE: return "sw2wbm_release"; case RXDMA_BUF: return "Rxdma_buf"; case RXDMA_DST: return "Rxdma_dst"; case RXDMA_MONITOR_BUF: return "Rxdma_monitor_buf"; case RXDMA_MONITOR_DESC: return "Rxdma_monitor_desc"; case RXDMA_MONITOR_STATUS: return "Rxdma_monitor_status"; case RXDMA_MONITOR_DST: return "Rxdma_monitor_destination"; case WBM_IDLE_LINK: return "WBM_hw_idle_link"; case PPE2TCL: return "PPE2TCL"; case REO2PPE: return "REO2PPE"; case TX_MONITOR_DST: return "tx_monitor_destination"; case TX_MONITOR_BUF: return "tx_monitor_buf"; default: dp_err("Invalid ring type: %u", ring_type); break; } return "Invalid"; } void dp_print_napi_stats(struct dp_soc *soc) { hif_print_napi_stats(soc->hif_handle); } /** * dp_txrx_host_peer_stats_clr() - Reinitialize the txrx peer stats * @soc: Datapath soc * @peer: Datatpath peer * @arg: argument to iter function * * Return: QDF_STATUS */ static inline void dp_txrx_host_peer_stats_clr(struct dp_soc *soc, struct dp_peer *peer, void *arg) { struct dp_txrx_peer *txrx_peer = NULL; struct dp_peer *tgt_peer = NULL; struct cdp_interface_peer_stats peer_stats_intf = {0}; peer_stats_intf.rx_avg_snr = CDP_INVALID_SNR; DP_STATS_CLR(peer); /* Clear monitor peer stats */ dp_monitor_peer_reset_stats(soc, peer); /* Clear MLD peer stats only when link peer is primary */ if (dp_peer_is_primary_link_peer(peer)) { tgt_peer = dp_get_tgt_peer_from_peer(peer); if (tgt_peer) { DP_STATS_CLR(tgt_peer); txrx_peer = tgt_peer->txrx_peer; dp_txrx_peer_stats_clr(txrx_peer); } } #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, peer->vdev->pdev->soc, &peer_stats_intf, peer->peer_id, UPDATE_PEER_STATS, peer->vdev->pdev->pdev_id); #endif } #ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING static inline void dp_srng_clear_ring_usage_wm_stats(struct dp_soc *soc) { int ring; for (ring = 0; ring < soc->num_reo_dest_rings; ring++) hal_srng_clear_ring_usage_wm_locked(soc->hal_soc, soc->reo_dest_ring[ring].hal_srng); for (ring = 0; ring < soc->num_tcl_data_rings; ring++) { if (wlan_cfg_get_wbm_ring_num_for_index( soc->wlan_cfg_ctx, ring) == INVALID_WBM_RING_NUM) continue; hal_srng_clear_ring_usage_wm_locked(soc->hal_soc, soc->tx_comp_ring[ring].hal_srng); } } #else static inline void dp_srng_clear_ring_usage_wm_stats(struct dp_soc *soc) { } #endif #ifdef WLAN_SUPPORT_PPEDS static void dp_clear_tx_ppeds_stats(struct dp_soc *soc) { if (soc->arch_ops.dp_ppeds_clear_stats) soc->arch_ops.dp_ppeds_clear_stats(soc); } static void dp_ppeds_clear_ring_util_stats(struct dp_soc *soc) { if (soc->arch_ops.dp_txrx_ppeds_clear_rings_stats) soc->arch_ops.dp_txrx_ppeds_clear_rings_stats(soc); } #else static void dp_clear_tx_ppeds_stats(struct dp_soc *soc) { } static void dp_ppeds_clear_ring_util_stats(struct dp_soc *soc) { } #endif /** * dp_txrx_host_stats_clr() - Reinitialize the txrx stats * @vdev: DP_VDEV handle * @soc: DP_SOC handle * * Return: QDF_STATUS */ static inline QDF_STATUS dp_txrx_host_stats_clr(struct dp_vdev *vdev, struct dp_soc *soc) { struct dp_vdev *var_vdev = NULL; if (!vdev || !vdev->pdev) return QDF_STATUS_E_FAILURE; /* * if NSS offload is enabled, then send message * to NSS FW to clear the stats. Once NSS FW clears the statistics * then clear host statistics. */ if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { if (soc->cdp_soc.ol_ops->nss_stats_clr) soc->cdp_soc.ol_ops->nss_stats_clr(soc->ctrl_psoc, vdev->vdev_id); } dp_vdev_stats_hw_offload_target_clear(soc, vdev->pdev->pdev_id, (1 << vdev->vdev_id)); DP_STATS_CLR(vdev->pdev); DP_STATS_CLR(vdev->pdev->soc); dp_clear_tx_ppeds_stats(soc); dp_ppeds_clear_ring_util_stats(soc); hif_clear_napi_stats(vdev->pdev->soc->hif_handle); TAILQ_FOREACH(var_vdev, &vdev->pdev->vdev_list, vdev_list_elem) { DP_STATS_CLR(var_vdev); dp_vdev_iterate_peer(var_vdev, dp_txrx_host_peer_stats_clr, NULL, DP_MOD_ID_GENERIC_STATS); } dp_srng_clear_ring_usage_wm_stats(soc); #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, vdev->pdev->soc, &vdev->stats, vdev->vdev_id, UPDATE_VDEV_STATS, vdev->pdev->pdev_id); #endif return QDF_STATUS_SUCCESS; } /** * dp_get_peer_calibr_stats()- Get peer calibrated stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * * Return: none */ static inline void dp_get_peer_calibr_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_peer *tgt_peer; tgt_peer = dp_get_tgt_peer_from_peer(peer); if (!tgt_peer) return; peer_stats->tx.last_per = tgt_peer->stats.tx.last_per; peer_stats->tx.tx_bytes_success_last = tgt_peer->stats.tx.tx_bytes_success_last; peer_stats->tx.tx_data_success_last = tgt_peer->stats.tx.tx_data_success_last; peer_stats->tx.tx_byte_rate = tgt_peer->stats.tx.tx_byte_rate; peer_stats->tx.tx_data_rate = tgt_peer->stats.tx.tx_data_rate; peer_stats->tx.tx_data_ucast_last = tgt_peer->stats.tx.tx_data_ucast_last; peer_stats->tx.tx_data_ucast_rate = tgt_peer->stats.tx.tx_data_ucast_rate; peer_stats->tx.inactive_time = tgt_peer->stats.tx.inactive_time; peer_stats->rx.rx_bytes_success_last = tgt_peer->stats.rx.rx_bytes_success_last; peer_stats->rx.rx_data_success_last = tgt_peer->stats.rx.rx_data_success_last; peer_stats->rx.rx_byte_rate = tgt_peer->stats.rx.rx_byte_rate; peer_stats->rx.rx_data_rate = tgt_peer->stats.rx.rx_data_rate; } /** * dp_get_peer_basic_stats()- Get peer basic stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * * Return: none */ static inline void dp_get_peer_basic_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_txrx_peer *txrx_peer; txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) return; peer_stats->tx.comp_pkt.num += txrx_peer->comp_pkt.num; peer_stats->tx.comp_pkt.bytes += txrx_peer->comp_pkt.bytes; peer_stats->tx.tx_failed += txrx_peer->tx_failed; peer_stats->rx.to_stack.num += txrx_peer->to_stack.num; peer_stats->rx.to_stack.bytes += txrx_peer->to_stack.bytes; } #ifdef QCA_ENHANCED_STATS_SUPPORT /** * dp_get_peer_per_pkt_stats()- Get peer per pkt stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * * Return: none */ static inline void dp_get_peer_per_pkt_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_txrx_peer *txrx_peer; struct dp_peer_per_pkt_stats *per_pkt_stats; uint8_t inx = 0, link_id = 0; struct dp_pdev *pdev; struct dp_soc *soc; uint8_t stats_arr_size; txrx_peer = dp_get_txrx_peer(peer); pdev = peer->vdev->pdev; if (!txrx_peer) return; if (!IS_MLO_DP_LINK_PEER(peer)) { stats_arr_size = txrx_peer->stats_arr_size; for (inx = 0; inx < stats_arr_size; inx++) { per_pkt_stats = &txrx_peer->stats[inx].per_pkt_stats; DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); } } else { soc = pdev->soc; link_id = dp_get_peer_hw_link_id(soc, pdev); per_pkt_stats = &txrx_peer->stats[link_id].per_pkt_stats; DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); } } #ifdef WLAN_FEATURE_11BE_MLO /** * dp_get_peer_extd_stats()- Get peer extd stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * * Return: none */ static inline void dp_get_peer_extd_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_soc *soc = peer->vdev->pdev->soc; if (IS_MLO_DP_MLD_PEER(peer)) { uint8_t i; struct dp_peer *link_peer; struct dp_soc *link_peer_soc; struct dp_mld_link_peers link_peers_info; dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_CDP); for (i = 0; i < link_peers_info.num_links; i++) { link_peer = link_peers_info.link_peers[i]; link_peer_soc = link_peer->vdev->pdev->soc; dp_monitor_peer_get_stats(link_peer_soc, link_peer, peer_stats, UPDATE_PEER_STATS); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); } else { dp_monitor_peer_get_stats(soc, peer, peer_stats, UPDATE_PEER_STATS); } } #else static inline void dp_get_peer_extd_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_soc *soc = peer->vdev->pdev->soc; dp_monitor_peer_get_stats(soc, peer, peer_stats, UPDATE_PEER_STATS); } #endif #else #if defined WLAN_FEATURE_11BE_MLO && defined DP_MLO_LINK_STATS_SUPPORT static inline void dp_get_peer_per_pkt_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { uint8_t i, index; struct dp_mld_link_peers link_peers_info; struct dp_txrx_peer *txrx_peer; struct dp_peer_per_pkt_stats *per_pkt_stats; struct dp_soc *soc = peer->vdev->pdev->soc; txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) return; if (IS_MLO_DP_MLD_PEER(peer)) { dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_GENERIC_STATS); for (i = 0; i < link_peers_info.num_links; i++) { if (i > txrx_peer->stats_arr_size) break; per_pkt_stats = &txrx_peer->stats[i].per_pkt_stats; DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_GENERIC_STATS); } else { index = dp_get_peer_link_id(peer); per_pkt_stats = &txrx_peer->stats[index].per_pkt_stats; DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); qdf_mem_copy(&peer_stats->mac_addr, &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE); } } static inline void dp_get_peer_extd_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { uint8_t i, index; struct dp_mld_link_peers link_peers_info; struct dp_txrx_peer *txrx_peer; struct dp_peer_extd_stats *extd_stats; struct dp_soc *soc = peer->vdev->pdev->soc; txrx_peer = dp_get_txrx_peer(peer); if (qdf_unlikely(!txrx_peer)) { dp_err_rl("txrx_peer NULL for peer MAC: " QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); return; } if (IS_MLO_DP_MLD_PEER(peer)) { dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_GENERIC_STATS); for (i = 0; i < link_peers_info.num_links; i++) { if (i > txrx_peer->stats_arr_size) break; extd_stats = &txrx_peer->stats[i].extd_stats; /* Return aggregated stats for MLD peer */ DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_GENERIC_STATS); } else { index = dp_get_peer_link_id(peer); extd_stats = &txrx_peer->stats[index].extd_stats; DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); qdf_mem_copy(&peer_stats->mac_addr, &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE); } } #else static inline void dp_get_peer_per_pkt_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_txrx_peer *txrx_peer; struct dp_peer_per_pkt_stats *per_pkt_stats; txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) return; per_pkt_stats = &txrx_peer->stats[0].per_pkt_stats; DP_UPDATE_PER_PKT_STATS(peer_stats, per_pkt_stats); } static inline void dp_get_peer_extd_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { struct dp_txrx_peer *txrx_peer; struct dp_peer_extd_stats *extd_stats; txrx_peer = dp_get_txrx_peer(peer); if (qdf_unlikely(!txrx_peer)) { dp_err_rl("txrx_peer NULL"); return; } extd_stats = &txrx_peer->stats[0].extd_stats; DP_UPDATE_EXTD_STATS(peer_stats, extd_stats); } #endif #endif /** * dp_get_peer_tx_per()- Get peer packet error ratio * @peer_stats: buffer for peer stats * * Return: none */ static inline void dp_get_peer_tx_per(struct cdp_peer_stats *peer_stats) { if (peer_stats->tx.tx_success.num + peer_stats->tx.retries > 0) peer_stats->tx.per = qdf_do_div((peer_stats->tx.retries * 100), (peer_stats->tx.tx_success.num + peer_stats->tx.retries)); else peer_stats->tx.per = 0; } void dp_get_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats) { dp_get_peer_calibr_stats(peer, peer_stats); dp_get_peer_basic_stats(peer, peer_stats); dp_get_peer_per_pkt_stats(peer, peer_stats); dp_get_peer_extd_stats(peer, peer_stats); dp_get_peer_tx_per(peer_stats); } /** * dp_get_host_peer_stats()- function to print peer stats * @soc: dp_soc handle * @mac_addr: mac address of the peer * * Return: QDF_STATUS */ static QDF_STATUS dp_get_host_peer_stats(struct cdp_soc_t *soc, uint8_t *mac_addr) { struct dp_peer *peer = NULL; struct cdp_peer_stats *peer_stats = NULL; struct cdp_peer_info peer_info = { 0 }; if (!mac_addr) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "%s: NULL peer mac addr\n", __func__); return QDF_STATUS_E_FAILURE; } DP_PEER_INFO_PARAMS_INIT(&peer_info, DP_VDEV_ALL, mac_addr, false, CDP_WILD_PEER_TYPE); peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, DP_MOD_ID_CDP); if (!peer) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "%s: Invalid peer\n", __func__); return QDF_STATUS_E_FAILURE; } peer_stats = qdf_mem_malloc(sizeof(struct cdp_peer_stats)); if (!peer_stats) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "%s: Memory allocation failed for cdp_peer_stats\n", __func__); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_E_NOMEM; } qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); dp_get_peer_stats(peer, peer_stats); dp_print_peer_stats(peer, peer_stats); dp_peer_rxtid_stats(dp_get_tgt_peer_from_peer(peer), dp_rx_tid_stats_cb, NULL); qdf_mem_free(peer_stats); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_txrx_stats_help() - Helper function for Txrx_Stats * * Return: None */ static void dp_txrx_stats_help(void) { dp_info("Command: iwpriv wlan0 txrx_stats "); dp_info("stats_option:"); dp_info(" 1 -- HTT Tx Statistics"); dp_info(" 2 -- HTT Rx Statistics"); dp_info(" 3 -- HTT Tx HW Queue Statistics"); dp_info(" 4 -- HTT Tx HW Sched Statistics"); dp_info(" 5 -- HTT Error Statistics"); dp_info(" 6 -- HTT TQM Statistics"); dp_info(" 7 -- HTT TQM CMDQ Statistics"); dp_info(" 8 -- HTT TX_DE_CMN Statistics"); dp_info(" 9 -- HTT Tx Rate Statistics"); dp_info(" 10 -- HTT Rx Rate Statistics"); dp_info(" 11 -- HTT Peer Statistics"); dp_info(" 12 -- HTT Tx SelfGen Statistics"); dp_info(" 13 -- HTT Tx MU HWQ Statistics"); dp_info(" 14 -- HTT RING_IF_INFO Statistics"); dp_info(" 15 -- HTT SRNG Statistics"); dp_info(" 16 -- HTT SFM Info Statistics"); dp_info(" 17 -- HTT PDEV_TX_MU_MIMO_SCHED INFO Statistics"); dp_info(" 18 -- HTT Peer List Details"); dp_info(" 20 -- Clear Host Statistics"); dp_info(" 21 -- Host Rx Rate Statistics"); dp_info(" 22 -- Host Tx Rate Statistics"); dp_info(" 23 -- Host Tx Statistics"); dp_info(" 24 -- Host Rx Statistics"); dp_info(" 25 -- Host AST Statistics"); dp_info(" 26 -- Host SRNG PTR Statistics"); dp_info(" 27 -- Host Mon Statistics"); dp_info(" 28 -- Host REO Queue Statistics"); dp_info(" 29 -- Host Soc cfg param Statistics"); dp_info(" 30 -- Host pdev cfg param Statistics"); dp_info(" 31 -- Host NAPI stats"); dp_info(" 32 -- Host Interrupt stats"); dp_info(" 33 -- Host FISA stats"); dp_info(" 34 -- Host Register Work stats"); dp_info(" 35 -- HW REO Queue stats"); dp_info(" 36 -- Host WBM IDLE link desc ring HP/TP"); dp_info(" 37 -- Host SRNG usage watermark stats"); } #ifdef DP_UMAC_HW_RESET_SUPPORT /** * dp_umac_rst_skel_enable_update() - Update skel dbg flag for umac reset * @soc: dp soc handle * @en: ebable/disable * * Return: void */ static void dp_umac_rst_skel_enable_update(struct dp_soc *soc, bool en) { soc->umac_reset_ctx.skel_enable = en; dp_cdp_debug("UMAC HW reset debug skeleton code enabled :%u", soc->umac_reset_ctx.skel_enable); } /** * dp_umac_rst_skel_enable_get() - Get skel dbg flag for umac reset * @soc: dp soc handle * * Return: enable/disable flag */ static bool dp_umac_rst_skel_enable_get(struct dp_soc *soc) { return soc->umac_reset_ctx.skel_enable; } #else static void dp_umac_rst_skel_enable_update(struct dp_soc *soc, bool en) { } static bool dp_umac_rst_skel_enable_get(struct dp_soc *soc) { return false; } #endif #ifndef WLAN_SOFTUMAC_SUPPORT static void dp_print_reg_write_stats(struct dp_soc *soc) { hal_dump_reg_write_stats(soc->hal_soc); hal_dump_reg_write_srng_stats(soc->hal_soc); } #else static void dp_print_reg_write_stats(struct dp_soc *soc) { hif_print_reg_write_stats(soc->hif_handle); } #endif /** * dp_print_host_stats()- Function to print the stats aggregated at host * @vdev: DP_VDEV handle * @req: host stats type * @soc: dp soc handler * * Return: 0 on success, print error message in case of failure */ static int dp_print_host_stats(struct dp_vdev *vdev, struct cdp_txrx_stats_req *req, struct dp_soc *soc) { struct dp_pdev *pdev = (struct dp_pdev *)vdev->pdev; enum cdp_host_txrx_stats type = dp_stats_mapping_table[req->stats][STATS_HOST]; dp_aggregate_pdev_stats(pdev); switch (type) { case TXRX_CLEAR_STATS: dp_txrx_host_stats_clr(vdev, soc); break; case TXRX_RX_RATE_STATS: dp_print_rx_rates(vdev); break; case TXRX_TX_RATE_STATS: dp_print_tx_rates(vdev); break; case TXRX_TX_HOST_STATS: dp_print_pdev_tx_stats(pdev); dp_print_soc_tx_stats(pdev->soc); dp_print_global_desc_count(); dp_print_vdev_mlo_mcast_tx_stats(vdev); break; case TXRX_RX_HOST_STATS: dp_print_pdev_rx_stats(pdev); dp_print_soc_rx_stats(pdev->soc); break; case TXRX_AST_STATS: dp_print_ast_stats(pdev->soc); dp_print_mec_stats(pdev->soc); dp_print_peer_table(vdev); if (soc->arch_ops.dp_mlo_print_ptnr_info) soc->arch_ops.dp_mlo_print_ptnr_info(vdev); break; case TXRX_SRNG_PTR_STATS: dp_print_ring_stats(pdev); break; case TXRX_RX_MON_STATS: dp_monitor_print_pdev_rx_mon_stats(pdev); break; case TXRX_REO_QUEUE_STATS: dp_get_host_peer_stats((struct cdp_soc_t *)pdev->soc, req->peer_addr); break; case TXRX_SOC_CFG_PARAMS: dp_print_soc_cfg_params(pdev->soc); break; case TXRX_PDEV_CFG_PARAMS: dp_print_pdev_cfg_params(pdev); break; case TXRX_NAPI_STATS: dp_print_napi_stats(pdev->soc); break; case TXRX_SOC_INTERRUPT_STATS: dp_print_soc_interrupt_stats(pdev->soc); break; case TXRX_SOC_FSE_STATS: if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) soc->cdp_soc.ol_ops->dp_print_fisa_stats( CDP_FISA_STATS_ID_DUMP_HW_FST); break; case TXRX_HAL_REG_WRITE_STATS: dp_print_reg_write_stats(pdev->soc); break; case TXRX_SOC_REO_HW_DESC_DUMP: dp_get_rx_reo_queue_info((struct cdp_soc_t *)pdev->soc, vdev->vdev_id); break; case TXRX_SOC_WBM_IDLE_HPTP_DUMP: dp_dump_wbm_idle_hptp(pdev->soc, pdev); break; case TXRX_SRNG_USAGE_WM_STATS: /* Dump usage watermark stats for all SRNGs */ dp_dump_srng_high_wm_stats(soc, DP_SRNG_WM_MASK_ALL); break; case TXRX_PEER_STATS: dp_print_per_link_stats((struct cdp_soc_t *)pdev->soc, vdev->vdev_id); break; default: dp_info("Wrong Input For TxRx Host Stats"); dp_txrx_stats_help(); break; } return 0; } /** * dp_pdev_tid_stats_ingress_inc() - increment ingress_stack counter * @pdev: pdev handle * @val: increase in value * * Return: void */ static void dp_pdev_tid_stats_ingress_inc(struct dp_pdev *pdev, uint32_t val) { pdev->stats.tid_stats.ingress_stack += val; } /** * dp_pdev_tid_stats_osif_drop() - increment osif_drop counter * @pdev: pdev handle * @val: increase in value * * Return: void */ static void dp_pdev_tid_stats_osif_drop(struct dp_pdev *pdev, uint32_t val) { pdev->stats.tid_stats.osif_drop += val; } /** * dp_get_fw_peer_stats()- function to print peer stats * @soc: soc handle * @pdev_id: id of the pdev handle * @mac_addr: mac address of the peer * @cap: Type of htt stats requested * @is_wait: if set, wait on completion from firmware response * * Currently Supporting only MAC ID based requests Only * 1: HTT_PEER_STATS_REQ_MODE_NO_QUERY * 2: HTT_PEER_STATS_REQ_MODE_QUERY_TQM * 3: HTT_PEER_STATS_REQ_MODE_FLUSH_TQM * * Return: QDF_STATUS */ static QDF_STATUS dp_get_fw_peer_stats(struct cdp_soc_t *soc, uint8_t pdev_id, uint8_t *mac_addr, uint32_t cap, uint32_t is_wait) { int i; uint32_t config_param0 = 0; uint32_t config_param1 = 0; uint32_t config_param2 = 0; uint32_t config_param3 = 0; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; HTT_DBG_EXT_STATS_PEER_INFO_IS_MAC_ADDR_SET(config_param0, 1); config_param0 |= (1 << (cap + 1)); for (i = 0; i < HTT_PEER_STATS_MAX_TLV; i++) { config_param1 |= (1 << i); } config_param2 |= (mac_addr[0] & 0x000000ff); config_param2 |= ((mac_addr[1] << 8) & 0x0000ff00); config_param2 |= ((mac_addr[2] << 16) & 0x00ff0000); config_param2 |= ((mac_addr[3] << 24) & 0xff000000); config_param3 |= (mac_addr[4] & 0x000000ff); config_param3 |= ((mac_addr[5] << 8) & 0x0000ff00); if (is_wait) { qdf_event_reset(&pdev->fw_peer_stats_event); dp_h2t_ext_stats_msg_send(pdev, HTT_DBG_EXT_STATS_PEER_INFO, config_param0, config_param1, config_param2, config_param3, 0, DBG_STATS_COOKIE_DP_STATS, 0); qdf_wait_single_event(&pdev->fw_peer_stats_event, DP_FW_PEER_STATS_CMP_TIMEOUT_MSEC); } else { dp_h2t_ext_stats_msg_send(pdev, HTT_DBG_EXT_STATS_PEER_INFO, config_param0, config_param1, config_param2, config_param3, 0, DBG_STATS_COOKIE_DEFAULT, 0); } return QDF_STATUS_SUCCESS; } /* This struct definition will be removed from here * once it get added in FW headers*/ struct httstats_cmd_req { uint32_t config_param0; uint32_t config_param1; uint32_t config_param2; uint32_t config_param3; int cookie; u_int8_t stats_id; }; /** * dp_get_htt_stats: function to process the httstas request * @soc: DP soc handle * @pdev_id: id of pdev handle * @data: pointer to request data * @data_len: length for request data * * Return: QDF_STATUS */ static QDF_STATUS dp_get_htt_stats(struct cdp_soc_t *soc, uint8_t pdev_id, void *data, uint32_t data_len) { struct httstats_cmd_req *req = (struct httstats_cmd_req *)data; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; QDF_ASSERT(data_len == sizeof(struct httstats_cmd_req)); dp_h2t_ext_stats_msg_send(pdev, req->stats_id, req->config_param0, req->config_param1, req->config_param2, req->config_param3, req->cookie, DBG_STATS_COOKIE_DEFAULT, 0); return QDF_STATUS_SUCCESS; } /** * dp_set_pdev_tidmap_prty_wifi3() - update tidmap priority in pdev * @pdev: DP_PDEV handle * @prio: tidmap priority value passed by the user * * Return: QDF_STATUS_SUCCESS on success */ static QDF_STATUS dp_set_pdev_tidmap_prty_wifi3(struct dp_pdev *pdev, uint8_t prio) { struct dp_soc *soc = pdev->soc; soc->tidmap_prty = prio; hal_tx_set_tidmap_prty(soc->hal_soc, prio); return QDF_STATUS_SUCCESS; } /** * dp_get_peer_param: function to get parameters in peer * @cdp_soc: DP soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @param: parameter type to be set * @val: address of buffer * * Return: val */ static QDF_STATUS dp_get_peer_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_param_type param, cdp_config_param_type *val) { return QDF_STATUS_SUCCESS; } #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT) static inline void dp_check_map_link_id_band(struct dp_peer *peer) { if (peer->link_id_valid) dp_map_link_id_band(peer); } /** * dp_map_local_link_id_band() - map local link id band * @peer: dp peer handle * * Return: None */ static inline void dp_map_local_link_id_band(struct dp_peer *peer) { struct dp_txrx_peer *txrx_peer = NULL; enum dp_bands band; txrx_peer = dp_get_txrx_peer(peer); if (txrx_peer && peer->local_link_id) { band = dp_freq_to_band(peer->freq); txrx_peer->ll_band[peer->local_link_id] = band; } else { dp_info("txrx_peer NULL or local link id not set: %u " QDF_MAC_ADDR_FMT, peer->local_link_id, QDF_MAC_ADDR_REF(peer->mac_addr.raw)); } } #else static inline void dp_check_map_link_id_band(struct dp_peer *peer) { } static inline void dp_map_local_link_id_band(struct dp_peer *peer) { } #endif /** * dp_set_peer_freq() - Set peer frequency * @cdp_soc: DP soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @param: parameter type to be set * @val: value of parameter to be set * * Return: QDF_STATUS_SUCCESS for success. error code for failure. */ static inline QDF_STATUS dp_set_peer_freq(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_param_type param, cdp_config_param_type val) { struct dp_peer *peer = NULL; struct cdp_peer_info peer_info = { 0 }; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, CDP_LINK_PEER_TYPE); peer = dp_peer_hash_find_wrapper((struct dp_soc *)cdp_soc, &peer_info, DP_MOD_ID_CDP); if (!peer) { dp_err("peer NULL,MAC " QDF_MAC_ADDR_FMT ", vdev_id %u", QDF_MAC_ADDR_REF(peer_mac), vdev_id); return QDF_STATUS_E_FAILURE; } peer->freq = val.cdp_peer_param_freq; dp_check_map_link_id_band(peer); dp_map_local_link_id_band(peer); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); dp_info("Peer " QDF_MAC_ADDR_FMT " vdev_id %u, frequency %u", QDF_MAC_ADDR_REF(peer_mac), vdev_id, peer->freq); return QDF_STATUS_SUCCESS; } /** * dp_set_peer_param: function to set parameters in peer * @cdp_soc: DP soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @param: parameter type to be set * @val: value of parameter to be set * * Return: 0 for success. nonzero for failure. */ static QDF_STATUS dp_set_peer_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_param_type param, cdp_config_param_type val) { QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find((struct dp_soc *)cdp_soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); struct dp_txrx_peer *txrx_peer; if (!peer) return QDF_STATUS_E_FAILURE; txrx_peer = peer->txrx_peer; if (!txrx_peer) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } switch (param) { case CDP_CONFIG_NAWDS: txrx_peer->nawds_enabled = val.cdp_peer_param_nawds; break; case CDP_CONFIG_ISOLATION: dp_info("Peer " QDF_MAC_ADDR_FMT " vdev_id %d, isolation %d", QDF_MAC_ADDR_REF(peer_mac), vdev_id, val.cdp_peer_param_isolation); dp_set_peer_isolation(txrx_peer, val.cdp_peer_param_isolation); break; case CDP_CONFIG_IN_TWT: txrx_peer->in_twt = !!(val.cdp_peer_param_in_twt); break; case CDP_CONFIG_PEER_FREQ: status = dp_set_peer_freq(cdp_soc, vdev_id, peer_mac, param, val); break; default: break; } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } #ifdef WLAN_FEATURE_11BE_MLO /** * dp_set_mld_peer_param: function to set parameters in MLD peer * @cdp_soc: DP soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @param: parameter type to be set * @val: value of parameter to be set * * Return: 0 for success. nonzero for failure. */ static QDF_STATUS dp_set_mld_peer_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_param_type param, cdp_config_param_type val) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); struct dp_peer *peer; struct dp_txrx_peer *txrx_peer; QDF_STATUS status = QDF_STATUS_SUCCESS; peer = dp_mld_peer_find_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) return QDF_STATUS_E_FAILURE; txrx_peer = peer->txrx_peer; if (!txrx_peer) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } switch (param) { case CDP_CONFIG_MLD_PEER_VDEV: status = dp_mld_peer_change_vdev(soc, peer, val.new_vdev_id); break; default: break; } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } /** * dp_set_peer_param_wrapper: wrapper function to set parameters in * legacy/link/MLD peer * @cdp_soc: DP soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @param: parameter type to be set * @val: value of parameter to be set * * Return: 0 for success. nonzero for failure. */ static QDF_STATUS dp_set_peer_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_param_type param, cdp_config_param_type val) { QDF_STATUS status; switch (param) { case CDP_CONFIG_MLD_PEER_VDEV: status = dp_set_mld_peer_param(cdp_soc, vdev_id, peer_mac, param, val); break; default: status = dp_set_peer_param(cdp_soc, vdev_id, peer_mac, param, val); break; } return status; } #endif /** * dp_get_pdev_param() - function to get parameters from pdev * @cdp_soc: DP soc handle * @pdev_id: id of pdev handle * @param: parameter type to be get * @val: buffer for value * * Return: status */ static QDF_STATUS dp_get_pdev_param(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, enum cdp_pdev_param_type param, cdp_config_param_type *val) { struct cdp_pdev *pdev = (struct cdp_pdev *) dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; switch (param) { case CDP_CONFIG_VOW: val->cdp_pdev_param_cfg_vow = ((struct dp_pdev *)pdev)->vow_stats; break; case CDP_TX_PENDING: val->cdp_pdev_param_tx_pending = dp_get_tx_pending(pdev); break; case CDP_FILTER_MCAST_DATA: val->cdp_pdev_param_fltr_mcast = dp_monitor_pdev_get_filter_mcast_data(pdev); break; case CDP_FILTER_NO_DATA: val->cdp_pdev_param_fltr_none = dp_monitor_pdev_get_filter_non_data(pdev); break; case CDP_FILTER_UCAST_DATA: val->cdp_pdev_param_fltr_ucast = dp_monitor_pdev_get_filter_ucast_data(pdev); break; case CDP_MONITOR_CHANNEL: val->cdp_pdev_param_monitor_chan = dp_monitor_get_chan_num((struct dp_pdev *)pdev); break; case CDP_MONITOR_FREQUENCY: val->cdp_pdev_param_mon_freq = dp_monitor_get_chan_freq((struct dp_pdev *)pdev); break; case CDP_CONFIG_RXDMA_BUF_RING_SIZE: val->cdp_rxdma_buf_ring_size = wlan_cfg_get_rx_dma_buf_ring_size(((struct dp_pdev *)pdev)->wlan_cfg_ctx); break; case CDP_CONFIG_DELAY_STATS: val->cdp_pdev_param_cfg_delay_stats = ((struct dp_pdev *)pdev)->delay_stats_flag; break; default: return QDF_STATUS_E_FAILURE; } return QDF_STATUS_SUCCESS; } /** * dp_set_pdev_param() - function to set parameters in pdev * @cdp_soc: DP soc handle * @pdev_id: id of pdev handle * @param: parameter type to be set * @val: value of parameter to be set * * Return: 0 for success. nonzero for failure. */ static QDF_STATUS dp_set_pdev_param(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, enum cdp_pdev_param_type param, cdp_config_param_type val) { int target_type; struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, pdev_id); enum reg_wifi_band chan_band; if (!pdev) return QDF_STATUS_E_FAILURE; target_type = hal_get_target_type(soc->hal_soc); switch (target_type) { case TARGET_TYPE_QCA6750: case TARGET_TYPE_WCN6450: pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC0_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; break; case TARGET_TYPE_KIWI: case TARGET_TYPE_MANGO: case TARGET_TYPE_PEACH: pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC0_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; break; default: pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MAC1_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MAC0_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MAC0_LMAC_ID; break; } switch (param) { case CDP_CONFIG_TX_CAPTURE: return dp_monitor_config_debug_sniffer(pdev, val.cdp_pdev_param_tx_capture); case CDP_CONFIG_DEBUG_SNIFFER: return dp_monitor_config_debug_sniffer(pdev, val.cdp_pdev_param_dbg_snf); case CDP_CONFIG_BPR_ENABLE: return dp_monitor_set_bpr_enable(pdev, val.cdp_pdev_param_bpr_enable); case CDP_CONFIG_PRIMARY_RADIO: pdev->is_primary = val.cdp_pdev_param_primary_radio; break; case CDP_CONFIG_CAPTURE_LATENCY: pdev->latency_capture_enable = val.cdp_pdev_param_cptr_latcy; break; case CDP_INGRESS_STATS: dp_pdev_tid_stats_ingress_inc(pdev, val.cdp_pdev_param_ingrs_stats); break; case CDP_OSIF_DROP: dp_pdev_tid_stats_osif_drop(pdev, val.cdp_pdev_param_osif_drop); break; case CDP_CONFIG_ENH_RX_CAPTURE: return dp_monitor_config_enh_rx_capture(pdev, val.cdp_pdev_param_en_rx_cap); case CDP_CONFIG_ENH_TX_CAPTURE: return dp_monitor_config_enh_tx_capture(pdev, val.cdp_pdev_param_en_tx_cap); case CDP_CONFIG_HMMC_TID_OVERRIDE: pdev->hmmc_tid_override_en = val.cdp_pdev_param_hmmc_tid_ovrd; break; case CDP_CONFIG_HMMC_TID_VALUE: pdev->hmmc_tid = val.cdp_pdev_param_hmmc_tid; break; case CDP_CHAN_NOISE_FLOOR: pdev->chan_noise_floor = val.cdp_pdev_param_chn_noise_flr; break; case CDP_TIDMAP_PRTY: dp_set_pdev_tidmap_prty_wifi3(pdev, val.cdp_pdev_param_tidmap_prty); break; case CDP_FILTER_NEIGH_PEERS: dp_monitor_set_filter_neigh_peers(pdev, val.cdp_pdev_param_fltr_neigh_peers); break; case CDP_MONITOR_CHANNEL: dp_monitor_set_chan_num(pdev, val.cdp_pdev_param_monitor_chan); break; case CDP_MONITOR_FREQUENCY: chan_band = wlan_reg_freq_to_band(val.cdp_pdev_param_mon_freq); dp_monitor_set_chan_freq(pdev, val.cdp_pdev_param_mon_freq); dp_monitor_set_chan_band(pdev, chan_band); break; case CDP_CONFIG_BSS_COLOR: dp_monitor_set_bsscolor(pdev, val.cdp_pdev_param_bss_color); break; case CDP_SET_ATF_STATS_ENABLE: dp_monitor_set_atf_stats_enable(pdev, val.cdp_pdev_param_atf_stats_enable); break; case CDP_CONFIG_SPECIAL_VAP: dp_monitor_pdev_config_scan_spcl_vap(pdev, val.cdp_pdev_param_config_special_vap); dp_monitor_vdev_set_monitor_mode_buf_rings(pdev); break; case CDP_RESET_SCAN_SPCL_VAP_STATS_ENABLE: dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(pdev, val.cdp_pdev_param_reset_scan_spcl_vap_stats_enable); break; case CDP_CONFIG_ENHANCED_STATS_ENABLE: pdev->enhanced_stats_en = val.cdp_pdev_param_enhanced_stats_enable; break; case CDP_ISOLATION: pdev->isolation = val.cdp_pdev_param_isolation; break; case CDP_CONFIG_UNDECODED_METADATA_CAPTURE_ENABLE: return dp_monitor_config_undecoded_metadata_capture(pdev, val.cdp_pdev_param_undecoded_metadata_enable); break; case CDP_CONFIG_RXDMA_BUF_RING_SIZE: wlan_cfg_set_rx_dma_buf_ring_size(pdev->wlan_cfg_ctx, val.cdp_rxdma_buf_ring_size); break; case CDP_CONFIG_VOW: pdev->vow_stats = val.cdp_pdev_param_cfg_vow; break; default: return QDF_STATUS_E_INVAL; } return QDF_STATUS_SUCCESS; } #ifdef QCA_UNDECODED_METADATA_SUPPORT static QDF_STATUS dp_set_pdev_phyrx_error_mask(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, uint32_t mask, uint32_t mask_cont) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; return dp_monitor_config_undecoded_metadata_phyrx_error_mask(pdev, mask, mask_cont); } static QDF_STATUS dp_get_pdev_phyrx_error_mask(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, uint32_t *mask, uint32_t *mask_cont) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; return dp_monitor_get_undecoded_metadata_phyrx_error_mask(pdev, mask, mask_cont); } #endif #ifdef QCA_PEER_EXT_STATS static void dp_rx_update_peer_delay_stats(struct dp_soc *soc, qdf_nbuf_t nbuf) { struct dp_peer *peer = NULL; uint16_t peer_id, ring_id; uint8_t tid = qdf_nbuf_get_tid_val(nbuf); struct dp_peer_delay_stats *delay_stats = NULL; peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf); if (peer_id > soc->max_peer_id) return; peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_CDP); if (qdf_unlikely(!peer)) return; if (qdf_unlikely(!peer->txrx_peer)) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return; } if (qdf_likely(peer->txrx_peer->delay_stats)) { delay_stats = peer->txrx_peer->delay_stats; ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf); dp_rx_compute_tid_delay(&delay_stats->delay_tid_stats[tid][ring_id], nbuf); } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); } #else static inline void dp_rx_update_peer_delay_stats(struct dp_soc *soc, qdf_nbuf_t nbuf) { } #endif /** * dp_calculate_delay_stats() - function to get rx delay stats * @cdp_soc: DP soc handle * @vdev_id: id of DP vdev handle * @nbuf: skb * * Return: QDF_STATUS */ static QDF_STATUS dp_calculate_delay_stats(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, qdf_nbuf_t nbuf) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_SUCCESS; if (vdev->pdev->delay_stats_flag) dp_rx_compute_delay(vdev, nbuf); else dp_rx_update_peer_delay_stats(soc, nbuf); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_get_vdev_param() - function to get parameters from vdev * @cdp_soc: DP soc handle * @vdev_id: id of DP vdev handle * @param: parameter type to get value * @val: buffer address * * Return: status */ static QDF_STATUS dp_get_vdev_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, enum cdp_vdev_param_type param, cdp_config_param_type *val) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_FAILURE; switch (param) { case CDP_ENABLE_WDS: val->cdp_vdev_param_wds = vdev->wds_enabled; break; case CDP_ENABLE_MEC: val->cdp_vdev_param_mec = vdev->mec_enabled; break; case CDP_ENABLE_DA_WAR: val->cdp_vdev_param_da_war = vdev->pdev->soc->da_war_enabled; break; case CDP_ENABLE_IGMP_MCAST_EN: val->cdp_vdev_param_igmp_mcast_en = vdev->igmp_mcast_enhanc_en; break; case CDP_ENABLE_MCAST_EN: val->cdp_vdev_param_mcast_en = vdev->mcast_enhancement_en; break; case CDP_ENABLE_HLOS_TID_OVERRIDE: val->cdp_vdev_param_hlos_tid_override = dp_vdev_get_hlos_tid_override((struct cdp_vdev *)vdev); break; case CDP_ENABLE_PEER_AUTHORIZE: val->cdp_vdev_param_peer_authorize = vdev->peer_authorize; break; case CDP_TX_ENCAP_TYPE: val->cdp_vdev_param_tx_encap = vdev->tx_encap_type; break; case CDP_ENABLE_CIPHER: val->cdp_vdev_param_cipher_en = vdev->sec_type; break; #ifdef WLAN_SUPPORT_MESH_LATENCY case CDP_ENABLE_PEER_TID_LATENCY: val->cdp_vdev_param_peer_tid_latency_enable = vdev->peer_tid_latency_enabled; break; case CDP_SET_VAP_MESH_TID: val->cdp_vdev_param_mesh_tid = vdev->mesh_tid_latency_config.latency_tid; break; #endif case CDP_DROP_3ADDR_MCAST: val->cdp_drop_3addr_mcast = vdev->drop_3addr_mcast; break; case CDP_SET_MCAST_VDEV: soc->arch_ops.txrx_get_vdev_mcast_param(soc, vdev, val); break; #ifdef QCA_SUPPORT_WDS_EXTENDED case CDP_DROP_TX_MCAST: val->cdp_drop_tx_mcast = vdev->drop_tx_mcast; break; #endif #ifdef MESH_MODE_SUPPORT case CDP_MESH_RX_FILTER: val->cdp_vdev_param_mesh_rx_filter = vdev->mesh_rx_filter; break; case CDP_MESH_MODE: val->cdp_vdev_param_mesh_mode = vdev->mesh_vdev; break; #endif case CDP_ENABLE_NAWDS: val->cdp_vdev_param_nawds = vdev->nawds_enabled; break; case CDP_ENABLE_WRAP: val->cdp_vdev_param_wrap = vdev->wrap_vdev; break; #ifdef DP_TRAFFIC_END_INDICATION case CDP_ENABLE_TRAFFIC_END_INDICATION: val->cdp_vdev_param_traffic_end_ind = vdev->traffic_end_ind_en; break; #endif default: dp_cdp_err("%pK: param value %d is wrong", soc, param); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_set_vdev_param() - function to set parameters in vdev * @cdp_soc: DP soc handle * @vdev_id: id of DP vdev handle * @param: parameter type to get value * @val: value * * Return: QDF_STATUS */ static QDF_STATUS dp_set_vdev_param(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, enum cdp_vdev_param_type param, cdp_config_param_type val) { struct dp_soc *dsoc = (struct dp_soc *)cdp_soc; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(dsoc, vdev_id, DP_MOD_ID_CDP); uint32_t var = 0; if (!vdev) return QDF_STATUS_E_FAILURE; switch (param) { case CDP_ENABLE_WDS: dp_cdp_err("%pK: wds_enable %d for vdev(%pK) id(%d)", dsoc, val.cdp_vdev_param_wds, vdev, vdev->vdev_id); vdev->wds_enabled = val.cdp_vdev_param_wds; break; case CDP_ENABLE_MEC: dp_cdp_err("%pK: mec_enable %d for vdev(%pK) id(%d)", dsoc, val.cdp_vdev_param_mec, vdev, vdev->vdev_id); vdev->mec_enabled = val.cdp_vdev_param_mec; break; case CDP_ENABLE_DA_WAR: dp_cdp_err("%pK: da_war_enable %d for vdev(%pK) id(%d)", dsoc, val.cdp_vdev_param_da_war, vdev, vdev->vdev_id); vdev->pdev->soc->da_war_enabled = val.cdp_vdev_param_da_war; dp_wds_flush_ast_table_wifi3(((struct cdp_soc_t *) vdev->pdev->soc)); break; case CDP_ENABLE_NAWDS: vdev->nawds_enabled = val.cdp_vdev_param_nawds; break; case CDP_ENABLE_MCAST_EN: vdev->mcast_enhancement_en = val.cdp_vdev_param_mcast_en; break; case CDP_ENABLE_IGMP_MCAST_EN: vdev->igmp_mcast_enhanc_en = val.cdp_vdev_param_igmp_mcast_en; break; case CDP_ENABLE_PROXYSTA: vdev->proxysta_vdev = val.cdp_vdev_param_proxysta; break; case CDP_UPDATE_TDLS_FLAGS: vdev->tdls_link_connected = val.cdp_vdev_param_tdls_flags; break; case CDP_CFG_WDS_AGING_TIMER: var = val.cdp_vdev_param_aging_tmr; if (!var) qdf_timer_stop(&vdev->pdev->soc->ast_aging_timer); else if (var != vdev->wds_aging_timer_val) qdf_timer_mod(&vdev->pdev->soc->ast_aging_timer, var); vdev->wds_aging_timer_val = var; break; case CDP_ENABLE_AP_BRIDGE: if (wlan_op_mode_sta != vdev->opmode) vdev->ap_bridge_enabled = val.cdp_vdev_param_ap_brdg_en; else vdev->ap_bridge_enabled = false; break; case CDP_ENABLE_CIPHER: vdev->sec_type = val.cdp_vdev_param_cipher_en; break; case CDP_ENABLE_QWRAP_ISOLATION: vdev->isolation_vdev = val.cdp_vdev_param_qwrap_isolation; break; case CDP_UPDATE_MULTIPASS: vdev->multipass_en = val.cdp_vdev_param_update_multipass; dp_info("vdev %d Multipass enable %d", vdev_id, vdev->multipass_en); break; case CDP_TX_ENCAP_TYPE: vdev->tx_encap_type = val.cdp_vdev_param_tx_encap; break; case CDP_RX_DECAP_TYPE: vdev->rx_decap_type = val.cdp_vdev_param_rx_decap; break; case CDP_TID_VDEV_PRTY: vdev->tidmap_prty = val.cdp_vdev_param_tidmap_prty; break; case CDP_TIDMAP_TBL_ID: vdev->tidmap_tbl_id = val.cdp_vdev_param_tidmap_tbl_id; break; #ifdef MESH_MODE_SUPPORT case CDP_MESH_RX_FILTER: dp_vdev_set_mesh_rx_filter((struct cdp_vdev *)vdev, val.cdp_vdev_param_mesh_rx_filter); break; case CDP_MESH_MODE: dp_vdev_set_mesh_mode((struct cdp_vdev *)vdev, val.cdp_vdev_param_mesh_mode); break; #endif case CDP_ENABLE_HLOS_TID_OVERRIDE: dp_info("vdev_id %d enable hlod tid override %d", vdev_id, val.cdp_vdev_param_hlos_tid_override); dp_vdev_set_hlos_tid_override(vdev, val.cdp_vdev_param_hlos_tid_override); break; #ifdef QCA_SUPPORT_WDS_EXTENDED case CDP_CFG_WDS_EXT: if (vdev->opmode == wlan_op_mode_ap) vdev->wds_ext_enabled = val.cdp_vdev_param_wds_ext; break; case CDP_DROP_TX_MCAST: dp_info("vdev_id %d drop tx mcast :%d", vdev_id, val.cdp_drop_tx_mcast); vdev->drop_tx_mcast = val.cdp_drop_tx_mcast; break; #endif case CDP_ENABLE_PEER_AUTHORIZE: vdev->peer_authorize = val.cdp_vdev_param_peer_authorize; break; #ifdef WLAN_SUPPORT_MESH_LATENCY case CDP_ENABLE_PEER_TID_LATENCY: dp_info("vdev_id %d enable peer tid latency %d", vdev_id, val.cdp_vdev_param_peer_tid_latency_enable); vdev->peer_tid_latency_enabled = val.cdp_vdev_param_peer_tid_latency_enable; break; case CDP_SET_VAP_MESH_TID: dp_info("vdev_id %d enable peer tid latency %d", vdev_id, val.cdp_vdev_param_mesh_tid); vdev->mesh_tid_latency_config.latency_tid = val.cdp_vdev_param_mesh_tid; break; #endif #ifdef WLAN_VENDOR_SPECIFIC_BAR_UPDATE case CDP_SKIP_BAR_UPDATE_AP: dp_info("vdev_id %d skip BAR update: %u", vdev_id, val.cdp_skip_bar_update); vdev->skip_bar_update = val.cdp_skip_bar_update; vdev->skip_bar_update_last_ts = 0; break; #endif case CDP_DROP_3ADDR_MCAST: dp_info("vdev_id %d drop 3 addr mcast :%d", vdev_id, val.cdp_drop_3addr_mcast); vdev->drop_3addr_mcast = val.cdp_drop_3addr_mcast; break; case CDP_ENABLE_WRAP: vdev->wrap_vdev = val.cdp_vdev_param_wrap; break; #ifdef DP_TRAFFIC_END_INDICATION case CDP_ENABLE_TRAFFIC_END_INDICATION: vdev->traffic_end_ind_en = val.cdp_vdev_param_traffic_end_ind; break; #endif #ifdef FEATURE_DIRECT_LINK case CDP_VDEV_TX_TO_FW: dp_info("vdev_id %d to_fw :%d", vdev_id, val.cdp_vdev_tx_to_fw); vdev->to_fw = val.cdp_vdev_tx_to_fw; break; #endif case CDP_VDEV_SET_MAC_ADDR: dp_info("set mac addr, old mac addr" QDF_MAC_ADDR_FMT " new mac addr: " QDF_MAC_ADDR_FMT " for vdev %d", QDF_MAC_ADDR_REF(vdev->mac_addr.raw), QDF_MAC_ADDR_REF(val.mac_addr), vdev->vdev_id); qdf_mem_copy(&vdev->mac_addr.raw[0], val.mac_addr, QDF_MAC_ADDR_SIZE); break; default: break; } dp_tx_vdev_update_search_flags((struct dp_vdev *)vdev); dsoc->arch_ops.txrx_set_vdev_param(dsoc, vdev, param, val); /* Update PDEV flags as VDEV flags are updated */ dp_pdev_update_fast_rx_flag(dsoc, vdev->pdev); dp_vdev_unref_delete(dsoc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #if defined(FEATURE_WLAN_TDLS) && defined(WLAN_FEATURE_11BE_MLO) /** * dp_update_mlo_vdev_for_tdls() - update mlo vdev configuration * for TDLS * @cdp_soc: DP soc handle * @vdev_id: id of DP vdev handle * @param: parameter type for vdev * @val: value * * If TDLS connection is from secondary vdev, then update TX bank register * info for primary vdev as well. * If TDLS connection is from primary vdev, same as before. * * Return: None */ static void dp_update_mlo_vdev_for_tdls(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, enum cdp_vdev_param_type param, cdp_config_param_type val) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct dp_peer *peer; struct dp_peer *tmp_peer; struct dp_peer *mld_peer; struct dp_vdev *vdev = NULL; struct dp_vdev *pri_vdev = NULL; uint8_t pri_vdev_id = CDP_INVALID_VDEV_ID; if (param != CDP_UPDATE_TDLS_FLAGS) return; dp_info("update TDLS flag for vdev_id %d, val %d", vdev_id, val.cdp_vdev_param_tdls_flags); vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_MISC); /* only check for STA mode vdev */ if (!vdev || vdev->opmode != wlan_op_mode_sta) { dp_info("vdev is not as expected for TDLS"); goto comp_ret; } /* Find primary vdev_id */ qdf_spin_lock_bh(&vdev->peer_list_lock); TAILQ_FOREACH_SAFE(peer, &vdev->peer_list, peer_list_elem, tmp_peer) { if (dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG) == QDF_STATUS_SUCCESS) { /* do check only if MLO link peer exist */ if (IS_MLO_DP_LINK_PEER(peer)) { mld_peer = DP_GET_MLD_PEER_FROM_PEER(peer); pri_vdev_id = mld_peer->vdev->vdev_id; dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); break; } dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG); } } qdf_spin_unlock_bh(&vdev->peer_list_lock); if (pri_vdev_id != CDP_INVALID_VDEV_ID) pri_vdev = dp_vdev_get_ref_by_id(soc, pri_vdev_id, DP_MOD_ID_MISC); /* If current vdev is not same as primary vdev */ if (pri_vdev && pri_vdev != vdev) { dp_info("primary vdev [%d] %pK different from vdev [%d] %pK", pri_vdev->vdev_id, pri_vdev, vdev->vdev_id, vdev); dp_set_vdev_param(cdp_soc, pri_vdev->vdev_id, CDP_UPDATE_TDLS_FLAGS, val); } comp_ret: if (pri_vdev) dp_vdev_unref_delete(soc, pri_vdev, DP_MOD_ID_MISC); if (vdev) dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_MISC); } static QDF_STATUS dp_set_vdev_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, enum cdp_vdev_param_type param, cdp_config_param_type val) { dp_update_mlo_vdev_for_tdls(cdp_soc, vdev_id, param, val); return dp_set_vdev_param(cdp_soc, vdev_id, param, val); } #else static QDF_STATUS dp_set_vdev_param_wrapper(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, enum cdp_vdev_param_type param, cdp_config_param_type val) { return dp_set_vdev_param(cdp_soc, vdev_id, param, val); } #endif /** * dp_rx_peer_metadata_ver_update() - update rx peer metadata version and * corresponding filed shift and mask * @soc: Handle to DP Soc structure * @peer_md_ver: RX peer metadata version value * * Return: None */ static void dp_rx_peer_metadata_ver_update(struct dp_soc *soc, uint8_t peer_md_ver) { dp_info("rx_peer_metadata version %d", peer_md_ver); switch (peer_md_ver) { case 0: /* htt_rx_peer_metadata_v0 */ soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V0_PEER_ID_S; soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V0_PEER_ID_M; soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V0_VDEV_ID_S; soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V0_VDEV_ID_M; break; case 1: /* htt_rx_peer_metadata_v1 */ soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1_PEER_ID_S; soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1_PEER_ID_M; soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1_VDEV_ID_S; soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1_VDEV_ID_M; soc->htt_mld_peer_valid_s = HTT_RX_PEER_META_DATA_V1_ML_PEER_VALID_S; soc->htt_mld_peer_valid_m = HTT_RX_PEER_META_DATA_V1_ML_PEER_VALID_M; break; case 2: /* htt_rx_peer_metadata_v1a */ soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1A_PEER_ID_S; soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1A_PEER_ID_M; soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1A_VDEV_ID_S; soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1A_VDEV_ID_M; soc->htt_mld_peer_valid_s = HTT_RX_PEER_META_DATA_V1A_ML_PEER_VALID_S; soc->htt_mld_peer_valid_m = HTT_RX_PEER_META_DATA_V1A_ML_PEER_VALID_M; break; case 3: /* htt_rx_peer_metadata_v1b */ soc->htt_peer_id_s = HTT_RX_PEER_META_DATA_V1B_PEER_ID_S; soc->htt_peer_id_m = HTT_RX_PEER_META_DATA_V1B_PEER_ID_M; soc->htt_vdev_id_s = HTT_RX_PEER_META_DATA_V1B_VDEV_ID_S; soc->htt_vdev_id_m = HTT_RX_PEER_META_DATA_V1B_VDEV_ID_M; soc->htt_mld_peer_valid_s = HTT_RX_PEER_META_DATA_V1B_ML_PEER_VALID_S; soc->htt_mld_peer_valid_m = HTT_RX_PEER_META_DATA_V1B_ML_PEER_VALID_M; break; default: dp_err("invliad rx_peer_metadata version %d", peer_md_ver); break; } soc->rx_peer_metadata_ver = peer_md_ver; } /** * dp_set_psoc_param: function to set parameters in psoc * @cdp_soc: DP soc handle * @param: parameter type to be set * @val: value of parameter to be set * * Return: QDF_STATUS */ static QDF_STATUS dp_set_psoc_param(struct cdp_soc_t *cdp_soc, enum cdp_psoc_param_type param, cdp_config_param_type val) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct wlan_cfg_dp_soc_ctxt *wlan_cfg_ctx = soc->wlan_cfg_ctx; switch (param) { case CDP_ENABLE_RATE_STATS: soc->peerstats_enabled = val.cdp_psoc_param_en_rate_stats; break; case CDP_SET_NSS_CFG: wlan_cfg_set_dp_soc_nss_cfg(wlan_cfg_ctx, val.cdp_psoc_param_en_nss_cfg); /* * TODO: masked out based on the per offloaded radio */ switch (val.cdp_psoc_param_en_nss_cfg) { case dp_nss_cfg_default: break; case dp_nss_cfg_first_radio: /* * This configuration is valid for single band radio which * is also NSS offload. */ case dp_nss_cfg_dbdc: case dp_nss_cfg_dbtc: wlan_cfg_set_num_tx_desc_pool(wlan_cfg_ctx, 0); wlan_cfg_set_num_tx_ext_desc_pool(wlan_cfg_ctx, 0); wlan_cfg_set_num_tx_desc(wlan_cfg_ctx, 0); wlan_cfg_set_num_tx_spl_desc(soc->wlan_cfg_ctx, 0); wlan_cfg_set_num_tx_ext_desc(wlan_cfg_ctx, 0); break; default: dp_cdp_err("%pK: Invalid offload config %d", soc, val.cdp_psoc_param_en_nss_cfg); } dp_cdp_err("%pK: nss-wifi<0> nss config is enabled" , soc); break; case CDP_SET_PREFERRED_HW_MODE: soc->preferred_hw_mode = val.cdp_psoc_param_preferred_hw_mode; break; case CDP_IPA_ENABLE: soc->wlan_cfg_ctx->ipa_enabled = val.cdp_ipa_enabled; break; case CDP_CFG_VDEV_STATS_HW_OFFLOAD: wlan_cfg_set_vdev_stats_hw_offload_config(wlan_cfg_ctx, val.cdp_psoc_param_vdev_stats_hw_offload); break; case CDP_SAWF_ENABLE: wlan_cfg_set_sawf_config(wlan_cfg_ctx, val.cdp_sawf_enabled); break; case CDP_UMAC_RST_SKEL_ENABLE: dp_umac_rst_skel_enable_update(soc, val.cdp_umac_rst_skel); break; case CDP_UMAC_RESET_STATS: dp_umac_reset_stats_print(soc); break; case CDP_SAWF_STATS: wlan_cfg_set_sawf_stats_config(wlan_cfg_ctx, val.cdp_sawf_stats); break; case CDP_CFG_RX_PEER_METADATA_VER: dp_rx_peer_metadata_ver_update( soc, val.cdp_peer_metadata_ver); break; case CDP_CFG_TX_DESC_NUM: wlan_cfg_set_num_tx_desc(wlan_cfg_ctx, val.cdp_tx_desc_num); break; case CDP_CFG_TX_EXT_DESC_NUM: wlan_cfg_set_num_tx_ext_desc(wlan_cfg_ctx, val.cdp_tx_ext_desc_num); break; case CDP_CFG_TX_RING_SIZE: wlan_cfg_set_tx_ring_size(wlan_cfg_ctx, val.cdp_tx_ring_size); break; case CDP_CFG_TX_COMPL_RING_SIZE: wlan_cfg_set_tx_comp_ring_size(wlan_cfg_ctx, val.cdp_tx_comp_ring_size); break; case CDP_CFG_RX_SW_DESC_NUM: wlan_cfg_set_dp_soc_rx_sw_desc_num(wlan_cfg_ctx, val.cdp_rx_sw_desc_num); break; case CDP_CFG_REO_DST_RING_SIZE: wlan_cfg_set_reo_dst_ring_size(wlan_cfg_ctx, val.cdp_reo_dst_ring_size); break; case CDP_CFG_RXDMA_REFILL_RING_SIZE: wlan_cfg_set_dp_soc_rxdma_refill_ring_size(wlan_cfg_ctx, val.cdp_rxdma_refill_ring_size); break; #ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL case CDP_CFG_RX_REFILL_POOL_NUM: wlan_cfg_set_rx_refill_buf_pool_size(wlan_cfg_ctx, val.cdp_rx_refill_buf_pool_size); break; #endif case CDP_CFG_AST_INDICATION_DISABLE: wlan_cfg_set_ast_indication_disable (wlan_cfg_ctx, val.cdp_ast_indication_disable); break; case CDP_CONFIG_DP_DEBUG_LOG: soc->dp_debug_log_en = val.cdp_psoc_param_dp_debug_log; break; case CDP_MONITOR_FLAG: soc->mon_flags = val.cdp_monitor_flag; dp_info("monior interface flags: 0x%x", soc->mon_flags); break; default: break; } return QDF_STATUS_SUCCESS; } #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) /** * dp_get_mldev_mode: function to get mlo operation mode * @soc: soc structure for data path * * Return: uint8_t */ static uint8_t dp_get_mldev_mode(struct dp_soc *soc) { return soc->mld_mode_ap; } #else static uint8_t dp_get_mldev_mode(struct dp_soc *cdp_soc) { return MLD_MODE_INVALID; } #endif /** * dp_get_psoc_param: function to get parameters in soc * @cdp_soc: DP soc handle * @param: parameter type to be get * @val: address of buffer * * Return: status */ static QDF_STATUS dp_get_psoc_param(struct cdp_soc_t *cdp_soc, enum cdp_psoc_param_type param, cdp_config_param_type *val) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct wlan_cfg_dp_soc_ctxt *wlan_cfg_ctx; if (!soc) return QDF_STATUS_E_FAILURE; wlan_cfg_ctx = soc->wlan_cfg_ctx; switch (param) { case CDP_ENABLE_RATE_STATS: val->cdp_psoc_param_en_rate_stats = soc->peerstats_enabled; break; case CDP_CFG_PEER_EXT_STATS: val->cdp_psoc_param_pext_stats = wlan_cfg_is_peer_ext_stats_enabled(wlan_cfg_ctx); break; case CDP_CFG_VDEV_STATS_HW_OFFLOAD: val->cdp_psoc_param_vdev_stats_hw_offload = wlan_cfg_get_vdev_stats_hw_offload_config(wlan_cfg_ctx); break; case CDP_UMAC_RST_SKEL_ENABLE: val->cdp_umac_rst_skel = dp_umac_rst_skel_enable_get(soc); break; case CDP_TXRX_HAL_SOC_HDL: val->hal_soc_hdl = soc->hal_soc; break; case CDP_CFG_TX_DESC_NUM: val->cdp_tx_desc_num = wlan_cfg_get_num_tx_desc(wlan_cfg_ctx); break; case CDP_CFG_TX_EXT_DESC_NUM: val->cdp_tx_ext_desc_num = wlan_cfg_get_num_tx_ext_desc(wlan_cfg_ctx); break; case CDP_CFG_TX_RING_SIZE: val->cdp_tx_ring_size = wlan_cfg_tx_ring_size(wlan_cfg_ctx); break; case CDP_CFG_TX_COMPL_RING_SIZE: val->cdp_tx_comp_ring_size = wlan_cfg_tx_comp_ring_size(wlan_cfg_ctx); break; case CDP_CFG_RX_SW_DESC_NUM: val->cdp_rx_sw_desc_num = wlan_cfg_get_dp_soc_rx_sw_desc_num(wlan_cfg_ctx); break; case CDP_CFG_REO_DST_RING_SIZE: val->cdp_reo_dst_ring_size = wlan_cfg_get_reo_dst_ring_size(wlan_cfg_ctx); break; case CDP_CFG_RXDMA_REFILL_RING_SIZE: val->cdp_rxdma_refill_ring_size = wlan_cfg_get_dp_soc_rxdma_refill_ring_size(wlan_cfg_ctx); break; #ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL case CDP_CFG_RX_REFILL_POOL_NUM: val->cdp_rx_refill_buf_pool_size = wlan_cfg_get_rx_refill_buf_pool_size(wlan_cfg_ctx); break; #endif case CDP_CFG_FISA_PARAMS: val->fisa_params.fisa_fst_size = wlan_cfg_get_rx_flow_search_table_size(soc->wlan_cfg_ctx); val->fisa_params.rx_flow_max_search = wlan_cfg_rx_fst_get_max_search(soc->wlan_cfg_ctx); val->fisa_params.rx_toeplitz_hash_key = wlan_cfg_rx_fst_get_hash_key(soc->wlan_cfg_ctx); break; case CDP_RX_PKT_TLV_SIZE: val->rx_pkt_tlv_size = soc->rx_pkt_tlv_size; break; case CDP_CFG_GET_MLO_OPER_MODE: val->cdp_psoc_param_mlo_oper_mode = dp_get_mldev_mode(soc); break; case CDP_CFG_PEER_JITTER_STATS: val->cdp_psoc_param_jitter_stats = wlan_cfg_is_peer_jitter_stats_enabled(soc->wlan_cfg_ctx); break; case CDP_CONFIG_DP_DEBUG_LOG: val->cdp_psoc_param_dp_debug_log = soc->dp_debug_log_en; break; case CDP_MONITOR_FLAG: val->cdp_monitor_flag = soc->mon_flags; break; default: dp_warn("Invalid param: %u", param); break; } return QDF_STATUS_SUCCESS; } /** * dp_set_vdev_dscp_tid_map_wifi3() - Update Map ID selected for particular vdev * @cdp_soc: CDP SOC handle * @vdev_id: id of DP_VDEV handle * @map_id:ID of map that needs to be updated * * Return: QDF_STATUS */ static QDF_STATUS dp_set_vdev_dscp_tid_map_wifi3(ol_txrx_soc_handle cdp_soc, uint8_t vdev_id, uint8_t map_id) { cdp_config_param_type val; struct dp_soc *soc = cdp_soc_t_to_dp_soc(cdp_soc); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (vdev) { vdev->dscp_tid_map_id = map_id; val.cdp_vdev_param_dscp_tid_map_id = map_id; soc->arch_ops.txrx_set_vdev_param(soc, vdev, CDP_UPDATE_DSCP_TO_TID_MAP, val); /* Update flag for transmit tid classification */ if (vdev->dscp_tid_map_id < soc->num_hw_dscp_tid_map) vdev->skip_sw_tid_classification |= DP_TX_HW_DSCP_TID_MAP_VALID; else vdev->skip_sw_tid_classification &= ~DP_TX_HW_DSCP_TID_MAP_VALID; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } return QDF_STATUS_E_FAILURE; } #ifdef DP_RATETABLE_SUPPORT static int dp_txrx_get_ratekbps(int preamb, int mcs, int htflag, int gintval) { uint32_t rix; uint16_t ratecode; enum cdp_punctured_modes punc_mode = NO_PUNCTURE; return dp_getrateindex((uint32_t)gintval, (uint16_t)mcs, 1, (uint8_t)preamb, 1, punc_mode, &rix, &ratecode); } #else static int dp_txrx_get_ratekbps(int preamb, int mcs, int htflag, int gintval) { return 0; } #endif /** * dp_txrx_get_pdev_stats() - Returns cdp_pdev_stats * @soc: DP soc handle * @pdev_id: id of DP pdev handle * @pdev_stats: buffer to copy to * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_pdev_stats(struct cdp_soc_t *soc, uint8_t pdev_id, struct cdp_pdev_stats *pdev_stats) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; dp_aggregate_pdev_stats(pdev); qdf_mem_copy(pdev_stats, &pdev->stats, sizeof(struct cdp_pdev_stats)); return QDF_STATUS_SUCCESS; } /** * dp_txrx_update_vdev_me_stats() - Update vdev ME stats sent from CDP * @vdev: DP vdev handle * @buf: buffer containing specific stats structure * @xmit_type: xmit type of packet - MLD/Link * * Return: void */ static void dp_txrx_update_vdev_me_stats(struct dp_vdev *vdev, void *buf, uint8_t xmit_type) { struct cdp_tx_ingress_stats *host_stats = NULL; if (!buf) { dp_cdp_err("%pK: Invalid host stats buf", vdev->pdev->soc); return; } host_stats = (struct cdp_tx_ingress_stats *)buf; DP_STATS_INC_PKT(vdev, tx_i[xmit_type].mcast_en.mcast_pkt, host_stats->mcast_en.mcast_pkt.num, host_stats->mcast_en.mcast_pkt.bytes); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.dropped_map_error, host_stats->mcast_en.dropped_map_error); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.dropped_self_mac, host_stats->mcast_en.dropped_self_mac); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.dropped_send_fail, host_stats->mcast_en.dropped_send_fail); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.ucast, host_stats->mcast_en.ucast); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.fail_seg_alloc, host_stats->mcast_en.fail_seg_alloc); DP_STATS_INC(vdev, tx_i[xmit_type].mcast_en.clone_fail, host_stats->mcast_en.clone_fail); } /** * dp_txrx_update_vdev_igmp_me_stats() - Update vdev IGMP ME stats sent from CDP * @vdev: DP vdev handle * @buf: buffer containing specific stats structure * @xmit_type: xmit type of packet - MLD/Link * * Return: void */ static void dp_txrx_update_vdev_igmp_me_stats(struct dp_vdev *vdev, void *buf, uint8_t xmit_type) { struct cdp_tx_ingress_stats *host_stats = NULL; if (!buf) { dp_cdp_err("%pK: Invalid host stats buf", vdev->pdev->soc); return; } host_stats = (struct cdp_tx_ingress_stats *)buf; DP_STATS_INC(vdev, tx_i[xmit_type].igmp_mcast_en.igmp_rcvd, host_stats->igmp_mcast_en.igmp_rcvd); DP_STATS_INC(vdev, tx_i[xmit_type].igmp_mcast_en.igmp_ucast_converted, host_stats->igmp_mcast_en.igmp_ucast_converted); } /** * dp_txrx_update_vdev_host_stats() - Update stats sent through CDP * @soc_hdl: DP soc handle * @vdev_id: id of DP vdev handle * @buf: buffer containing specific stats structure * @stats_id: stats type * @xmit_type: xmit type of packet - MLD/Link * * Return: QDF_STATUS */ static QDF_STATUS dp_txrx_update_vdev_host_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, void *buf, uint16_t stats_id, uint8_t xmit_type) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) { dp_cdp_err("%pK: Invalid vdev handle", soc); return QDF_STATUS_E_FAILURE; } switch (stats_id) { case DP_VDEV_STATS_PKT_CNT_ONLY: break; case DP_VDEV_STATS_TX_ME: dp_txrx_update_vdev_me_stats(vdev, buf, xmit_type); dp_txrx_update_vdev_igmp_me_stats(vdev, buf, xmit_type); break; default: qdf_info("Invalid stats_id %d", stats_id); break; } dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_txrx_get_peer_stats_wrapper() - will get cdp_peer_stats * @soc: soc handle * @peer_stats: destination buffer to copy to * @peer_info: peer info * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_peer_stats_wrapper(struct cdp_soc_t *soc, struct cdp_peer_stats *peer_stats, struct cdp_peer_info peer_info) { struct dp_peer *peer = NULL; peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, DP_MOD_ID_CDP); qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); if (!peer) return QDF_STATUS_E_FAILURE; dp_get_peer_stats(peer, peer_stats); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_txrx_get_peer_stats() - will get cdp_peer_stats * @soc: soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address of DP_PEER handle * @peer_stats: destination buffer to copy to * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_stats *peer_stats) { struct cdp_peer_info peer_info = { 0 }; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, CDP_WILD_PEER_TYPE); return dp_txrx_get_peer_stats_wrapper(soc, peer_stats, peer_info); } /** * dp_txrx_get_peer_stats_based_on_peer_type() - get peer stats based on the * peer type * @soc: soc handle * @vdev_id: id of vdev handle * @peer_mac: mac of DP_PEER handle * @peer_stats: buffer to copy to * @peer_type: type of peer * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_peer_stats_based_on_peer_type(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_stats *peer_stats, enum cdp_peer_type peer_type) { struct cdp_peer_info peer_info = { 0 }; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, peer_type); return dp_txrx_get_peer_stats_wrapper(soc, peer_stats, peer_info); } #if defined WLAN_FEATURE_11BE_MLO && defined DP_MLO_LINK_STATS_SUPPORT /** * dp_get_per_link_peer_stats() - Get per link stats * @peer: DP peer * @peer_stats: buffer to copy to * @peer_type: Peer type * @num_link: Number of ML links * * Return: status success/failure */ QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats, enum cdp_peer_type peer_type, uint8_t num_link) { uint8_t i, min_num_links; struct dp_peer *link_peer; struct dp_mld_link_peers link_peers_info; struct dp_soc *soc = peer->vdev->pdev->soc; dp_get_peer_calibr_stats(peer, peer_stats); dp_get_peer_basic_stats(peer, peer_stats); dp_get_peer_tx_per(peer_stats); if (IS_MLO_DP_MLD_PEER(peer)) { dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_GENERIC_STATS); if (link_peers_info.num_links > num_link) dp_info("Req stats of %d link. less than total link %d", num_link, link_peers_info.num_links); min_num_links = num_link < link_peers_info.num_links ? num_link : link_peers_info.num_links; for (i = 0; i < min_num_links; i++) { link_peer = link_peers_info.link_peers[i]; if (qdf_unlikely(!link_peer)) continue; dp_get_peer_per_pkt_stats(link_peer, peer_stats); dp_get_peer_extd_stats(link_peer, peer_stats); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_GENERIC_STATS); } else { dp_get_peer_per_pkt_stats(peer, peer_stats); dp_get_peer_extd_stats(peer, peer_stats); } return QDF_STATUS_SUCCESS; } #else QDF_STATUS dp_get_per_link_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats, enum cdp_peer_type peer_type, uint8_t num_link) { dp_err("Per link stats not supported"); return QDF_STATUS_E_INVAL; } #endif /** * dp_txrx_get_per_link_peer_stats() - Get per link peer stats * @soc: soc handle * @vdev_id: id of vdev handle * @peer_mac: peer mac address * @peer_stats: buffer to copy to * @peer_type: Peer type * @num_link: Number of ML links * * NOTE: For peer_type = CDP_MLD_PEER_TYPE peer_stats should point to * buffer of size = (sizeof(*peer_stats) * num_link) * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_per_link_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_stats *peer_stats, enum cdp_peer_type peer_type, uint8_t num_link) { QDF_STATUS status; struct dp_peer *peer = NULL; struct cdp_peer_info peer_info = { 0 }; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, peer_type); peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, DP_MOD_ID_GENERIC_STATS); if (!peer) return QDF_STATUS_E_FAILURE; qdf_mem_zero(peer_stats, sizeof(struct cdp_peer_stats)); status = dp_get_per_link_peer_stats(peer, peer_stats, peer_type, num_link); dp_peer_unref_delete(peer, DP_MOD_ID_GENERIC_STATS); return status; } /** * dp_txrx_get_peer_stats_param() - will return specified cdp_peer_stats * @soc: soc handle * @vdev_id: vdev_id of vdev object * @peer_mac: mac address of the peer * @type: enum of required stats * @buf: buffer to hold the value * * Return: status success/failure */ static QDF_STATUS dp_txrx_get_peer_stats_param(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_peer_stats_type type, cdp_peer_stats_param_t *buf) { QDF_STATUS ret; struct dp_peer *peer = NULL; struct cdp_peer_info peer_info = { 0 }; DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac, false, CDP_WILD_PEER_TYPE); peer = dp_peer_hash_find_wrapper((struct dp_soc *)soc, &peer_info, DP_MOD_ID_CDP); if (!peer) { dp_peer_err("%pK: Invalid Peer for Mac " QDF_MAC_ADDR_FMT, soc, QDF_MAC_ADDR_REF(peer_mac)); return QDF_STATUS_E_FAILURE; } if (type >= cdp_peer_per_pkt_stats_min && type < cdp_peer_per_pkt_stats_max) { ret = dp_txrx_get_peer_per_pkt_stats_param(peer, type, buf); } else if (type >= cdp_peer_extd_stats_min && type < cdp_peer_extd_stats_max) { ret = dp_txrx_get_peer_extd_stats_param(peer, type, buf); } else { dp_err("%pK: Invalid stat type requested", soc); ret = QDF_STATUS_E_FAILURE; } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return ret; } /** * dp_txrx_reset_peer_stats() - reset cdp_peer_stats for particular peer * @soc_hdl: soc handle * @vdev_id: id of vdev handle * @peer_mac: mac of DP_PEER handle * * Return: QDF_STATUS */ #ifdef WLAN_FEATURE_11BE_MLO static QDF_STATUS dp_txrx_reset_peer_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac) { QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) return QDF_STATUS_E_FAILURE; DP_STATS_CLR(peer); dp_txrx_peer_stats_clr(peer->txrx_peer); if (IS_MLO_DP_MLD_PEER(peer)) { uint8_t i; struct dp_peer *link_peer; struct dp_soc *link_peer_soc; struct dp_mld_link_peers link_peers_info; dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_CDP); for (i = 0; i < link_peers_info.num_links; i++) { link_peer = link_peers_info.link_peers[i]; link_peer_soc = link_peer->vdev->pdev->soc; DP_STATS_CLR(link_peer); dp_monitor_peer_reset_stats(link_peer_soc, link_peer); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); } else { dp_monitor_peer_reset_stats(soc, peer); } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } #else static QDF_STATUS dp_txrx_reset_peer_stats(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac) { QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) return QDF_STATUS_E_FAILURE; DP_STATS_CLR(peer); dp_txrx_peer_stats_clr(peer->txrx_peer); dp_monitor_peer_reset_stats((struct dp_soc *)soc, peer); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } #endif /** * dp_txrx_get_vdev_stats() - Update buffer with cdp_vdev_stats * @soc_hdl: CDP SoC handle * @vdev_id: vdev Id * @buf: buffer for vdev stats * @is_aggregate: are aggregate stats being collected * * Return: QDF_STATUS */ QDF_STATUS dp_txrx_get_vdev_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, void *buf, bool is_aggregate) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct cdp_vdev_stats *vdev_stats; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return QDF_STATUS_E_RESOURCES; vdev_stats = (struct cdp_vdev_stats *)buf; if (is_aggregate) { dp_aggregate_vdev_stats(vdev, buf, DP_XMIT_LINK); } else { dp_copy_vdev_stats_to_tgt_buf(vdev_stats, &vdev->stats, DP_XMIT_LINK); } dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_get_total_per() - get total per * @soc: DP soc handle * @pdev_id: id of DP_PDEV handle * * Return: % error rate using retries per packet and success packets */ static int dp_get_total_per(struct cdp_soc_t *soc, uint8_t pdev_id) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return 0; dp_aggregate_pdev_stats(pdev); if ((pdev->stats.tx.tx_success.num + pdev->stats.tx.retries) == 0) return 0; return qdf_do_div((pdev->stats.tx.retries * 100), ((pdev->stats.tx.tx_success.num) + (pdev->stats.tx.retries))); } /** * dp_txrx_stats_publish() - publish pdev stats into a buffer * @soc: DP soc handle * @pdev_id: id of DP_PDEV handle * @buf: to hold pdev_stats * * Return: int */ static int dp_txrx_stats_publish(struct cdp_soc_t *soc, uint8_t pdev_id, struct cdp_stats_extd *buf) { struct cdp_txrx_stats_req req = {0,}; QDF_STATUS status; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return TXRX_STATS_LEVEL_OFF; if (pdev->pending_fw_stats_response) { dp_warn("pdev%d: prev req pending\n", pdev->pdev_id); return TXRX_STATS_LEVEL_OFF; } dp_aggregate_pdev_stats(pdev); pdev->pending_fw_stats_response = true; req.stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_TX; req.cookie_val = DBG_STATS_COOKIE_DP_STATS; pdev->fw_stats_tlv_bitmap_rcvd = 0; qdf_event_reset(&pdev->fw_stats_event); status = dp_h2t_ext_stats_msg_send(pdev, req.stats, req.param0, req.param1, req.param2, req.param3, 0, req.cookie_val, 0); if (status != QDF_STATUS_SUCCESS) { dp_warn("pdev%d: tx stats req failed\n", pdev->pdev_id); pdev->pending_fw_stats_response = false; return TXRX_STATS_LEVEL_OFF; } req.stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_RX; req.cookie_val = DBG_STATS_COOKIE_DP_STATS; status = dp_h2t_ext_stats_msg_send(pdev, req.stats, req.param0, req.param1, req.param2, req.param3, 0, req.cookie_val, 0); if (status != QDF_STATUS_SUCCESS) { dp_warn("pdev%d: rx stats req failed\n", pdev->pdev_id); pdev->pending_fw_stats_response = false; return TXRX_STATS_LEVEL_OFF; } /* The event may have already been signaled. Wait only if it's pending */ if (!pdev->fw_stats_event.done) { status = qdf_wait_single_event(&pdev->fw_stats_event, DP_MAX_SLEEP_TIME); if (status != QDF_STATUS_SUCCESS) { if (status == QDF_STATUS_E_TIMEOUT) dp_warn("pdev%d: fw stats timeout. TLVs rcvd 0x%llx\n", pdev->pdev_id, pdev->fw_stats_tlv_bitmap_rcvd); pdev->pending_fw_stats_response = false; return TXRX_STATS_LEVEL_OFF; } } qdf_mem_copy(buf, &pdev->stats, sizeof(struct cdp_pdev_stats)); pdev->pending_fw_stats_response = false; return TXRX_STATS_LEVEL; } /** * dp_get_obss_stats() - Get Pdev OBSS stats from Fw * @soc: DP soc handle * @pdev_id: id of DP_PDEV handle * @buf: to hold pdev obss stats * @req: Pointer to CDP TxRx stats * * Return: status */ static QDF_STATUS dp_get_obss_stats(struct cdp_soc_t *soc, uint8_t pdev_id, struct cdp_pdev_obss_pd_stats_tlv *buf, struct cdp_txrx_stats_req *req) { QDF_STATUS status; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_INVAL; if (pdev->pending_fw_obss_stats_response) return QDF_STATUS_E_AGAIN; pdev->pending_fw_obss_stats_response = true; req->stats = (enum cdp_stats)HTT_DBG_EXT_STATS_PDEV_OBSS_PD_STATS; req->cookie_val = DBG_STATS_COOKIE_HTT_OBSS; qdf_event_reset(&pdev->fw_obss_stats_event); status = dp_h2t_ext_stats_msg_send(pdev, req->stats, req->param0, req->param1, req->param2, req->param3, 0, req->cookie_val, req->mac_id); if (QDF_IS_STATUS_ERROR(status)) { pdev->pending_fw_obss_stats_response = false; return status; } status = qdf_wait_single_event(&pdev->fw_obss_stats_event, DP_MAX_SLEEP_TIME); if (status != QDF_STATUS_SUCCESS) { if (status == QDF_STATUS_E_TIMEOUT) qdf_debug("TIMEOUT_OCCURS"); pdev->pending_fw_obss_stats_response = false; return QDF_STATUS_E_TIMEOUT; } qdf_mem_copy(buf, &pdev->stats.htt_tx_pdev_stats.obss_pd_stats_tlv, sizeof(struct cdp_pdev_obss_pd_stats_tlv)); pdev->pending_fw_obss_stats_response = false; return status; } /** * dp_clear_pdev_obss_pd_stats() - Clear pdev obss stats * @soc: DP soc handle * @pdev_id: id of DP_PDEV handle * @req: Pointer to CDP TxRx stats request mac_id will be * pre-filled and should not be overwritten * * Return: status */ static QDF_STATUS dp_clear_pdev_obss_pd_stats(struct cdp_soc_t *soc, uint8_t pdev_id, struct cdp_txrx_stats_req *req) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); uint32_t cookie_val = DBG_STATS_COOKIE_DEFAULT; if (!pdev) return QDF_STATUS_E_INVAL; /* * For HTT_DBG_EXT_STATS_RESET command, FW need to config * from param0 to param3 according to below rule: * * PARAM: * - config_param0 : start_offset (stats type) * - config_param1 : stats bmask from start offset * - config_param2 : stats bmask from start offset + 32 * - config_param3 : stats bmask from start offset + 64 */ req->stats = (enum cdp_stats)HTT_DBG_EXT_STATS_RESET; req->param0 = HTT_DBG_EXT_STATS_PDEV_OBSS_PD_STATS; req->param1 = 0x00000001; return dp_h2t_ext_stats_msg_send(pdev, req->stats, req->param0, req->param1, req->param2, req->param3, 0, cookie_val, req->mac_id); } /** * dp_set_pdev_dscp_tid_map_wifi3() - update dscp tid map in pdev * @soc_handle: soc handle * @pdev_id: id of DP_PDEV handle * @map_id: ID of map that needs to be updated * @tos: index value in map * @tid: tid value passed by the user * * Return: QDF_STATUS */ static QDF_STATUS dp_set_pdev_dscp_tid_map_wifi3(struct cdp_soc_t *soc_handle, uint8_t pdev_id, uint8_t map_id, uint8_t tos, uint8_t tid) { uint8_t dscp; struct dp_soc *soc = (struct dp_soc *)soc_handle; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; dscp = (tos >> DP_IP_DSCP_SHIFT) & DP_IP_DSCP_MASK; pdev->dscp_tid_map[map_id][dscp] = tid; if (map_id < soc->num_hw_dscp_tid_map) hal_tx_update_dscp_tid(soc->hal_soc, tid, map_id, dscp); else return QDF_STATUS_E_FAILURE; return QDF_STATUS_SUCCESS; } #ifdef WLAN_SYSFS_DP_STATS /** * dp_sysfs_event_trigger() - Trigger event to wait for firmware * stats request response. * @soc: soc handle * @cookie_val: cookie value * * Return: QDF_STATUS */ static QDF_STATUS dp_sysfs_event_trigger(struct dp_soc *soc, uint32_t cookie_val) { QDF_STATUS status = QDF_STATUS_SUCCESS; /* wait for firmware response for sysfs stats request */ if (cookie_val == DBG_SYSFS_STATS_COOKIE) { if (!soc) { dp_cdp_err("soc is NULL"); return QDF_STATUS_E_FAILURE; } /* wait for event completion */ status = qdf_wait_single_event(&soc->sysfs_config->sysfs_txrx_fw_request_done, WLAN_SYSFS_STAT_REQ_WAIT_MS); if (status == QDF_STATUS_SUCCESS) dp_cdp_info("sysfs_txrx_fw_request_done event completed"); else if (status == QDF_STATUS_E_TIMEOUT) dp_cdp_warn("sysfs_txrx_fw_request_done event expired"); else dp_cdp_warn("sysfs_txrx_fw_request_done event error code %d", status); } return status; } #else /* WLAN_SYSFS_DP_STATS */ static QDF_STATUS dp_sysfs_event_trigger(struct dp_soc *soc, uint32_t cookie_val) { return QDF_STATUS_SUCCESS; } #endif /* WLAN_SYSFS_DP_STATS */ /** * dp_fw_stats_process() - Process TXRX FW stats request. * @vdev: DP VDEV handle * @req: stats request * * Return: QDF_STATUS */ static QDF_STATUS dp_fw_stats_process(struct dp_vdev *vdev, struct cdp_txrx_stats_req *req) { struct dp_pdev *pdev = NULL; struct dp_soc *soc = NULL; uint32_t stats = req->stats; uint8_t mac_id = req->mac_id; uint32_t cookie_val = DBG_STATS_COOKIE_DEFAULT; if (!vdev) { DP_TRACE(NONE, "VDEV not found"); return QDF_STATUS_E_FAILURE; } pdev = vdev->pdev; if (!pdev) { DP_TRACE(NONE, "PDEV not found"); return QDF_STATUS_E_FAILURE; } soc = pdev->soc; if (!soc) { DP_TRACE(NONE, "soc not found"); return QDF_STATUS_E_FAILURE; } /* In case request is from host sysfs for displaying stats on console */ if (req->cookie_val == DBG_SYSFS_STATS_COOKIE) cookie_val = DBG_SYSFS_STATS_COOKIE; /* * For HTT_DBG_EXT_STATS_RESET command, FW need to config * from param0 to param3 according to below rule: * * PARAM: * - config_param0 : start_offset (stats type) * - config_param1 : stats bmask from start offset * - config_param2 : stats bmask from start offset + 32 * - config_param3 : stats bmask from start offset + 64 */ if (req->stats == CDP_TXRX_STATS_0) { req->param0 = HTT_DBG_EXT_STATS_PDEV_TX; req->param1 = 0xFFFFFFFF; req->param2 = 0xFFFFFFFF; req->param3 = 0xFFFFFFFF; } else if (req->stats == (uint8_t)HTT_DBG_EXT_STATS_PDEV_TX_MU) { req->param0 = HTT_DBG_EXT_STATS_SET_VDEV_MASK(vdev->vdev_id); } if (req->stats == (uint8_t)HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT) { dp_h2t_ext_stats_msg_send(pdev, HTT_DBG_EXT_STATS_PDEV_RX_RATE_EXT, req->param0, req->param1, req->param2, req->param3, 0, cookie_val, mac_id); } else { dp_h2t_ext_stats_msg_send(pdev, stats, req->param0, req->param1, req->param2, req->param3, 0, cookie_val, mac_id); } dp_sysfs_event_trigger(soc, cookie_val); return QDF_STATUS_SUCCESS; } /** * dp_txrx_stats_request - function to map to firmware and host stats * @soc_handle: soc handle * @vdev_id: virtual device ID * @req: stats request * * Return: QDF_STATUS */ static QDF_STATUS dp_txrx_stats_request(struct cdp_soc_t *soc_handle, uint8_t vdev_id, struct cdp_txrx_stats_req *req) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_handle); int host_stats; int fw_stats; enum cdp_stats stats; int num_stats; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); QDF_STATUS status = QDF_STATUS_E_INVAL; if (!vdev || !req) { dp_cdp_err("%pK: Invalid vdev/req instance", soc); status = QDF_STATUS_E_INVAL; goto fail0; } if (req->mac_id >= WLAN_CFG_MAC_PER_TARGET) { dp_err("Invalid mac_id: %u request", req->mac_id); status = QDF_STATUS_E_INVAL; goto fail0; } stats = req->stats; if (stats >= CDP_TXRX_MAX_STATS) { status = QDF_STATUS_E_INVAL; goto fail0; } /* * DP_CURR_FW_STATS_AVAIL: no of FW stats currently available * has to be updated if new FW HTT stats added */ if (stats > CDP_TXRX_STATS_HTT_MAX) stats = stats + DP_CURR_FW_STATS_AVAIL - DP_HTT_DBG_EXT_STATS_MAX; num_stats = QDF_ARRAY_SIZE(dp_stats_mapping_table); if (stats >= num_stats) { dp_cdp_err("%pK : Invalid stats option: %d", soc, stats); status = QDF_STATUS_E_INVAL; goto fail0; } req->stats = stats; fw_stats = dp_stats_mapping_table[stats][STATS_FW]; host_stats = dp_stats_mapping_table[stats][STATS_HOST]; dp_info("stats: %u fw_stats_type: %d host_stats: %d", stats, fw_stats, host_stats); if (fw_stats != TXRX_FW_STATS_INVALID) { /* update request with FW stats type */ req->stats = fw_stats; status = dp_fw_stats_process(vdev, req); } else if ((host_stats != TXRX_HOST_STATS_INVALID) && (host_stats <= TXRX_HOST_STATS_MAX)) status = dp_print_host_stats(vdev, req, soc); else dp_cdp_info("%pK: Wrong Input for TxRx Stats", soc); fail0: if (vdev) dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return status; } /** * dp_soc_notify_asserted_soc() - API to notify asserted soc info * @psoc: CDP soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_notify_asserted_soc(struct cdp_soc_t *psoc) { struct dp_soc *soc = (struct dp_soc *)psoc; if (!soc) { dp_cdp_err("%pK: soc is NULL", soc); return QDF_STATUS_E_INVAL; } return dp_umac_reset_notify_asserted_soc(soc); } /** * dp_txrx_dump_stats() - Dump statistics * @psoc: CDP soc handle * @value: Statistics option * @level: verbosity level */ static QDF_STATUS dp_txrx_dump_stats(struct cdp_soc_t *psoc, uint16_t value, enum qdf_stats_verbosity_level level) { struct dp_soc *soc = (struct dp_soc *)psoc; QDF_STATUS status = QDF_STATUS_SUCCESS; if (!soc) { dp_cdp_err("%pK: soc is NULL", soc); return QDF_STATUS_E_INVAL; } switch (value) { case CDP_TXRX_PATH_STATS: dp_txrx_path_stats(soc); dp_print_soc_interrupt_stats(soc); dp_print_reg_write_stats(soc); dp_pdev_print_tx_delay_stats(soc); /* Dump usage watermark stats for core TX/RX SRNGs */ dp_dump_srng_high_wm_stats(soc, DP_SRNG_WM_MASK_REO_DST | DP_SRNG_WM_MASK_TX_COMP); if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) soc->cdp_soc.ol_ops->dp_print_fisa_stats( CDP_FISA_STATS_ID_ERR_STATS); break; case CDP_RX_RING_STATS: dp_print_per_ring_stats(soc); break; case CDP_TXRX_TSO_STATS: dp_print_tso_stats(soc, level); break; case CDP_DUMP_TX_FLOW_POOL_INFO: if (level == QDF_STATS_VERBOSITY_LEVEL_HIGH) cdp_dump_flow_pool_info((struct cdp_soc_t *)soc); else dp_tx_dump_flow_pool_info_compact(soc); break; case CDP_DP_NAPI_STATS: dp_print_napi_stats(soc); break; case CDP_TXRX_DESC_STATS: /* TODO: NOT IMPLEMENTED */ break; case CDP_DP_RX_FISA_STATS: if (soc->cdp_soc.ol_ops->dp_print_fisa_stats) soc->cdp_soc.ol_ops->dp_print_fisa_stats( CDP_FISA_STATS_ID_DUMP_SW_FST); break; case CDP_DP_SWLM_STATS: dp_print_swlm_stats(soc); break; case CDP_DP_TX_HW_LATENCY_STATS: dp_pdev_print_tx_delay_stats(soc); break; default: status = QDF_STATUS_E_INVAL; break; } return status; } #ifdef WLAN_SYSFS_DP_STATS static void dp_sysfs_get_stat_type(struct dp_soc *soc, uint32_t *mac_id, uint32_t *stat_type) { qdf_spinlock_acquire(&soc->sysfs_config->rw_stats_lock); *stat_type = soc->sysfs_config->stat_type_requested; *mac_id = soc->sysfs_config->mac_id; qdf_spinlock_release(&soc->sysfs_config->rw_stats_lock); } static void dp_sysfs_update_config_buf_params(struct dp_soc *soc, uint32_t curr_len, uint32_t max_buf_len, char *buf) { qdf_spinlock_acquire(&soc->sysfs_config->sysfs_write_user_buffer); /* set sysfs_config parameters */ soc->sysfs_config->buf = buf; soc->sysfs_config->curr_buffer_length = curr_len; soc->sysfs_config->max_buffer_length = max_buf_len; qdf_spinlock_release(&soc->sysfs_config->sysfs_write_user_buffer); } static QDF_STATUS dp_sysfs_fill_stats(ol_txrx_soc_handle soc_hdl, char *buf, uint32_t buf_size) { uint32_t mac_id = 0; uint32_t stat_type = 0; uint32_t fw_stats = 0; uint32_t host_stats = 0; enum cdp_stats stats; struct cdp_txrx_stats_req req; uint32_t num_stats; struct dp_soc *soc = NULL; if (!soc_hdl) { dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); return QDF_STATUS_E_INVAL; } soc = cdp_soc_t_to_dp_soc(soc_hdl); if (!soc) { dp_cdp_err("%pK: soc is NULL", soc); return QDF_STATUS_E_INVAL; } dp_sysfs_get_stat_type(soc, &mac_id, &stat_type); stats = stat_type; if (stats >= CDP_TXRX_MAX_STATS) { dp_cdp_info("sysfs stat type requested is invalid"); return QDF_STATUS_E_INVAL; } /* * DP_CURR_FW_STATS_AVAIL: no of FW stats currently available * has to be updated if new FW HTT stats added */ if (stats > CDP_TXRX_MAX_STATS) stats = stats + DP_CURR_FW_STATS_AVAIL - DP_HTT_DBG_EXT_STATS_MAX; num_stats = QDF_ARRAY_SIZE(dp_stats_mapping_table); if (stats >= num_stats) { dp_cdp_err("%pK : Invalid stats option: %d, max num stats: %d", soc, stats, num_stats); return QDF_STATUS_E_INVAL; } /* build request */ fw_stats = dp_stats_mapping_table[stats][STATS_FW]; host_stats = dp_stats_mapping_table[stats][STATS_HOST]; req.stats = stat_type; req.mac_id = mac_id; /* request stats to be printed */ qdf_mutex_acquire(&soc->sysfs_config->sysfs_read_lock); if (fw_stats != TXRX_FW_STATS_INVALID) { /* update request with FW stats type */ req.cookie_val = DBG_SYSFS_STATS_COOKIE; } else if ((host_stats != TXRX_HOST_STATS_INVALID) && (host_stats <= TXRX_HOST_STATS_MAX)) { req.cookie_val = DBG_STATS_COOKIE_DEFAULT; soc->sysfs_config->process_id = qdf_get_current_pid(); soc->sysfs_config->printing_mode = PRINTING_MODE_ENABLED; } dp_sysfs_update_config_buf_params(soc, 0, buf_size, buf); dp_txrx_stats_request(soc_hdl, mac_id, &req); soc->sysfs_config->process_id = 0; soc->sysfs_config->printing_mode = PRINTING_MODE_DISABLED; dp_sysfs_update_config_buf_params(soc, 0, 0, NULL); qdf_mutex_release(&soc->sysfs_config->sysfs_read_lock); return QDF_STATUS_SUCCESS; } static QDF_STATUS dp_sysfs_set_stat_type(ol_txrx_soc_handle soc_hdl, uint32_t stat_type, uint32_t mac_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); if (!soc_hdl) { dp_cdp_err("%pK: soc is NULL", soc); return QDF_STATUS_E_INVAL; } qdf_spinlock_acquire(&soc->sysfs_config->rw_stats_lock); soc->sysfs_config->stat_type_requested = stat_type; soc->sysfs_config->mac_id = mac_id; qdf_spinlock_release(&soc->sysfs_config->rw_stats_lock); return QDF_STATUS_SUCCESS; } static QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl) { struct dp_soc *soc; QDF_STATUS status; if (!soc_hdl) { dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); return QDF_STATUS_E_INVAL; } soc = soc_hdl; soc->sysfs_config = qdf_mem_malloc(sizeof(struct sysfs_stats_config)); if (!soc->sysfs_config) { dp_cdp_err("failed to allocate memory for sysfs_config no memory"); return QDF_STATUS_E_NOMEM; } status = qdf_event_create(&soc->sysfs_config->sysfs_txrx_fw_request_done); /* create event for fw stats request from sysfs */ if (status != QDF_STATUS_SUCCESS) { dp_cdp_err("failed to create event sysfs_txrx_fw_request_done"); qdf_mem_free(soc->sysfs_config); soc->sysfs_config = NULL; return QDF_STATUS_E_FAILURE; } qdf_spinlock_create(&soc->sysfs_config->rw_stats_lock); qdf_mutex_create(&soc->sysfs_config->sysfs_read_lock); qdf_spinlock_create(&soc->sysfs_config->sysfs_write_user_buffer); return QDF_STATUS_SUCCESS; } static QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl) { struct dp_soc *soc; QDF_STATUS status; if (!soc_hdl) { dp_cdp_err("%pK: soc_hdl is NULL", soc_hdl); return QDF_STATUS_E_INVAL; } soc = soc_hdl; if (!soc->sysfs_config) { dp_cdp_err("soc->sysfs_config is NULL"); return QDF_STATUS_E_FAILURE; } status = qdf_event_destroy(&soc->sysfs_config->sysfs_txrx_fw_request_done); if (status != QDF_STATUS_SUCCESS) dp_cdp_err("Failed to destroy event sysfs_txrx_fw_request_done"); qdf_mutex_destroy(&soc->sysfs_config->sysfs_read_lock); qdf_spinlock_destroy(&soc->sysfs_config->rw_stats_lock); qdf_spinlock_destroy(&soc->sysfs_config->sysfs_write_user_buffer); qdf_mem_free(soc->sysfs_config); return QDF_STATUS_SUCCESS; } #else /* WLAN_SYSFS_DP_STATS */ static QDF_STATUS dp_sysfs_deinitialize_stats(struct dp_soc *soc_hdl) { return QDF_STATUS_SUCCESS; } static QDF_STATUS dp_sysfs_initialize_stats(struct dp_soc *soc_hdl) { return QDF_STATUS_SUCCESS; } #endif /* WLAN_SYSFS_DP_STATS */ /** * dp_txrx_clear_dump_stats() - clear dumpStats * @soc_hdl: soc handle * @pdev_id: pdev ID * @value: stats option * * Return: 0 - Success, non-zero - failure */ static QDF_STATUS dp_txrx_clear_dump_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint8_t value) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); QDF_STATUS status = QDF_STATUS_SUCCESS; if (!soc) { dp_err("soc is NULL"); return QDF_STATUS_E_INVAL; } switch (value) { case CDP_TXRX_TSO_STATS: dp_txrx_clear_tso_stats(soc); break; case CDP_DP_TX_HW_LATENCY_STATS: dp_pdev_clear_tx_delay_stats(soc); break; default: status = QDF_STATUS_E_INVAL; break; } return status; } static QDF_STATUS dp_txrx_get_interface_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, void *buf, bool is_aggregate) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); if (soc && soc->arch_ops.dp_get_interface_stats) return soc->arch_ops.dp_get_interface_stats(soc_hdl, vdev_id, buf, is_aggregate); return QDF_STATUS_E_FAILURE; } #ifdef QCA_LL_TX_FLOW_CONTROL_V2 /** * dp_update_flow_control_parameters() - API to store datapath * config parameters * @soc: soc handle * @params: ini parameter handle * * Return: void */ static inline void dp_update_flow_control_parameters(struct dp_soc *soc, struct cdp_config_params *params) { soc->wlan_cfg_ctx->tx_flow_stop_queue_threshold = params->tx_flow_stop_queue_threshold; soc->wlan_cfg_ctx->tx_flow_start_queue_offset = params->tx_flow_start_queue_offset; } #else static inline void dp_update_flow_control_parameters(struct dp_soc *soc, struct cdp_config_params *params) { } #endif #ifdef WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT /* Max packet limit for TX Comp packet loop (dp_tx_comp_handler) */ #define DP_TX_COMP_LOOP_PKT_LIMIT_MAX 1024 /* Max packet limit for RX REAP Loop (dp_rx_process) */ #define DP_RX_REAP_LOOP_PKT_LIMIT_MAX 1024 static void dp_update_rx_soft_irq_limit_params(struct dp_soc *soc, struct cdp_config_params *params) { soc->wlan_cfg_ctx->tx_comp_loop_pkt_limit = params->tx_comp_loop_pkt_limit; if (params->tx_comp_loop_pkt_limit < DP_TX_COMP_LOOP_PKT_LIMIT_MAX) soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check = true; else soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check = false; soc->wlan_cfg_ctx->rx_reap_loop_pkt_limit = params->rx_reap_loop_pkt_limit; if (params->rx_reap_loop_pkt_limit < DP_RX_REAP_LOOP_PKT_LIMIT_MAX) soc->wlan_cfg_ctx->rx_enable_eol_data_check = true; else soc->wlan_cfg_ctx->rx_enable_eol_data_check = false; soc->wlan_cfg_ctx->rx_hp_oos_update_limit = params->rx_hp_oos_update_limit; 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", soc->wlan_cfg_ctx->tx_comp_loop_pkt_limit, soc->wlan_cfg_ctx->tx_comp_enable_eol_data_check, soc->wlan_cfg_ctx->rx_reap_loop_pkt_limit, soc->wlan_cfg_ctx->rx_enable_eol_data_check, soc->wlan_cfg_ctx->rx_hp_oos_update_limit); } #else static inline void dp_update_rx_soft_irq_limit_params(struct dp_soc *soc, struct cdp_config_params *params) { } #endif /* WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT */ /** * dp_update_config_parameters() - API to store datapath * config parameters * @psoc: soc handle * @params: ini parameter handle * * Return: status */ static QDF_STATUS dp_update_config_parameters(struct cdp_soc *psoc, struct cdp_config_params *params) { struct dp_soc *soc = (struct dp_soc *)psoc; if (!(soc)) { dp_cdp_err("%pK: Invalid handle", soc); return QDF_STATUS_E_INVAL; } soc->wlan_cfg_ctx->tso_enabled = params->tso_enable; soc->wlan_cfg_ctx->lro_enabled = params->lro_enable; soc->wlan_cfg_ctx->rx_hash = params->flow_steering_enable; soc->wlan_cfg_ctx->p2p_tcp_udp_checksumoffload = params->p2p_tcp_udp_checksumoffload; soc->wlan_cfg_ctx->nan_tcp_udp_checksumoffload = params->nan_tcp_udp_checksumoffload; soc->wlan_cfg_ctx->tcp_udp_checksumoffload = params->tcp_udp_checksumoffload; soc->wlan_cfg_ctx->napi_enabled = params->napi_enable; soc->wlan_cfg_ctx->ipa_enabled = params->ipa_enable; soc->wlan_cfg_ctx->gro_enabled = params->gro_enable; dp_update_rx_soft_irq_limit_params(soc, params); dp_update_flow_control_parameters(soc, params); return QDF_STATUS_SUCCESS; } static struct cdp_wds_ops dp_ops_wds = { .vdev_set_wds = dp_vdev_set_wds, #ifdef WDS_VENDOR_EXTENSION .txrx_set_wds_rx_policy = dp_txrx_set_wds_rx_policy, .txrx_wds_peer_tx_policy_update = dp_txrx_peer_wds_tx_policy_update, #endif }; /** * dp_txrx_data_tx_cb_set() - set the callback for non standard tx * @soc_hdl: datapath soc handle * @vdev_id: virtual interface id * @callback: callback function * @ctxt: callback context * */ static void dp_txrx_data_tx_cb_set(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, ol_txrx_data_tx_cb callback, void *ctxt) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return; vdev->tx_non_std_data_callback.func = callback; vdev->tx_non_std_data_callback.ctxt = ctxt; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } /** * dp_pdev_get_dp_txrx_handle() - get dp handle from pdev * @soc: datapath soc handle * @pdev_id: id of datapath pdev handle * * Return: opaque pointer to dp txrx handle */ static void *dp_pdev_get_dp_txrx_handle(struct cdp_soc_t *soc, uint8_t pdev_id) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (qdf_unlikely(!pdev)) return NULL; return pdev->dp_txrx_handle; } /** * dp_pdev_set_dp_txrx_handle() - set dp handle in pdev * @soc: datapath soc handle * @pdev_id: id of datapath pdev handle * @dp_txrx_hdl: opaque pointer for dp_txrx_handle * * Return: void */ static void dp_pdev_set_dp_txrx_handle(struct cdp_soc_t *soc, uint8_t pdev_id, void *dp_txrx_hdl) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return; pdev->dp_txrx_handle = dp_txrx_hdl; } /** * dp_vdev_get_dp_ext_handle() - get dp handle from vdev * @soc_hdl: datapath soc handle * @vdev_id: vdev id * * Return: opaque pointer to dp txrx handle */ static void *dp_vdev_get_dp_ext_handle(ol_txrx_soc_handle soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); void *dp_ext_handle; if (!vdev) return NULL; dp_ext_handle = vdev->vdev_dp_ext_handle; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return dp_ext_handle; } /** * dp_vdev_set_dp_ext_handle() - set dp handle in vdev * @soc_hdl: datapath soc handle * @vdev_id: vdev id * @size: size of advance dp handle * * Return: QDF_STATUS */ static QDF_STATUS dp_vdev_set_dp_ext_handle(ol_txrx_soc_handle soc_hdl, uint8_t vdev_id, uint16_t size) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); void *dp_ext_handle; if (!vdev) return QDF_STATUS_E_FAILURE; dp_ext_handle = qdf_mem_malloc(size); if (!dp_ext_handle) { dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_E_FAILURE; } vdev->vdev_dp_ext_handle = dp_ext_handle; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } /** * dp_vdev_inform_ll_conn() - Inform vdev to add/delete a latency critical * connection for this vdev * @soc_hdl: CDP soc handle * @vdev_id: vdev ID * @action: Add/Delete action * * Return: QDF_STATUS. */ static QDF_STATUS dp_vdev_inform_ll_conn(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, enum vdev_ll_conn_actions action) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) { dp_err("LL connection action for invalid vdev %d", vdev_id); return QDF_STATUS_E_FAILURE; } switch (action) { case CDP_VDEV_LL_CONN_ADD: vdev->num_latency_critical_conn++; break; case CDP_VDEV_LL_CONN_DEL: vdev->num_latency_critical_conn--; break; default: dp_err("LL connection action invalid %d", action); break; } dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR /** * dp_soc_set_swlm_enable() - Enable/Disable SWLM if initialized. * @soc_hdl: CDP Soc handle * @value: Enable/Disable value * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_set_swlm_enable(struct cdp_soc_t *soc_hdl, uint8_t value) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); if (!soc->swlm.is_init) { dp_err("SWLM is not initialized"); return QDF_STATUS_E_FAILURE; } soc->swlm.is_enabled = !!value; return QDF_STATUS_SUCCESS; } /** * dp_soc_is_swlm_enabled() - Check if SWLM is enabled. * @soc_hdl: CDP Soc handle * * Return: QDF_STATUS */ static uint8_t dp_soc_is_swlm_enabled(struct cdp_soc_t *soc_hdl) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); return soc->swlm.is_enabled; } #endif /** * dp_soc_get_dp_txrx_handle() - get context for external-dp from dp soc * @soc_handle: datapath soc handle * * Return: opaque pointer to external dp (non-core DP) */ static void *dp_soc_get_dp_txrx_handle(struct cdp_soc *soc_handle) { struct dp_soc *soc = (struct dp_soc *)soc_handle; return soc->external_txrx_handle; } /** * dp_soc_set_dp_txrx_handle() - set external dp handle in soc * @soc_handle: datapath soc handle * @txrx_handle: opaque pointer to external dp (non-core DP) * * Return: void */ static void dp_soc_set_dp_txrx_handle(struct cdp_soc *soc_handle, void *txrx_handle) { struct dp_soc *soc = (struct dp_soc *)soc_handle; soc->external_txrx_handle = txrx_handle; } /** * dp_soc_map_pdev_to_lmac() - Save pdev_id to lmac_id mapping * @soc_hdl: datapath soc handle * @pdev_id: id of the datapath pdev handle * @lmac_id: lmac id * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_map_pdev_to_lmac (struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint32_t lmac_id) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; wlan_cfg_set_hw_mac_idx(soc->wlan_cfg_ctx, pdev_id, lmac_id); /*Set host PDEV ID for lmac_id*/ wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, pdev_id, lmac_id); return QDF_STATUS_SUCCESS; } /** * dp_soc_handle_pdev_mode_change() - Update pdev to lmac mapping * @soc_hdl: datapath soc handle * @pdev_id: id of the datapath pdev handle * @lmac_id: lmac id * * In the event of a dynamic mode change, update the pdev to lmac mapping * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_handle_pdev_mode_change (struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint32_t lmac_id) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_vdev *vdev = NULL; uint8_t hw_pdev_id, mac_id; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); int nss_config = wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx); if (qdf_unlikely(!pdev)) return QDF_STATUS_E_FAILURE; pdev->lmac_id = lmac_id; pdev->target_pdev_id = dp_calculate_target_pdev_id_from_host_pdev_id(soc, pdev_id); dp_info("mode change %d %d", pdev->pdev_id, pdev->lmac_id); /*Set host PDEV ID for lmac_id*/ wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, pdev->pdev_id, lmac_id); hw_pdev_id = dp_get_target_pdev_id_for_host_pdev_id(soc, pdev->pdev_id); /* * When NSS offload is enabled, send pdev_id->lmac_id * and pdev_id to hw_pdev_id to NSS FW */ if (nss_config) { mac_id = pdev->lmac_id; if (soc->cdp_soc.ol_ops->pdev_update_lmac_n_target_pdev_id) soc->cdp_soc.ol_ops-> pdev_update_lmac_n_target_pdev_id( soc->ctrl_psoc, &pdev_id, &mac_id, &hw_pdev_id); } qdf_spin_lock_bh(&pdev->vdev_list_lock); TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { DP_TX_TCL_METADATA_PDEV_ID_SET(vdev->htt_tcl_metadata, hw_pdev_id); vdev->lmac_id = pdev->lmac_id; } qdf_spin_unlock_bh(&pdev->vdev_list_lock); return QDF_STATUS_SUCCESS; } /** * dp_soc_set_pdev_status_down() - set pdev down/up status * @soc: datapath soc handle * @pdev_id: id of datapath pdev handle * @is_pdev_down: pdev down/up status * * Return: QDF_STATUS */ static QDF_STATUS dp_soc_set_pdev_status_down(struct cdp_soc_t *soc, uint8_t pdev_id, bool is_pdev_down) { struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; pdev->is_pdev_down = is_pdev_down; return QDF_STATUS_SUCCESS; } /** * dp_get_cfg_capabilities() - get dp capabilities * @soc_handle: datapath soc handle * @dp_caps: enum for dp capabilities * * Return: bool to determine if dp caps is enabled */ static bool dp_get_cfg_capabilities(struct cdp_soc_t *soc_handle, enum cdp_capabilities dp_caps) { struct dp_soc *soc = (struct dp_soc *)soc_handle; return wlan_cfg_get_dp_caps(soc->wlan_cfg_ctx, dp_caps); } #ifdef FEATURE_AST static QDF_STATUS dp_peer_teardown_wifi3(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; QDF_STATUS status = QDF_STATUS_SUCCESS; struct dp_peer *peer = dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, DP_MOD_ID_CDP); /* Peer can be null for monitor vap mac address */ if (!peer) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, "%s: Invalid peer\n", __func__); return QDF_STATUS_E_FAILURE; } dp_peer_update_state(soc, peer, DP_PEER_STATE_LOGICAL_DELETE); qdf_spin_lock_bh(&soc->ast_lock); dp_peer_send_wds_disconnect(soc, peer); dp_peer_delete_ast_entries(soc, peer); qdf_spin_unlock_bh(&soc->ast_lock); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } #endif #ifndef WLAN_SUPPORT_RX_TAG_STATISTICS /** * dp_dump_pdev_rx_protocol_tag_stats - dump the number of packets tagged for * given protocol type (RX_PROTOCOL_TAG_ALL indicates for all protocol) * @soc: cdp_soc handle * @pdev_id: id of cdp_pdev handle * @protocol_type: protocol type for which stats should be displayed * * Return: none */ static inline void dp_dump_pdev_rx_protocol_tag_stats(struct cdp_soc_t *soc, uint8_t pdev_id, uint16_t protocol_type) { } #endif /* WLAN_SUPPORT_RX_TAG_STATISTICS */ #ifndef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG /** * dp_update_pdev_rx_protocol_tag() - Add/remove a protocol tag that should be * applied to the desired protocol type packets * @soc: soc handle * @pdev_id: id of cdp_pdev handle * @enable_rx_protocol_tag: bitmask that indicates what protocol types * are enabled for tagging. zero indicates disable feature, non-zero indicates * enable feature * @protocol_type: new protocol type for which the tag is being added * @tag: user configured tag for the new protocol * * Return: Success */ static inline QDF_STATUS dp_update_pdev_rx_protocol_tag(struct cdp_soc_t *soc, uint8_t pdev_id, uint32_t enable_rx_protocol_tag, uint16_t protocol_type, uint16_t tag) { return QDF_STATUS_SUCCESS; } #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG */ #ifndef WLAN_SUPPORT_RX_FLOW_TAG /** * dp_set_rx_flow_tag() - add/delete a flow * @cdp_soc: CDP soc handle * @pdev_id: id of cdp_pdev handle * @flow_info: flow tuple that is to be added to/deleted from flow search table * * Return: Success */ static inline QDF_STATUS dp_set_rx_flow_tag(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, struct cdp_rx_flow_info *flow_info) { return QDF_STATUS_SUCCESS; } /** * dp_dump_rx_flow_tag_stats() - dump the number of packets tagged for * given flow 5-tuple * @cdp_soc: soc handle * @pdev_id: id of cdp_pdev handle * @flow_info: flow 5-tuple for which stats should be displayed * * Return: Success */ static inline QDF_STATUS dp_dump_rx_flow_tag_stats(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, struct cdp_rx_flow_info *flow_info) { return QDF_STATUS_SUCCESS; } #endif /* WLAN_SUPPORT_RX_FLOW_TAG */ static QDF_STATUS dp_peer_map_attach_wifi3(struct cdp_soc_t *soc_hdl, uint32_t max_peers, uint32_t max_ast_index, uint8_t peer_map_unmap_versions) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; QDF_STATUS status; soc->max_peers = max_peers; wlan_cfg_set_max_ast_idx(soc->wlan_cfg_ctx, max_ast_index); status = soc->arch_ops.txrx_peer_map_attach(soc); if (!QDF_IS_STATUS_SUCCESS(status)) { dp_err("failure in allocating peer tables"); return QDF_STATUS_E_FAILURE; } dp_info("max_peers %u, calculated max_peers %u max_ast_index: %u", max_peers, soc->max_peer_id, max_ast_index); status = dp_peer_find_attach(soc); if (!QDF_IS_STATUS_SUCCESS(status)) { dp_err("Peer find attach failure"); goto fail; } soc->peer_map_unmap_versions = peer_map_unmap_versions; soc->peer_map_attach_success = TRUE; return QDF_STATUS_SUCCESS; fail: soc->arch_ops.txrx_peer_map_detach(soc); return status; } static QDF_STATUS dp_soc_set_param(struct cdp_soc_t *soc_hdl, enum cdp_soc_param_t param, uint32_t value) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; switch (param) { case DP_SOC_PARAM_MSDU_EXCEPTION_DESC: soc->num_msdu_exception_desc = value; dp_info("num_msdu exception_desc %u", value); break; case DP_SOC_PARAM_CMEM_FSE_SUPPORT: if (wlan_cfg_is_fst_in_cmem_enabled(soc->wlan_cfg_ctx)) soc->fst_in_cmem = !!value; dp_info("FW supports CMEM FSE %u", value); break; case DP_SOC_PARAM_MAX_AST_AGEOUT: soc->max_ast_ageout_count = value; dp_info("Max ast ageout count %u", soc->max_ast_ageout_count); break; case DP_SOC_PARAM_EAPOL_OVER_CONTROL_PORT: soc->eapol_over_control_port = value; dp_info("Eapol over control_port:%d", soc->eapol_over_control_port); break; case DP_SOC_PARAM_MULTI_PEER_GRP_CMD_SUPPORT: soc->multi_peer_grp_cmd_supported = value; dp_info("Multi Peer group command support:%d", soc->multi_peer_grp_cmd_supported); break; case DP_SOC_PARAM_RSSI_DBM_CONV_SUPPORT: soc->features.rssi_dbm_conv_support = value; dp_info("Rssi dbm conversion support:%u", soc->features.rssi_dbm_conv_support); break; case DP_SOC_PARAM_UMAC_HW_RESET_SUPPORT: soc->features.umac_hw_reset_support = value; dp_info("UMAC HW reset support :%u", soc->features.umac_hw_reset_support); break; case DP_SOC_PARAM_MULTI_RX_REORDER_SETUP_SUPPORT: soc->features.multi_rx_reorder_q_setup_support = value; dp_info("Multi rx reorder queue setup support: %u", soc->features.multi_rx_reorder_q_setup_support); break; default: dp_info("not handled param %d ", param); break; } return QDF_STATUS_SUCCESS; } static void dp_soc_set_rate_stats_ctx(struct cdp_soc_t *soc_handle, void *stats_ctx) { struct dp_soc *soc = (struct dp_soc *)soc_handle; soc->rate_stats_ctx = (struct cdp_soc_rate_stats_ctx *)stats_ctx; } #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE /** * dp_peer_flush_rate_stats_req() - Flush peer rate stats * @soc: Datapath SOC handle * @peer: Datapath peer * @arg: argument to iter function * * Return: QDF_STATUS */ static void dp_peer_flush_rate_stats_req(struct dp_soc *soc, struct dp_peer *peer, void *arg) { /* Skip self peer */ if (!qdf_mem_cmp(peer->mac_addr.raw, peer->vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE)) return; dp_wdi_event_handler( WDI_EVENT_FLUSH_RATE_STATS_REQ, soc, dp_monitor_peer_get_peerstats_ctx(soc, peer), peer->peer_id, WDI_NO_VAL, peer->vdev->pdev->pdev_id); } /** * dp_flush_rate_stats_req() - Flush peer rate stats in pdev * @soc_hdl: Datapath SOC handle * @pdev_id: pdev_id * * Return: QDF_STATUS */ static QDF_STATUS dp_flush_rate_stats_req(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (!pdev) return QDF_STATUS_E_FAILURE; dp_pdev_iterate_peer(pdev, dp_peer_flush_rate_stats_req, NULL, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #else static inline QDF_STATUS dp_flush_rate_stats_req(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { return QDF_STATUS_SUCCESS; } #endif #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE #ifdef WLAN_FEATURE_11BE_MLO /** * dp_get_peer_extd_rate_link_stats() - function to get peer * extended rate and link stats * @soc_hdl: dp soc handler * @mac_addr: mac address of peer * * Return: QDF_STATUS */ static QDF_STATUS dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) { uint8_t i; struct dp_peer *link_peer; struct dp_soc *link_peer_soc; struct dp_mld_link_peers link_peers_info; struct dp_peer *peer = NULL; struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct cdp_peer_info peer_info = { 0 }; if (!mac_addr) { dp_err("NULL peer mac addr"); return QDF_STATUS_E_FAILURE; } DP_PEER_INFO_PARAMS_INIT(&peer_info, DP_VDEV_ALL, mac_addr, false, CDP_WILD_PEER_TYPE); peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CDP); if (!peer) { dp_err("Peer is NULL"); return QDF_STATUS_E_FAILURE; } if (IS_MLO_DP_MLD_PEER(peer)) { dp_get_link_peers_ref_from_mld_peer(soc, peer, &link_peers_info, DP_MOD_ID_CDP); for (i = 0; i < link_peers_info.num_links; i++) { link_peer = link_peers_info.link_peers[i]; link_peer_soc = link_peer->vdev->pdev->soc; dp_wdi_event_handler(WDI_EVENT_FLUSH_RATE_STATS_REQ, link_peer_soc, dp_monitor_peer_get_peerstats_ctx (link_peer_soc, link_peer), link_peer->peer_id, WDI_NO_VAL, link_peer->vdev->pdev->pdev_id); } dp_release_link_peers_ref(&link_peers_info, DP_MOD_ID_CDP); } else { dp_wdi_event_handler( WDI_EVENT_FLUSH_RATE_STATS_REQ, soc, dp_monitor_peer_get_peerstats_ctx(soc, peer), peer->peer_id, WDI_NO_VAL, peer->vdev->pdev->pdev_id); } dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #else static QDF_STATUS dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) { struct dp_peer *peer = NULL; struct dp_soc *soc = (struct dp_soc *)soc_hdl; if (!mac_addr) { dp_err("NULL peer mac addr"); return QDF_STATUS_E_FAILURE; } peer = dp_peer_find_hash_find(soc, mac_addr, 0, DP_VDEV_ALL, DP_MOD_ID_CDP); if (!peer) { dp_err("Peer is NULL"); return QDF_STATUS_E_FAILURE; } dp_wdi_event_handler( WDI_EVENT_FLUSH_RATE_STATS_REQ, soc, dp_monitor_peer_get_peerstats_ctx(soc, peer), peer->peer_id, WDI_NO_VAL, peer->vdev->pdev->pdev_id); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } #endif #else static inline QDF_STATUS dp_get_peer_extd_rate_link_stats(struct cdp_soc_t *soc_hdl, uint8_t *mac_addr) { return QDF_STATUS_SUCCESS; } #endif static void *dp_peer_get_peerstats_ctx(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *mac_addr) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_peer *peer; void *peerstats_ctx = NULL; if (mac_addr) { peer = dp_peer_find_hash_find(soc, mac_addr, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) return NULL; if (!IS_MLO_DP_MLD_PEER(peer)) peerstats_ctx = dp_monitor_peer_get_peerstats_ctx(soc, peer); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); } return peerstats_ctx; } #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE static QDF_STATUS dp_peer_flush_rate_stats(struct cdp_soc_t *soc, uint8_t pdev_id, void *buf) { dp_wdi_event_handler(WDI_EVENT_PEER_FLUSH_RATE_STATS, (struct dp_soc *)soc, buf, HTT_INVALID_PEER, WDI_NO_VAL, pdev_id); return QDF_STATUS_SUCCESS; } #else static inline QDF_STATUS dp_peer_flush_rate_stats(struct cdp_soc_t *soc, uint8_t pdev_id, void *buf) { return QDF_STATUS_SUCCESS; } #endif static void *dp_soc_get_rate_stats_ctx(struct cdp_soc_t *soc_handle) { struct dp_soc *soc = (struct dp_soc *)soc_handle; return soc->rate_stats_ctx; } /** * dp_get_cfg() - get dp cfg * @soc: cdp soc handle * @cfg: cfg enum * * Return: cfg value */ static uint32_t dp_get_cfg(struct cdp_soc_t *soc, enum cdp_dp_cfg cfg) { struct dp_soc *dpsoc = (struct dp_soc *)soc; uint32_t value = 0; switch (cfg) { case cfg_dp_enable_data_stall: value = dpsoc->wlan_cfg_ctx->enable_data_stall_detection; break; case cfg_dp_enable_p2p_ip_tcp_udp_checksum_offload: value = dpsoc->wlan_cfg_ctx->p2p_tcp_udp_checksumoffload; break; case cfg_dp_enable_nan_ip_tcp_udp_checksum_offload: value = dpsoc->wlan_cfg_ctx->nan_tcp_udp_checksumoffload; break; case cfg_dp_enable_ip_tcp_udp_checksum_offload: value = dpsoc->wlan_cfg_ctx->tcp_udp_checksumoffload; break; case cfg_dp_disable_legacy_mode_csum_offload: value = dpsoc->wlan_cfg_ctx-> legacy_mode_checksumoffload_disable; break; case cfg_dp_tso_enable: value = dpsoc->wlan_cfg_ctx->tso_enabled; break; case cfg_dp_lro_enable: value = dpsoc->wlan_cfg_ctx->lro_enabled; break; case cfg_dp_gro_enable: value = dpsoc->wlan_cfg_ctx->gro_enabled; break; case cfg_dp_tc_based_dyn_gro_enable: value = dpsoc->wlan_cfg_ctx->tc_based_dynamic_gro; break; case cfg_dp_tc_ingress_prio: value = dpsoc->wlan_cfg_ctx->tc_ingress_prio; break; case cfg_dp_sg_enable: value = dpsoc->wlan_cfg_ctx->sg_enabled; break; case cfg_dp_tx_flow_start_queue_offset: value = dpsoc->wlan_cfg_ctx->tx_flow_start_queue_offset; break; case cfg_dp_tx_flow_stop_queue_threshold: value = dpsoc->wlan_cfg_ctx->tx_flow_stop_queue_threshold; break; case cfg_dp_disable_intra_bss_fwd: value = dpsoc->wlan_cfg_ctx->disable_intra_bss_fwd; break; case cfg_dp_pktlog_buffer_size: value = dpsoc->wlan_cfg_ctx->pktlog_buffer_size; break; case cfg_dp_wow_check_rx_pending: value = dpsoc->wlan_cfg_ctx->wow_check_rx_pending_enable; break; case cfg_dp_local_pkt_capture: value = wlan_cfg_get_local_pkt_capture(dpsoc->wlan_cfg_ctx); break; default: value = 0; } return value; } #ifdef PEER_FLOW_CONTROL /** * dp_tx_flow_ctrl_configure_pdev() - Configure flow control params * @soc_handle: datapath soc handle * @pdev_id: id of datapath pdev handle * @param: ol ath params * @value: value of the flag * @buff: Buffer to be passed * * Implemented this function same as legacy function. In legacy code, single * function is used to display stats and update pdev params. * * Return: 0 for success. nonzero for failure. */ static uint32_t dp_tx_flow_ctrl_configure_pdev(struct cdp_soc_t *soc_handle, uint8_t pdev_id, enum _dp_param_t param, uint32_t value, void *buff) { struct dp_soc *soc = (struct dp_soc *)soc_handle; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc, pdev_id); if (qdf_unlikely(!pdev)) return 1; soc = pdev->soc; if (!soc) return 1; switch (param) { #ifdef QCA_ENH_V3_STATS_SUPPORT case DP_PARAM_VIDEO_DELAY_STATS_FC: if (value) pdev->delay_stats_flag = true; else pdev->delay_stats_flag = false; break; case DP_PARAM_VIDEO_STATS_FC: qdf_print("------- TID Stats ------\n"); dp_pdev_print_tid_stats(pdev); qdf_print("------ Delay Stats ------\n"); dp_pdev_print_delay_stats(pdev); qdf_print("------ Rx Error Stats ------\n"); dp_pdev_print_rx_error_stats(pdev); break; #endif case DP_PARAM_TOTAL_Q_SIZE: { uint32_t tx_min, tx_max; tx_min = wlan_cfg_get_min_tx_desc(soc->wlan_cfg_ctx); tx_max = wlan_cfg_get_num_tx_desc(soc->wlan_cfg_ctx); if (!buff) { if ((value >= tx_min) && (value <= tx_max)) { pdev->num_tx_allowed = value; } else { dp_tx_info("%pK: Failed to update num_tx_allowed, Q_min = %d Q_max = %d", soc, tx_min, tx_max); break; } } else { *(int *)buff = pdev->num_tx_allowed; } } break; default: dp_tx_info("%pK: not handled param %d ", soc, param); break; } return 0; } #endif #ifdef DP_UMAC_HW_RESET_SUPPORT /** * dp_reset_interrupt_ring_masks() - Reset rx interrupt masks * @soc: dp soc handle * * Return: void */ static void dp_reset_interrupt_ring_masks(struct dp_soc *soc) { struct dp_intr_bkp *intr_bkp; struct dp_intr *intr_ctx; int num_ctxt = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); int i; intr_bkp = (struct dp_intr_bkp *)qdf_mem_malloc_atomic(sizeof(struct dp_intr_bkp) * num_ctxt); qdf_assert_always(intr_bkp); soc->umac_reset_ctx.intr_ctx_bkp = intr_bkp; for (i = 0; i < num_ctxt; i++) { intr_ctx = &soc->intr_ctx[i]; intr_bkp->tx_ring_mask = intr_ctx->tx_ring_mask; intr_bkp->rx_ring_mask = intr_ctx->rx_ring_mask; intr_bkp->rx_mon_ring_mask = intr_ctx->rx_mon_ring_mask; intr_bkp->rx_err_ring_mask = intr_ctx->rx_err_ring_mask; intr_bkp->rx_wbm_rel_ring_mask = intr_ctx->rx_wbm_rel_ring_mask; intr_bkp->reo_status_ring_mask = intr_ctx->reo_status_ring_mask; intr_bkp->rxdma2host_ring_mask = intr_ctx->rxdma2host_ring_mask; intr_bkp->host2rxdma_ring_mask = intr_ctx->host2rxdma_ring_mask; intr_bkp->host2rxdma_mon_ring_mask = intr_ctx->host2rxdma_mon_ring_mask; intr_bkp->tx_mon_ring_mask = intr_ctx->tx_mon_ring_mask; intr_ctx->tx_ring_mask = 0; intr_ctx->rx_ring_mask = 0; intr_ctx->rx_mon_ring_mask = 0; intr_ctx->rx_err_ring_mask = 0; intr_ctx->rx_wbm_rel_ring_mask = 0; intr_ctx->reo_status_ring_mask = 0; intr_ctx->rxdma2host_ring_mask = 0; intr_ctx->host2rxdma_ring_mask = 0; intr_ctx->host2rxdma_mon_ring_mask = 0; intr_ctx->tx_mon_ring_mask = 0; intr_bkp++; } } /** * dp_restore_interrupt_ring_masks() - Restore rx interrupt masks * @soc: dp soc handle * * Return: void */ static void dp_restore_interrupt_ring_masks(struct dp_soc *soc) { struct dp_intr_bkp *intr_bkp = soc->umac_reset_ctx.intr_ctx_bkp; struct dp_intr_bkp *intr_bkp_base = intr_bkp; struct dp_intr *intr_ctx; int num_ctxt = wlan_cfg_get_num_contexts(soc->wlan_cfg_ctx); int i; if (!intr_bkp) return; for (i = 0; i < num_ctxt; i++) { intr_ctx = &soc->intr_ctx[i]; intr_ctx->tx_ring_mask = intr_bkp->tx_ring_mask; intr_ctx->rx_ring_mask = intr_bkp->rx_ring_mask; intr_ctx->rx_mon_ring_mask = intr_bkp->rx_mon_ring_mask; intr_ctx->rx_err_ring_mask = intr_bkp->rx_err_ring_mask; intr_ctx->rx_wbm_rel_ring_mask = intr_bkp->rx_wbm_rel_ring_mask; intr_ctx->reo_status_ring_mask = intr_bkp->reo_status_ring_mask; intr_ctx->rxdma2host_ring_mask = intr_bkp->rxdma2host_ring_mask; intr_ctx->host2rxdma_ring_mask = intr_bkp->host2rxdma_ring_mask; intr_ctx->host2rxdma_mon_ring_mask = intr_bkp->host2rxdma_mon_ring_mask; intr_ctx->tx_mon_ring_mask = intr_bkp->tx_mon_ring_mask; intr_bkp++; } qdf_mem_free(intr_bkp_base); soc->umac_reset_ctx.intr_ctx_bkp = NULL; } /** * dp_resume_tx_hardstart() - Restore the old Tx hardstart functions * @soc: dp soc handle * * Return: void */ static void dp_resume_tx_hardstart(struct dp_soc *soc) { struct dp_vdev *vdev; struct ol_txrx_hardtart_ctxt ctxt = {0}; struct cdp_ctrl_objmgr_psoc *psoc = soc->ctrl_psoc; int i; for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_pdev *pdev = soc->pdev_list[i]; if (!pdev) continue; TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { uint8_t vdev_id = vdev->vdev_id; dp_vdev_fetch_tx_handler(vdev, soc, &ctxt); soc->cdp_soc.ol_ops->dp_update_tx_hardstart(psoc, vdev_id, &ctxt); } } } /** * dp_pause_tx_hardstart() - Register Tx hardstart functions to drop packets * @soc: dp soc handle * * Return: void */ static void dp_pause_tx_hardstart(struct dp_soc *soc) { struct dp_vdev *vdev; struct ol_txrx_hardtart_ctxt ctxt; struct cdp_ctrl_objmgr_psoc *psoc = soc->ctrl_psoc; int i; ctxt.tx = &dp_tx_drop; ctxt.tx_fast = &dp_tx_drop; ctxt.tx_exception = &dp_tx_exc_drop; for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_pdev *pdev = soc->pdev_list[i]; if (!pdev) continue; TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { uint8_t vdev_id = vdev->vdev_id; soc->cdp_soc.ol_ops->dp_update_tx_hardstart(psoc, vdev_id, &ctxt); } } } /** * dp_unregister_notify_umac_pre_reset_fw_callback() - unregister notify_fw_cb * @soc: dp soc handle * * Return: void */ static inline void dp_unregister_notify_umac_pre_reset_fw_callback(struct dp_soc *soc) { soc->notify_fw_callback = NULL; } /** * dp_check_n_notify_umac_prereset_done() - Send pre reset done to firmware * @soc: dp soc handle * * Return: void */ static inline void dp_check_n_notify_umac_prereset_done(struct dp_soc *soc) { /* Some Cpu(s) is processing the umac rings*/ if (soc->service_rings_running) return; /* Unregister the callback */ dp_unregister_notify_umac_pre_reset_fw_callback(soc); /* Check if notify was already sent by any other thread */ if (qdf_atomic_test_and_set_bit(DP_UMAC_RESET_NOTIFY_DONE, &soc->service_rings_running)) return; /* Notify the firmware that Umac pre reset is complete */ dp_umac_reset_notify_action_completion(soc, UMAC_RESET_ACTION_DO_PRE_RESET); } /** * dp_register_notify_umac_pre_reset_fw_callback() - register notify_fw_cb * @soc: dp soc handle * * Return: void */ static inline void dp_register_notify_umac_pre_reset_fw_callback(struct dp_soc *soc) { soc->notify_fw_callback = dp_check_n_notify_umac_prereset_done; } #ifdef DP_UMAC_HW_HARD_RESET /** * dp_set_umac_regs() - Reinitialize host umac registers * @soc: dp soc handle * * Return: void */ static void dp_set_umac_regs(struct dp_soc *soc) { int i; struct hal_reo_params reo_params; qdf_mem_zero(&reo_params, sizeof(reo_params)); if (wlan_cfg_is_rx_hash_enabled(soc->wlan_cfg_ctx)) { if (soc->arch_ops.reo_remap_config(soc, &reo_params.remap0, &reo_params.remap1, &reo_params.remap2)) reo_params.rx_hash_enabled = true; else reo_params.rx_hash_enabled = false; } reo_params.reo_qref = &soc->reo_qref; hal_reo_setup(soc->hal_soc, &reo_params, 0); soc->arch_ops.dp_cc_reg_cfg_init(soc, true); for (i = 0; i < PCP_TID_MAP_MAX; i++) hal_tx_update_pcp_tid_map(soc->hal_soc, soc->pcp_tid_map[i], i); for (i = 0; i < MAX_PDEV_CNT; i++) { struct dp_vdev *vdev = NULL; struct dp_pdev *pdev = soc->pdev_list[i]; if (!pdev) continue; for (i = 0; i < soc->num_hw_dscp_tid_map; i++) hal_tx_set_dscp_tid_map(soc->hal_soc, pdev->dscp_tid_map[i], i); TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { soc->arch_ops.dp_bank_reconfig(soc, vdev); soc->arch_ops.dp_reconfig_tx_vdev_mcast_ctrl(soc, vdev); } } } #else static void dp_set_umac_regs(struct dp_soc *soc) { } #endif /** * dp_reinit_rings() - Reinitialize host managed rings * @soc: dp soc handle * * Return: QDF_STATUS */ static void dp_reinit_rings(struct dp_soc *soc) { unsigned long end; dp_soc_srng_deinit(soc); dp_hw_link_desc_ring_deinit(soc); /* Busy wait for 2 ms to make sure the rings are in idle state * before we enable them again */ end = jiffies + msecs_to_jiffies(2); while (time_before(jiffies, end)) ; dp_hw_link_desc_ring_init(soc); dp_link_desc_ring_replenish(soc, WLAN_INVALID_PDEV_ID); dp_soc_srng_init(soc); } /** * dp_umac_reset_action_trigger_recovery() - Handle FW Umac recovery trigger * @soc: dp soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_umac_reset_action_trigger_recovery(struct dp_soc *soc) { enum umac_reset_action action = UMAC_RESET_ACTION_DO_TRIGGER_RECOVERY; return dp_umac_reset_notify_action_completion(soc, action); } #ifdef WLAN_SUPPORT_PPEDS /** * dp_umac_reset_service_handle_n_notify_done() * Handle Umac pre reset for direct switch * @soc: dp soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_umac_reset_service_handle_n_notify_done(struct dp_soc *soc) { if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || !soc->arch_ops.txrx_soc_ppeds_service_status_update || !soc->arch_ops.txrx_soc_ppeds_interrupt_stop) goto non_ppeds; /* * Check if ppeds is enabled on SoC. */ if (!soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) goto non_ppeds; /* * Start the UMAC pre reset done service. */ soc->arch_ops.txrx_soc_ppeds_service_status_update(soc, true); dp_register_notify_umac_pre_reset_fw_callback(soc); soc->arch_ops.txrx_soc_ppeds_interrupt_stop(soc); dp_soc_ppeds_stop((struct cdp_soc_t *)soc); /* * UMAC pre reset service complete */ soc->arch_ops.txrx_soc_ppeds_service_status_update(soc, false); soc->umac_reset_ctx.nbuf_list = NULL; return QDF_STATUS_SUCCESS; non_ppeds: dp_register_notify_umac_pre_reset_fw_callback(soc); dp_umac_reset_trigger_pre_reset_notify_cb(soc); soc->umac_reset_ctx.nbuf_list = NULL; return QDF_STATUS_SUCCESS; } static inline void dp_umac_reset_ppeds_txdesc_pool_reset(struct dp_soc *soc, qdf_nbuf_t *nbuf_list) { if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || !soc->arch_ops.txrx_soc_ppeds_txdesc_pool_reset) return; /* * Deinit of PPEDS Tx desc rings. */ if (soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) soc->arch_ops.txrx_soc_ppeds_txdesc_pool_reset(soc, nbuf_list); } static inline void dp_umac_reset_ppeds_start(struct dp_soc *soc) { if (!soc->arch_ops.txrx_soc_ppeds_enabled_check || !soc->arch_ops.txrx_soc_ppeds_start || !soc->arch_ops.txrx_soc_ppeds_interrupt_start) return; /* * Start PPEDS node and enable interrupt. */ if (soc->arch_ops.txrx_soc_ppeds_enabled_check(soc)) { soc->arch_ops.txrx_soc_ppeds_start(soc); soc->arch_ops.txrx_soc_ppeds_interrupt_start(soc); } } #else static QDF_STATUS dp_umac_reset_service_handle_n_notify_done(struct dp_soc *soc) { dp_register_notify_umac_pre_reset_fw_callback(soc); dp_umac_reset_trigger_pre_reset_notify_cb(soc); soc->umac_reset_ctx.nbuf_list = NULL; return QDF_STATUS_SUCCESS; } static inline void dp_umac_reset_ppeds_txdesc_pool_reset(struct dp_soc *soc, qdf_nbuf_t *nbuf_list) { } static inline void dp_umac_reset_ppeds_start(struct dp_soc *soc) { } #endif /** * dp_umac_reset_handle_pre_reset() - Handle Umac prereset interrupt from FW * @soc: dp soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_umac_reset_handle_pre_reset(struct dp_soc *soc) { dp_reset_interrupt_ring_masks(soc); dp_pause_tx_hardstart(soc); dp_pause_reo_send_cmd(soc); dp_umac_reset_service_handle_n_notify_done(soc); return QDF_STATUS_SUCCESS; } /** * dp_umac_reset_handle_post_reset() - Handle Umac postreset interrupt from FW * @soc: dp soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_umac_reset_handle_post_reset(struct dp_soc *soc) { if (!soc->umac_reset_ctx.skel_enable) { bool cleanup_needed; qdf_nbuf_t *nbuf_list = &soc->umac_reset_ctx.nbuf_list; dp_set_umac_regs(soc); dp_reinit_rings(soc); dp_rx_desc_reuse(soc, nbuf_list); dp_cleanup_reo_cmd_module(soc); dp_umac_reset_ppeds_txdesc_pool_reset(soc, nbuf_list); cleanup_needed = dp_get_global_tx_desc_cleanup_flag(soc); dp_tx_desc_pool_cleanup(soc, nbuf_list, cleanup_needed); dp_reset_tid_q_setup(soc); } return dp_umac_reset_notify_action_completion(soc, UMAC_RESET_ACTION_DO_POST_RESET_START); } /** * dp_umac_reset_handle_post_reset_complete() - Handle Umac postreset_complete * interrupt from FW * @soc: dp soc handle * * Return: QDF_STATUS */ static QDF_STATUS dp_umac_reset_handle_post_reset_complete(struct dp_soc *soc) { QDF_STATUS status; qdf_nbuf_t nbuf_list = soc->umac_reset_ctx.nbuf_list; uint8_t mac_id; soc->umac_reset_ctx.nbuf_list = NULL; soc->service_rings_running = 0; dp_resume_reo_send_cmd(soc); dp_umac_reset_ppeds_start(soc); dp_restore_interrupt_ring_masks(soc); dp_resume_tx_hardstart(soc); dp_reset_global_tx_desc_cleanup_flag(soc); status = dp_umac_reset_notify_action_completion(soc, UMAC_RESET_ACTION_DO_POST_RESET_COMPLETE); while (nbuf_list) { qdf_nbuf_t nbuf = nbuf_list->next; qdf_nbuf_free(nbuf_list); nbuf_list = nbuf; } /* * at pre-reset if in_use descriptors are not sufficient we replenish * only 1/3 of the ring. Try to replenish full ring here. */ for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) { struct dp_srng *dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id]; struct rx_desc_pool *rx_desc_pool = &soc->rx_desc_buf[mac_id]; dp_rx_buffers_lt_replenish_simple(soc, mac_id, dp_rxdma_srng, rx_desc_pool, true); } dp_umac_reset_info("Umac reset done on soc %pK\n trigger start : %u us " "trigger done : %u us prereset : %u us\n" "postreset : %u us \n postreset complete: %u us \n", soc, soc->umac_reset_ctx.ts.trigger_done - soc->umac_reset_ctx.ts.trigger_start, soc->umac_reset_ctx.ts.pre_reset_done - soc->umac_reset_ctx.ts.pre_reset_start, soc->umac_reset_ctx.ts.post_reset_done - soc->umac_reset_ctx.ts.post_reset_start, soc->umac_reset_ctx.ts.post_reset_complete_done - soc->umac_reset_ctx.ts.post_reset_complete_start); return status; } #endif #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 static void dp_set_pkt_capture_mode(struct cdp_soc_t *soc_handle, bool val) { struct dp_soc *soc = (struct dp_soc *)soc_handle; soc->wlan_cfg_ctx->pkt_capture_mode = val; } #endif #ifdef HW_TX_DELAY_STATS_ENABLE /** * dp_enable_disable_vdev_tx_delay_stats() - Start/Stop tx delay stats capture * @soc_hdl: DP soc handle * @vdev_id: vdev id * @value: value * * Return: None */ static void dp_enable_disable_vdev_tx_delay_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t value) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = NULL; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return; vdev->hw_tx_delay_stats_enabled = value; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } /** * dp_check_vdev_tx_delay_stats_enabled() - check the feature is enabled or not * @soc_hdl: DP soc handle * @vdev_id: vdev id * * Return: 1 if enabled, 0 if disabled */ static uint8_t dp_check_vdev_tx_delay_stats_enabled(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev; uint8_t ret_val = 0; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return ret_val; ret_val = vdev->hw_tx_delay_stats_enabled; dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return ret_val; } #endif #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) static void dp_recovery_vdev_flush_peers(struct cdp_soc_t *cdp_soc, uint8_t vdev_id, bool mlo_peers_only) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; struct dp_vdev *vdev; vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) return; dp_vdev_flush_peers((struct cdp_vdev *)vdev, false, mlo_peers_only); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); } #endif #ifdef QCA_GET_TSF_VIA_REG /** * dp_get_tsf_time() - get tsf time * @soc_hdl: Datapath soc handle * @tsf_id: TSF identifier * @mac_id: mac_id * @tsf: pointer to update tsf value * @tsf_sync_soc_time: pointer to update tsf sync time * * Return: None. */ static inline void dp_get_tsf_time(struct cdp_soc_t *soc_hdl, uint32_t tsf_id, uint32_t mac_id, uint64_t *tsf, uint64_t *tsf_sync_soc_time) { hal_get_tsf_time(((struct dp_soc *)soc_hdl)->hal_soc, tsf_id, mac_id, tsf, tsf_sync_soc_time); } #else static inline void dp_get_tsf_time(struct cdp_soc_t *soc_hdl, uint32_t tsf_id, uint32_t mac_id, uint64_t *tsf, uint64_t *tsf_sync_soc_time) { } #endif /** * dp_get_tsf2_scratch_reg() - get tsf2 offset from the scratch register * @soc_hdl: Datapath soc handle * @mac_id: mac_id * @value: pointer to update tsf2 offset value * * Return: None. */ static inline void dp_get_tsf2_scratch_reg(struct cdp_soc_t *soc_hdl, uint8_t mac_id, uint64_t *value) { hal_get_tsf2_offset(((struct dp_soc *)soc_hdl)->hal_soc, mac_id, value); } /** * dp_get_tqm_scratch_reg() - get tqm offset from the scratch register * @soc_hdl: Datapath soc handle * @value: pointer to update tqm offset value * * Return: None. */ static inline void dp_get_tqm_scratch_reg(struct cdp_soc_t *soc_hdl, uint64_t *value) { hal_get_tqm_offset(((struct dp_soc *)soc_hdl)->hal_soc, value); } /** * dp_set_tx_pause() - Pause or resume tx path * @soc_hdl: Datapath soc handle * @flag: set or clear is_tx_pause * * Return: None. */ static inline void dp_set_tx_pause(struct cdp_soc_t *soc_hdl, bool flag) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); soc->is_tx_pause = flag; } static inline uint64_t dp_rx_fisa_get_cmem_base(struct cdp_soc_t *soc_hdl, uint64_t size) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); if (soc->arch_ops.dp_get_fst_cmem_base) return soc->arch_ops.dp_get_fst_cmem_base(soc, size); return 0; } #ifdef DP_TX_PACKET_INSPECT_FOR_ILP /** * dp_evaluate_update_tx_ilp_config() - Evaluate and update DP TX * ILP configuration * @soc_hdl: CDP SOC handle * @num_msdu_idx_map: Number of HTT msdu index to qtype map in array * @msdu_idx_map_arr: Pointer to HTT msdu index to qtype map array * * This function will check: (a) TX ILP INI configuration, * (b) index 3 value in array same as HTT_MSDU_QTYPE_LATENCY_TOLERANT, * only if both (a) and (b) condition is met, then TX ILP feature is * considered to be enabled. * * Return: Final updated TX ILP enable result in dp_soc, * true is enabled, false is not */ static bool dp_evaluate_update_tx_ilp_config(struct cdp_soc_t *soc_hdl, uint8_t num_msdu_idx_map, uint8_t *msdu_idx_map_arr) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); bool enable_tx_ilp = false; /** * Check INI configuration firstly, if it's disabled, * then keep feature disabled. */ if (!wlan_cfg_get_tx_ilp_inspect_config(soc->wlan_cfg_ctx)) { dp_info("TX ILP INI is disabled already"); goto update_tx_ilp; } /* Check if the msdu index to qtype map table is valid */ if (num_msdu_idx_map != HTT_MSDUQ_MAX_INDEX || !msdu_idx_map_arr) { dp_info("Invalid msdu_idx qtype map num: 0x%x, arr_addr %pK", num_msdu_idx_map, msdu_idx_map_arr); goto update_tx_ilp; } dp_info("msdu_idx_map_arr idx 0x%x value 0x%x", HTT_MSDUQ_INDEX_CUSTOM_PRIO_1, msdu_idx_map_arr[HTT_MSDUQ_INDEX_CUSTOM_PRIO_1]); if (HTT_MSDU_QTYPE_USER_SPECIFIED == msdu_idx_map_arr[HTT_MSDUQ_INDEX_CUSTOM_PRIO_1]) enable_tx_ilp = true; update_tx_ilp: soc->tx_ilp_enable = enable_tx_ilp; dp_info("configure tx ilp enable %d", soc->tx_ilp_enable); return soc->tx_ilp_enable; } #endif static struct cdp_cmn_ops dp_ops_cmn = { .txrx_soc_attach_target = dp_soc_attach_target_wifi3, .txrx_vdev_attach = dp_vdev_attach_wifi3, .txrx_vdev_detach = dp_vdev_detach_wifi3, .txrx_pdev_attach = dp_pdev_attach_wifi3, .txrx_pdev_post_attach = dp_pdev_post_attach_wifi3, .txrx_pdev_detach = dp_pdev_detach_wifi3, .txrx_pdev_deinit = dp_pdev_deinit_wifi3, .txrx_peer_create = dp_peer_create_wifi3, .txrx_peer_setup = dp_peer_setup_wifi3_wrapper, #ifdef FEATURE_AST .txrx_peer_teardown = dp_peer_teardown_wifi3, #else .txrx_peer_teardown = NULL, #endif .txrx_peer_add_ast = dp_peer_add_ast_wifi3, .txrx_peer_update_ast = dp_peer_update_ast_wifi3, .txrx_peer_get_ast_info_by_soc = dp_peer_get_ast_info_by_soc_wifi3, .txrx_peer_get_ast_info_by_pdev = dp_peer_get_ast_info_by_pdevid_wifi3, .txrx_peer_ast_delete_by_soc = dp_peer_ast_entry_del_by_soc, .txrx_peer_ast_delete_by_pdev = dp_peer_ast_entry_del_by_pdev, .txrx_peer_HMWDS_ast_delete = dp_peer_HMWDS_ast_entry_del, .txrx_peer_delete = dp_peer_delete_wifi3, #ifdef DP_RX_UDP_OVER_PEER_ROAM .txrx_update_roaming_peer = dp_update_roaming_peer_wifi3, #endif .txrx_vdev_register = dp_vdev_register_wifi3, .txrx_soc_detach = dp_soc_detach_wifi3, .txrx_soc_deinit = dp_soc_deinit_wifi3, .txrx_soc_init = dp_soc_init_wifi3, #ifndef QCA_HOST_MODE_WIFI_DISABLED .txrx_tso_soc_attach = dp_tso_soc_attach, .txrx_tso_soc_detach = dp_tso_soc_detach, .tx_send = dp_tx_send, .tx_send_exc = dp_tx_send_exception, #endif .set_tx_pause = dp_set_tx_pause, .txrx_pdev_init = dp_pdev_init_wifi3, .txrx_get_vdev_mac_addr = dp_get_vdev_mac_addr_wifi3, .txrx_get_ctrl_pdev_from_vdev = dp_get_ctrl_pdev_from_vdev_wifi3, .txrx_ath_getstats = dp_get_device_stats, #ifndef WLAN_SOFTUMAC_SUPPORT .addba_requestprocess = dp_addba_requestprocess_wifi3, .addba_responsesetup = dp_addba_responsesetup_wifi3, .addba_resp_tx_completion = dp_addba_resp_tx_completion_wifi3, .delba_process = dp_delba_process_wifi3, .set_addba_response = dp_set_addba_response, .flush_cache_rx_queue = NULL, .tid_update_ba_win_size = dp_rx_tid_update_ba_win_size, #endif /* TODO: get API's for dscp-tid need to be added*/ .set_vdev_dscp_tid_map = dp_set_vdev_dscp_tid_map_wifi3, .set_pdev_dscp_tid_map = dp_set_pdev_dscp_tid_map_wifi3, .txrx_get_total_per = dp_get_total_per, .txrx_stats_request = dp_txrx_stats_request, .txrx_get_peer_mac_from_peer_id = dp_get_peer_mac_from_peer_id, .display_stats = dp_txrx_dump_stats, .notify_asserted_soc = dp_soc_notify_asserted_soc, .txrx_intr_attach = dp_soc_interrupt_attach_wrapper, .txrx_intr_detach = dp_soc_interrupt_detach_wrapper, .txrx_ppeds_stop = dp_soc_ppeds_stop, .set_key_sec_type = dp_set_key_sec_type_wifi3, .update_config_parameters = dp_update_config_parameters, /* TODO: Add other functions */ .txrx_data_tx_cb_set = dp_txrx_data_tx_cb_set, .get_dp_txrx_handle = dp_pdev_get_dp_txrx_handle, .set_dp_txrx_handle = dp_pdev_set_dp_txrx_handle, .get_vdev_dp_ext_txrx_handle = dp_vdev_get_dp_ext_handle, .set_vdev_dp_ext_txrx_handle = dp_vdev_set_dp_ext_handle, .get_soc_dp_txrx_handle = dp_soc_get_dp_txrx_handle, .set_soc_dp_txrx_handle = dp_soc_set_dp_txrx_handle, .map_pdev_to_lmac = dp_soc_map_pdev_to_lmac, .handle_mode_change = dp_soc_handle_pdev_mode_change, .set_pdev_status_down = dp_soc_set_pdev_status_down, .txrx_peer_reset_ast = dp_wds_reset_ast_wifi3, .txrx_peer_reset_ast_table = dp_wds_reset_ast_table_wifi3, .txrx_peer_flush_ast_table = dp_wds_flush_ast_table_wifi3, .txrx_peer_map_attach = dp_peer_map_attach_wifi3, .set_soc_param = dp_soc_set_param, .txrx_get_os_rx_handles_from_vdev = dp_get_os_rx_handles_from_vdev_wifi3, #ifndef WLAN_SOFTUMAC_SUPPORT .set_pn_check = dp_set_pn_check_wifi3, .txrx_set_ba_aging_timeout = dp_set_ba_aging_timeout, .txrx_get_ba_aging_timeout = dp_get_ba_aging_timeout, .delba_tx_completion = dp_delba_tx_completion_wifi3, .set_pdev_pcp_tid_map = dp_set_pdev_pcp_tid_map_wifi3, .set_vdev_pcp_tid_map = dp_set_vdev_pcp_tid_map_wifi3, #endif .get_dp_capabilities = dp_get_cfg_capabilities, .txrx_get_cfg = dp_get_cfg, .set_rate_stats_ctx = dp_soc_set_rate_stats_ctx, .get_rate_stats_ctx = dp_soc_get_rate_stats_ctx, .txrx_peer_flush_rate_stats = dp_peer_flush_rate_stats, .txrx_flush_rate_stats_request = dp_flush_rate_stats_req, .txrx_peer_get_peerstats_ctx = dp_peer_get_peerstats_ctx, .txrx_cp_peer_del_response = dp_cp_peer_del_resp_handler, #ifdef QCA_MULTIPASS_SUPPORT .set_vlan_groupkey = dp_set_vlan_groupkey, #endif .get_peer_mac_list = dp_get_peer_mac_list, .get_peer_id = dp_get_peer_id, #ifdef QCA_SUPPORT_WDS_EXTENDED .set_wds_ext_peer_rx = dp_wds_ext_set_peer_rx, .get_wds_ext_peer_osif_handle = dp_wds_ext_get_peer_osif_handle, .set_wds_ext_peer_bit = dp_wds_ext_set_peer_bit, #endif /* QCA_SUPPORT_WDS_EXTENDED */ #if defined(FEATURE_RUNTIME_PM) || defined(DP_POWER_SAVE) .txrx_drain = dp_drain_txrx, #endif #if defined(FEATURE_RUNTIME_PM) .set_rtpm_tput_policy = dp_set_rtpm_tput_policy_requirement, #endif #ifdef WLAN_SYSFS_DP_STATS .txrx_sysfs_fill_stats = dp_sysfs_fill_stats, .txrx_sysfs_set_stat_type = dp_sysfs_set_stat_type, #endif /* WLAN_SYSFS_DP_STATS */ #ifdef WLAN_FEATURE_PKT_CAPTURE_V2 .set_pkt_capture_mode = dp_set_pkt_capture_mode, #endif #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) .txrx_recovery_vdev_flush_peers = dp_recovery_vdev_flush_peers, #endif .txrx_umac_reset_deinit = dp_soc_umac_reset_deinit, .txrx_umac_reset_init = dp_soc_umac_reset_init, .txrx_get_tsf_time = dp_get_tsf_time, .txrx_get_tsf2_offset = dp_get_tsf2_scratch_reg, .txrx_get_tqm_offset = dp_get_tqm_scratch_reg, #ifdef WLAN_SUPPORT_RX_FISA .get_fst_cmem_base = dp_rx_fisa_get_cmem_base, #endif #ifdef WLAN_SUPPORT_DPDK .dpdk_get_ring_info = dp_dpdk_get_ring_info, .cfgmgr_get_soc_info = dp_cfgmgr_get_soc_info, .cfgmgr_get_vdev_info = dp_cfgmgr_get_vdev_info, .cfgmgr_get_peer_info = dp_cfgmgr_get_peer_info, .cfgmgr_get_vdev_create_evt_info = dp_cfgmgr_get_vdev_create_evt_info, .cfgmgr_get_peer_create_evt_info = dp_cfgmgr_get_peer_create_evt_info, #endif }; static struct cdp_ctrl_ops dp_ops_ctrl = { .txrx_peer_authorize = dp_peer_authorize, .txrx_peer_get_authorize = dp_peer_get_authorize, #ifdef VDEV_PEER_PROTOCOL_COUNT .txrx_enable_peer_protocol_count = dp_enable_vdev_peer_protocol_count, .txrx_set_peer_protocol_drop_mask = dp_enable_vdev_peer_protocol_drop_mask, .txrx_is_peer_protocol_count_enabled = dp_is_vdev_peer_protocol_count_enabled, .txrx_get_peer_protocol_drop_mask = dp_get_vdev_peer_protocol_drop_mask, #endif .txrx_set_vdev_param = dp_set_vdev_param_wrapper, .txrx_set_psoc_param = dp_set_psoc_param, .txrx_get_psoc_param = dp_get_psoc_param, #ifndef WLAN_SOFTUMAC_SUPPORT .txrx_set_pdev_reo_dest = dp_set_pdev_reo_dest, .txrx_get_pdev_reo_dest = dp_get_pdev_reo_dest, #endif .txrx_get_sec_type = dp_get_sec_type, .txrx_wdi_event_sub = dp_wdi_event_sub, .txrx_wdi_event_unsub = dp_wdi_event_unsub, .txrx_set_pdev_param = dp_set_pdev_param, .txrx_get_pdev_param = dp_get_pdev_param, #ifdef WLAN_FEATURE_11BE_MLO .txrx_set_peer_param = dp_set_peer_param_wrapper, #else .txrx_set_peer_param = dp_set_peer_param, #endif .txrx_get_peer_param = dp_get_peer_param, #ifdef VDEV_PEER_PROTOCOL_COUNT .txrx_peer_protocol_cnt = dp_peer_stats_update_protocol_cnt, #endif #ifdef WLAN_SUPPORT_MSCS .txrx_record_mscs_params = dp_record_mscs_params, #endif .set_key = dp_set_michael_key, .txrx_get_vdev_param = dp_get_vdev_param, .calculate_delay_stats = dp_calculate_delay_stats, #ifdef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG .txrx_update_pdev_rx_protocol_tag = dp_update_pdev_rx_protocol_tag, #ifdef WLAN_SUPPORT_RX_TAG_STATISTICS .txrx_dump_pdev_rx_protocol_tag_stats = dp_dump_pdev_rx_protocol_tag_stats, #endif /* WLAN_SUPPORT_RX_TAG_STATISTICS */ #endif /* WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG */ #ifdef WLAN_SUPPORT_RX_FLOW_TAG .txrx_set_rx_flow_tag = dp_set_rx_flow_tag, .txrx_dump_rx_flow_tag_stats = dp_dump_rx_flow_tag_stats, #endif /* WLAN_SUPPORT_RX_FLOW_TAG */ #ifdef QCA_MULTIPASS_SUPPORT .txrx_peer_set_vlan_id = dp_peer_set_vlan_id, #endif /*QCA_MULTIPASS_SUPPORT*/ #if defined(WLAN_FEATURE_TSF_AUTO_REPORT) || defined(WLAN_CONFIG_TX_DELAY) .txrx_set_delta_tsf = dp_set_delta_tsf, #endif #ifdef WLAN_FEATURE_TSF_UPLINK_DELAY .txrx_set_tsf_ul_delay_report = dp_set_tsf_ul_delay_report, .txrx_get_uplink_delay = dp_get_uplink_delay, #endif #ifdef QCA_UNDECODED_METADATA_SUPPORT .txrx_set_pdev_phyrx_error_mask = dp_set_pdev_phyrx_error_mask, .txrx_get_pdev_phyrx_error_mask = dp_get_pdev_phyrx_error_mask, #endif .txrx_peer_flush_frags = dp_peer_flush_frags, #ifdef DP_UMAC_HW_RESET_SUPPORT .get_umac_reset_in_progress_state = dp_get_umac_reset_in_progress_state, #endif #ifdef WLAN_SUPPORT_RX_FISA .txrx_fisa_config = dp_fisa_config, #endif }; static struct cdp_me_ops dp_ops_me = { #ifndef QCA_HOST_MODE_WIFI_DISABLED #ifdef ATH_SUPPORT_IQUE .tx_me_alloc_descriptor = dp_tx_me_alloc_descriptor, .tx_me_free_descriptor = dp_tx_me_free_descriptor, .tx_me_convert_ucast = dp_tx_me_send_convert_ucast, #endif #endif }; static struct cdp_host_stats_ops dp_ops_host_stats = { .txrx_per_peer_stats = dp_get_host_peer_stats, .get_fw_peer_stats = dp_get_fw_peer_stats, .get_htt_stats = dp_get_htt_stats, .txrx_stats_publish = dp_txrx_stats_publish, .txrx_get_vdev_stats = dp_txrx_get_vdev_stats, .txrx_get_peer_stats = dp_txrx_get_peer_stats, .txrx_get_peer_stats_based_on_peer_type = dp_txrx_get_peer_stats_based_on_peer_type, .txrx_get_soc_stats = dp_txrx_get_soc_stats, .txrx_get_peer_stats_param = dp_txrx_get_peer_stats_param, .txrx_get_per_link_stats = dp_txrx_get_per_link_peer_stats, .txrx_reset_peer_stats = dp_txrx_reset_peer_stats, .txrx_get_pdev_stats = dp_txrx_get_pdev_stats, #if defined(IPA_OFFLOAD) && defined(QCA_ENHANCED_STATS_SUPPORT) .txrx_get_peer_stats = dp_ipa_txrx_get_peer_stats, .txrx_get_vdev_stats = dp_ipa_txrx_get_vdev_stats, .txrx_get_pdev_stats = dp_ipa_txrx_get_pdev_stats, #endif .txrx_get_ratekbps = dp_txrx_get_ratekbps, .txrx_update_vdev_stats = dp_txrx_update_vdev_host_stats, .txrx_get_peer_delay_stats = dp_txrx_get_peer_delay_stats, .txrx_get_peer_jitter_stats = dp_txrx_get_peer_jitter_stats, #ifdef QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT .txrx_alloc_vdev_stats_id = dp_txrx_alloc_vdev_stats_id, .txrx_reset_vdev_stats_id = dp_txrx_reset_vdev_stats_id, #endif #ifdef WLAN_TX_PKT_CAPTURE_ENH .get_peer_tx_capture_stats = dp_peer_get_tx_capture_stats, .get_pdev_tx_capture_stats = dp_pdev_get_tx_capture_stats, #endif /* WLAN_TX_PKT_CAPTURE_ENH */ #ifdef HW_TX_DELAY_STATS_ENABLE .enable_disable_vdev_tx_delay_stats = dp_enable_disable_vdev_tx_delay_stats, .is_tx_delay_stats_enabled = dp_check_vdev_tx_delay_stats_enabled, #endif .txrx_get_pdev_tid_stats = dp_pdev_get_tid_stats, #ifdef WLAN_CONFIG_TELEMETRY_AGENT .txrx_pdev_telemetry_stats = dp_get_pdev_telemetry_stats, .txrx_peer_telemetry_stats = dp_get_peer_telemetry_stats, .txrx_pdev_deter_stats = dp_get_pdev_deter_stats, .txrx_peer_deter_stats = dp_get_peer_deter_stats, .txrx_update_pdev_chan_util_stats = dp_update_pdev_chan_util_stats, #endif .txrx_get_peer_extd_rate_link_stats = dp_get_peer_extd_rate_link_stats, .get_pdev_obss_stats = dp_get_obss_stats, .clear_pdev_obss_pd_stats = dp_clear_pdev_obss_pd_stats, .txrx_get_interface_stats = dp_txrx_get_interface_stats, #ifdef WLAN_FEATURE_TX_LATENCY_STATS .tx_latency_stats_fetch = dp_tx_latency_stats_fetch, .tx_latency_stats_config = dp_tx_latency_stats_config, .tx_latency_stats_register_cb = dp_tx_latency_stats_register_cb, #endif /* TODO */ }; static struct cdp_raw_ops dp_ops_raw = { /* TODO */ }; #ifdef PEER_FLOW_CONTROL static struct cdp_pflow_ops dp_ops_pflow = { dp_tx_flow_ctrl_configure_pdev, }; #endif #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) static struct cdp_cfr_ops dp_ops_cfr = { .txrx_get_cfr_rcc = dp_get_cfr_rcc, .txrx_set_cfr_rcc = dp_set_cfr_rcc, .txrx_get_cfr_dbg_stats = dp_get_cfr_dbg_stats, .txrx_clear_cfr_dbg_stats = dp_clear_cfr_dbg_stats, }; #endif #ifdef WLAN_SUPPORT_MSCS static struct cdp_mscs_ops dp_ops_mscs = { .mscs_peer_lookup_n_get_priority = dp_mscs_peer_lookup_n_get_priority, }; #endif #ifdef WLAN_SUPPORT_MESH_LATENCY static struct cdp_mesh_latency_ops dp_ops_mesh_latency = { .mesh_latency_update_peer_parameter = dp_mesh_latency_update_peer_parameter, }; #endif #ifdef WLAN_SUPPORT_SCS static struct cdp_scs_ops dp_ops_scs = { .scs_peer_lookup_n_rule_match = dp_scs_peer_lookup_n_rule_match, }; #endif #ifdef WLAN_SUPPORT_RX_FLOW_TAG static struct cdp_fse_ops dp_ops_fse = { .fse_rule_add = dp_rx_sfe_add_flow_entry, .fse_rule_delete = dp_rx_sfe_delete_flow_entry, }; #endif #ifdef CONFIG_SAWF_DEF_QUEUES static struct cdp_sawf_ops dp_ops_sawf = { .sawf_def_queues_map_req = dp_sawf_def_queues_map_req, .sawf_def_queues_unmap_req = dp_sawf_def_queues_unmap_req, .sawf_def_queues_get_map_report = dp_sawf_def_queues_get_map_report, #ifdef CONFIG_SAWF_STATS .sawf_get_peer_msduq_info = dp_sawf_get_peer_msduq_info, .txrx_get_peer_sawf_delay_stats = dp_sawf_get_peer_delay_stats, .txrx_get_peer_sawf_tx_stats = dp_sawf_get_peer_tx_stats, .sawf_mpdu_stats_req = dp_sawf_mpdu_stats_req, .sawf_mpdu_details_stats_req = dp_sawf_mpdu_details_stats_req, .txrx_sawf_set_mov_avg_params = dp_sawf_set_mov_avg_params, .txrx_sawf_set_sla_params = dp_sawf_set_sla_params, .txrx_sawf_init_telemtery_params = dp_sawf_init_telemetry_params, .telemetry_get_throughput_stats = dp_sawf_get_tx_stats, .telemetry_get_mpdu_stats = dp_sawf_get_mpdu_sched_stats, .telemetry_get_drop_stats = dp_sawf_get_drop_stats, .peer_config_ul = dp_sawf_peer_config_ul, .swaf_peer_sla_configuration = dp_swaf_peer_sla_configuration, .sawf_peer_flow_count = dp_sawf_peer_flow_count, #endif #ifdef WLAN_FEATURE_11BE_MLO_3_LINK_TX .get_peer_msduq = dp_sawf_get_peer_msduq, .sawf_3_link_peer_flow_count = dp_sawf_3_link_peer_flow_count, #endif }; #endif #ifdef DP_TX_TRACKING #define DP_TX_COMP_MAX_LATENCY_MS 60000 static bool dp_check_pending_tx(struct dp_soc *soc) { hal_soc_handle_t hal_soc = soc->hal_soc; uint32_t hp, tp, i; for (i = 0; i < soc->num_tcl_data_rings; i++) { if (dp_ipa_is_ring_ipa_tx(soc, i)) continue; hal_get_sw_hptp(hal_soc, soc->tcl_data_ring[i].hal_srng, &tp, &hp); if (hp != tp) { dp_info_rl("Pending transactions in TCL DATA Ring[%d] hp=0x%x, tp=0x%x", i, hp, tp); return true; } if (wlan_cfg_get_wbm_ring_num_for_index(soc->wlan_cfg_ctx, i) == INVALID_WBM_RING_NUM) continue; hal_get_sw_hptp(hal_soc, soc->tx_comp_ring[i].hal_srng, &tp, &hp); if (hp != tp) { dp_info_rl("Pending transactions in TX comp Ring[%d] hp=0x%x, tp=0x%x", i, hp, tp); return true; } } return false; } /** * dp_tx_comp_delay_check() - calculate time latency for tx completion per pkt * @tx_desc: tx descriptor * * Calculate time latency for tx completion per pkt and trigger self recovery * when the delay is more than threshold value. * * Return: True if delay is more than threshold */ static bool dp_tx_comp_delay_check(struct dp_tx_desc_s *tx_desc) { uint64_t time_latency, timestamp_tick = tx_desc->timestamp_tick; qdf_ktime_t current_time = qdf_ktime_real_get(); qdf_ktime_t timestamp = tx_desc->timestamp; if (dp_tx_pkt_tracepoints_enabled()) { if (!timestamp) return false; time_latency = qdf_ktime_to_ms(current_time) - qdf_ktime_to_ms(timestamp); if (time_latency >= DP_TX_COMP_MAX_LATENCY_MS) { dp_err_rl("enqueued: %llu ms, current : %llu ms", timestamp, current_time); return true; } } else { if (!timestamp_tick) return false; current_time = qdf_system_ticks(); time_latency = qdf_system_ticks_to_msecs(current_time - timestamp_tick); if (time_latency >= DP_TX_COMP_MAX_LATENCY_MS) { dp_err_rl("enqueued: %u ms, current : %u ms", qdf_system_ticks_to_msecs(timestamp_tick), qdf_system_ticks_to_msecs(current_time)); return true; } } return false; } void dp_find_missing_tx_comp(struct dp_soc *soc) { uint8_t i; uint32_t j; uint32_t num_desc, page_id, offset; uint16_t num_desc_per_page; struct dp_tx_desc_s *tx_desc = NULL; struct dp_tx_desc_pool_s *tx_desc_pool = NULL; if (dp_check_pending_tx(soc)) return; for (i = 0; i < MAX_TXDESC_POOLS; i++) { tx_desc_pool = &soc->tx_desc[i]; if (!(tx_desc_pool->pool_size) || IS_TX_DESC_POOL_STATUS_INACTIVE(tx_desc_pool) || !(tx_desc_pool->desc_pages.cacheable_pages)) continue; num_desc = tx_desc_pool->pool_size; num_desc_per_page = tx_desc_pool->desc_pages.num_element_per_page; for (j = 0; j < num_desc; j++) { page_id = j / num_desc_per_page; offset = j % num_desc_per_page; if (qdf_unlikely(!(tx_desc_pool-> desc_pages.cacheable_pages))) break; tx_desc = dp_tx_desc_find(soc, i, page_id, offset, false); if (tx_desc->magic == DP_TX_MAGIC_PATTERN_FREE) { continue; } else if (tx_desc->magic == DP_TX_MAGIC_PATTERN_INUSE) { if (dp_tx_comp_delay_check(tx_desc)) { dp_err_rl("Tx completion not rcvd for id: %u", tx_desc->id); if (tx_desc->vdev_id == DP_INVALID_VDEV_ID) { tx_desc->flags |= DP_TX_DESC_FLAG_FLUSH; dp_err_rl("Freed tx_desc %u", tx_desc->id); dp_tx_comp_free_buf(soc, tx_desc, false); dp_tx_desc_release(soc, tx_desc, i); DP_STATS_INC(soc, tx.tx_comp_force_freed, 1); } } } else { dp_err_rl("tx desc %u corrupted, flags: 0x%x", tx_desc->id, tx_desc->flags); } } } } #else inline void dp_find_missing_tx_comp(struct dp_soc *soc) { } #endif #ifdef FEATURE_RUNTIME_PM /** * dp_runtime_suspend() - ensure DP is ready to runtime suspend * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * * DP is ready to runtime suspend if there are no pending TX packets. * * Return: QDF_STATUS */ static QDF_STATUS dp_runtime_suspend(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; int32_t tx_pending; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL"); return QDF_STATUS_E_INVAL; } /* Abort if there are any pending TX packets */ tx_pending = dp_get_tx_pending(dp_pdev_to_cdp_pdev(pdev)); if (tx_pending) { dp_info_rl("%pK: Abort suspend due to pending TX packets %d", soc, tx_pending); dp_find_missing_tx_comp(soc); /* perform a force flush if tx is pending */ soc->arch_ops.dp_update_ring_hptp(soc, true); qdf_atomic_set(&soc->tx_pending_rtpm, 0); return QDF_STATUS_E_AGAIN; } if (dp_runtime_get_refcount(soc)) { dp_init_info("refcount: %d", dp_runtime_get_refcount(soc)); return QDF_STATUS_E_AGAIN; } if (soc->intr_mode == DP_INTR_POLL) qdf_timer_stop(&soc->int_timer); return QDF_STATUS_SUCCESS; } #define DP_FLUSH_WAIT_CNT 10 #define DP_RUNTIME_SUSPEND_WAIT_MS 10 /** * dp_runtime_resume() - ensure DP is ready to runtime resume * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * * Resume DP for runtime PM. * * Return: QDF_STATUS */ static QDF_STATUS dp_runtime_resume(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); int suspend_wait = 0; if (soc->intr_mode == DP_INTR_POLL) qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); /* * Wait until dp runtime refcount becomes zero or time out, then flush * pending tx for runtime suspend. */ while (dp_runtime_get_refcount(soc) && suspend_wait < DP_FLUSH_WAIT_CNT) { qdf_sleep(DP_RUNTIME_SUSPEND_WAIT_MS); suspend_wait++; } soc->arch_ops.dp_update_ring_hptp(soc, false); qdf_atomic_set(&soc->tx_pending_rtpm, 0); return QDF_STATUS_SUCCESS; } #endif /* FEATURE_RUNTIME_PM */ /** * dp_tx_get_success_ack_stats() - get tx success completion count * @soc_hdl: Datapath soc handle * @vdev_id: vdev identifier * * Return: tx success ack count */ static uint32_t dp_tx_get_success_ack_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct cdp_vdev_stats *vdev_stats = NULL; uint32_t tx_success; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_CDP); if (!vdev) { dp_cdp_err("%pK: Invalid vdev id %d", soc, vdev_id); return 0; } vdev_stats = qdf_mem_malloc_atomic(sizeof(struct cdp_vdev_stats)); if (!vdev_stats) { dp_cdp_err("%pK: DP alloc failure - unable to get alloc vdev stats", soc); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return 0; } dp_aggregate_vdev_stats(vdev, vdev_stats, DP_XMIT_TOTAL); tx_success = vdev_stats->tx.tx_success.num; qdf_mem_free(vdev_stats); dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP); return tx_success; } #ifdef WLAN_SUPPORT_DATA_STALL /** * dp_register_data_stall_detect_cb() - register data stall callback * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * @data_stall_detect_callback: data stall callback function * * Return: QDF_STATUS Enumeration */ static QDF_STATUS dp_register_data_stall_detect_cb( struct cdp_soc_t *soc_hdl, uint8_t pdev_id, data_stall_detect_cb data_stall_detect_callback) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev NULL!"); return QDF_STATUS_E_INVAL; } pdev->data_stall_detect_callback = data_stall_detect_callback; return QDF_STATUS_SUCCESS; } /** * dp_deregister_data_stall_detect_cb() - de-register data stall callback * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * @data_stall_detect_callback: data stall callback function * * Return: QDF_STATUS Enumeration */ static QDF_STATUS dp_deregister_data_stall_detect_cb( struct cdp_soc_t *soc_hdl, uint8_t pdev_id, data_stall_detect_cb data_stall_detect_callback) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev NULL!"); return QDF_STATUS_E_INVAL; } pdev->data_stall_detect_callback = NULL; return QDF_STATUS_SUCCESS; } /** * dp_txrx_post_data_stall_event() - post data stall event * @soc_hdl: Datapath soc handle * @indicator: Module triggering data stall * @data_stall_type: data stall event type * @pdev_id: pdev id * @vdev_id_bitmap: vdev id bitmap * @recovery_type: data stall recovery type * * Return: None */ static void dp_txrx_post_data_stall_event(struct cdp_soc_t *soc_hdl, enum data_stall_log_event_indicator indicator, enum data_stall_log_event_type data_stall_type, uint32_t pdev_id, uint32_t vdev_id_bitmap, enum data_stall_log_recovery_type recovery_type) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct data_stall_event_info data_stall_info; struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev NULL!"); return; } if (!pdev->data_stall_detect_callback) { dp_err("data stall cb not registered!"); return; } dp_info("data_stall_type: %x pdev_id: %d", data_stall_type, pdev_id); data_stall_info.indicator = indicator; data_stall_info.data_stall_type = data_stall_type; data_stall_info.vdev_id_bitmap = vdev_id_bitmap; data_stall_info.pdev_id = pdev_id; data_stall_info.recovery_type = recovery_type; pdev->data_stall_detect_callback(&data_stall_info); } #endif /* WLAN_SUPPORT_DATA_STALL */ #ifdef WLAN_FEATURE_STATS_EXT /** * dp_txrx_ext_stats_request() - request dp txrx extended stats request * @soc_hdl: soc handle * @pdev_id: pdev id * @req: stats request * * Return: QDF_STATUS */ static QDF_STATUS dp_txrx_ext_stats_request(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_txrx_ext_stats *req) { struct dp_soc *soc = (struct dp_soc *)soc_hdl; struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); int i = 0; int tcl_ring_full = 0; if (!pdev) { dp_err("pdev is null"); return QDF_STATUS_E_INVAL; } dp_aggregate_pdev_stats(pdev); for(i = 0 ; i < MAX_TCL_DATA_RINGS; i++) tcl_ring_full += soc->stats.tx.tcl_ring_full[i]; req->tx_msdu_enqueue = pdev->stats.tx_i.processed.num; req->tx_msdu_overflow = tcl_ring_full; /* Error rate at LMAC */ req->rx_mpdu_received = soc->ext_stats.rx_mpdu_received + pdev->stats.err.fw_reported_rxdma_error; /* only count error source from RXDMA */ req->rx_mpdu_error = pdev->stats.err.fw_reported_rxdma_error; /* Error rate at above the MAC */ req->rx_mpdu_delivered = soc->ext_stats.rx_mpdu_received; req->rx_mpdu_missed = pdev->stats.err.reo_error; dp_info("ext stats: tx_msdu_enq = %u, tx_msdu_overflow = %u, " "rx_mpdu_receive = %u, rx_mpdu_delivered = %u, " "rx_mpdu_missed = %u, rx_mpdu_error = %u", req->tx_msdu_enqueue, req->tx_msdu_overflow, req->rx_mpdu_received, req->rx_mpdu_delivered, req->rx_mpdu_missed, req->rx_mpdu_error); return QDF_STATUS_SUCCESS; } #endif /* WLAN_FEATURE_STATS_EXT */ #ifdef WLAN_FEATURE_MARK_FIRST_WAKEUP_PACKET /** * dp_mark_first_wakeup_packet() - set flag to indicate that * fw is compatible for marking first packet after wow wakeup * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * @value: 1 for enabled/ 0 for disabled * * Return: None */ static void dp_mark_first_wakeup_packet(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint8_t value) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL"); return; } pdev->is_first_wakeup_packet = value; } #endif #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF /** * dp_set_peer_txq_flush_config() - Set the peer txq flush configuration * @soc_hdl: Opaque handle to the DP soc object * @vdev_id: VDEV identifier * @mac: MAC address of the peer * @ac: access category mask * @tid: TID mask * @policy: Flush policy * * Return: 0 on success, errno on failure */ static int dp_set_peer_txq_flush_config(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *mac, uint8_t ac, uint32_t tid, enum cdp_peer_txq_flush_policy policy) { struct dp_soc *soc; if (!soc_hdl) { dp_err("soc is null"); return -EINVAL; } soc = cdp_soc_t_to_dp_soc(soc_hdl); return target_if_peer_txq_flush_config(soc->ctrl_psoc, vdev_id, mac, ac, tid, policy); } #endif #ifdef CONNECTIVITY_PKTLOG /** * dp_register_packetdump_callback() - registers * tx data packet, tx mgmt. packet and rx data packet * dump callback handler. * * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * @dp_tx_packetdump_cb: tx packetdump cb * @dp_rx_packetdump_cb: rx packetdump cb * * This function is used to register tx data pkt, tx mgmt. * pkt and rx data pkt dump callback * * Return: None * */ static inline void dp_register_packetdump_callback(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, ol_txrx_pktdump_cb dp_tx_packetdump_cb, ol_txrx_pktdump_cb dp_rx_packetdump_cb) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL!"); return; } pdev->dp_tx_packetdump_cb = dp_tx_packetdump_cb; pdev->dp_rx_packetdump_cb = dp_rx_packetdump_cb; } /** * dp_deregister_packetdump_callback() - deregidters * tx data packet, tx mgmt. packet and rx data packet * dump callback handler * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * * This function is used to deregidter tx data pkt., * tx mgmt. pkt and rx data pkt. dump callback * * Return: None * */ static inline void dp_deregister_packetdump_callback(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL!"); return; } pdev->dp_tx_packetdump_cb = NULL; pdev->dp_rx_packetdump_cb = NULL; } #endif #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER /** * dp_set_bus_vote_lvl_high() - Take a vote on bus bandwidth from dp * @soc_hdl: Datapath soc handle * @high: whether the bus bw is high or not * * Return: void */ static void dp_set_bus_vote_lvl_high(ol_txrx_soc_handle soc_hdl, bool high) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); soc->high_throughput = high; } /** * dp_get_bus_vote_lvl_high() - get bus bandwidth vote to dp * @soc_hdl: Datapath soc handle * * Return: bool */ static bool dp_get_bus_vote_lvl_high(ol_txrx_soc_handle soc_hdl) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); return soc->high_throughput; } #endif #ifdef DP_PEER_EXTENDED_API static struct cdp_misc_ops dp_ops_misc = { #ifdef FEATURE_WLAN_TDLS .tx_non_std = dp_tx_non_std, #endif /* FEATURE_WLAN_TDLS */ .get_opmode = dp_get_opmode, #ifdef FEATURE_RUNTIME_PM .runtime_suspend = dp_runtime_suspend, .runtime_resume = dp_runtime_resume, #endif /* FEATURE_RUNTIME_PM */ .get_num_rx_contexts = dp_get_num_rx_contexts, .get_tx_ack_stats = dp_tx_get_success_ack_stats, #ifdef WLAN_SUPPORT_DATA_STALL .txrx_data_stall_cb_register = dp_register_data_stall_detect_cb, .txrx_data_stall_cb_deregister = dp_deregister_data_stall_detect_cb, .txrx_post_data_stall_event = dp_txrx_post_data_stall_event, #endif #ifdef WLAN_FEATURE_STATS_EXT .txrx_ext_stats_request = dp_txrx_ext_stats_request, #ifndef WLAN_SOFTUMAC_SUPPORT .request_rx_hw_stats = dp_request_rx_hw_stats, .reset_rx_hw_ext_stats = dp_reset_rx_hw_ext_stats, #endif #endif /* WLAN_FEATURE_STATS_EXT */ .vdev_inform_ll_conn = dp_vdev_inform_ll_conn, #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR .set_swlm_enable = dp_soc_set_swlm_enable, .is_swlm_enabled = dp_soc_is_swlm_enabled, #endif .display_txrx_hw_info = dp_display_srng_info, #ifndef WLAN_SOFTUMAC_SUPPORT .get_tx_rings_grp_bitmap = dp_get_tx_rings_grp_bitmap, #endif #ifdef WLAN_FEATURE_MARK_FIRST_WAKEUP_PACKET .mark_first_wakeup_packet = dp_mark_first_wakeup_packet, #endif #ifdef WLAN_FEATURE_PEER_TXQ_FLUSH_CONF .set_peer_txq_flush_config = dp_set_peer_txq_flush_config, #endif #ifdef CONNECTIVITY_PKTLOG .register_pktdump_cb = dp_register_packetdump_callback, .unregister_pktdump_cb = dp_deregister_packetdump_callback, #endif #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER .set_bus_vote_lvl_high = dp_set_bus_vote_lvl_high, .get_bus_vote_lvl_high = dp_get_bus_vote_lvl_high, #endif #ifdef DP_TX_PACKET_INSPECT_FOR_ILP .evaluate_update_tx_ilp_cfg = dp_evaluate_update_tx_ilp_config, #endif }; #endif #ifdef DP_FLOW_CTL static struct cdp_flowctl_ops dp_ops_flowctl = { /* WIFI 3.0 DP implement as required. */ #ifdef QCA_LL_TX_FLOW_CONTROL_V2 #ifndef WLAN_SOFTUMAC_SUPPORT .flow_pool_map_handler = dp_tx_flow_pool_map, .flow_pool_unmap_handler = dp_tx_flow_pool_unmap, #endif /*WLAN_SOFTUMAC_SUPPORT */ .register_pause_cb = dp_txrx_register_pause_cb, .dump_flow_pool_info = dp_tx_dump_flow_pool_info, .tx_desc_thresh_reached = dp_tx_desc_thresh_reached, #endif /* QCA_LL_TX_FLOW_CONTROL_V2 */ }; static struct cdp_lflowctl_ops dp_ops_l_flowctl = { /* WIFI 3.0 DP NOT IMPLEMENTED YET */ }; #endif #ifdef IPA_OFFLOAD static struct cdp_ipa_ops dp_ops_ipa = { .ipa_get_resource = dp_ipa_get_resource, .ipa_set_doorbell_paddr = dp_ipa_set_doorbell_paddr, .ipa_iounmap_doorbell_vaddr = dp_ipa_iounmap_doorbell_vaddr, .ipa_op_response = dp_ipa_op_response, .ipa_register_op_cb = dp_ipa_register_op_cb, .ipa_deregister_op_cb = dp_ipa_deregister_op_cb, .ipa_get_stat = dp_ipa_get_stat, .ipa_tx_data_frame = dp_tx_send_ipa_data_frame, .ipa_enable_autonomy = dp_ipa_enable_autonomy, .ipa_disable_autonomy = dp_ipa_disable_autonomy, .ipa_setup = dp_ipa_setup, .ipa_cleanup = dp_ipa_cleanup, .ipa_setup_iface = dp_ipa_setup_iface, .ipa_cleanup_iface = dp_ipa_cleanup_iface, .ipa_enable_pipes = dp_ipa_enable_pipes, .ipa_disable_pipes = dp_ipa_disable_pipes, .ipa_set_perf_level = dp_ipa_set_perf_level, .ipa_rx_intrabss_fwd = dp_ipa_rx_intrabss_fwd, .ipa_tx_buf_smmu_mapping = dp_ipa_tx_buf_smmu_mapping, .ipa_tx_buf_smmu_unmapping = dp_ipa_tx_buf_smmu_unmapping, .ipa_rx_buf_smmu_pool_mapping = dp_ipa_rx_buf_pool_smmu_mapping, .ipa_set_smmu_mapped = dp_ipa_set_smmu_mapped, .ipa_get_smmu_mapped = dp_ipa_get_smmu_mapped, #ifdef QCA_SUPPORT_WDS_EXTENDED .ipa_rx_wdsext_iface = dp_ipa_rx_wdsext_iface, #endif #ifdef QCA_ENHANCED_STATS_SUPPORT .ipa_update_peer_rx_stats = dp_ipa_update_peer_rx_stats, #endif #ifdef IPA_OPT_WIFI_DP .ipa_rx_super_rule_setup = dp_ipa_rx_super_rule_setup, .ipa_pcie_link_up = dp_ipa_pcie_link_up, .ipa_pcie_link_down = dp_ipa_pcie_link_down, #endif #ifdef IPA_WDS_EASYMESH_FEATURE .ipa_ast_create = dp_ipa_ast_create, #endif .ipa_get_wdi_version = dp_ipa_get_wdi_version, }; #endif #ifdef DP_POWER_SAVE static QDF_STATUS dp_bus_suspend(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); int timeout = SUSPEND_DRAIN_WAIT; int drain_wait_delay = 50; /* 50 ms */ int32_t tx_pending; if (qdf_unlikely(!pdev)) { dp_err("pdev is NULL"); return QDF_STATUS_E_INVAL; } /* Abort if there are any pending TX packets */ while ((tx_pending = dp_get_tx_pending((struct cdp_pdev *)pdev))) { qdf_sleep(drain_wait_delay); if (timeout <= 0) { dp_info("TX frames are pending %d, abort suspend", tx_pending); dp_find_missing_tx_comp(soc); return QDF_STATUS_E_TIMEOUT; } timeout = timeout - drain_wait_delay; } if (soc->intr_mode == DP_INTR_POLL) qdf_timer_stop(&soc->int_timer); /* Stop monitor reap timer and reap any pending frames in ring */ dp_monitor_reap_timer_suspend(soc); return QDF_STATUS_SUCCESS; } static QDF_STATUS dp_bus_resume(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (qdf_unlikely(!pdev)) { dp_err("pdev is NULL"); return QDF_STATUS_E_INVAL; } if (soc->intr_mode == DP_INTR_POLL) qdf_timer_mod(&soc->int_timer, DP_INTR_POLL_TIMER_MS); /* Start monitor reap timer */ dp_monitor_reap_timer_start(soc, CDP_MON_REAP_SOURCE_ANY); soc->arch_ops.dp_update_ring_hptp(soc, false); return QDF_STATUS_SUCCESS; } /** * dp_process_wow_ack_rsp() - process wow ack response * @soc_hdl: datapath soc handle * @pdev_id: data path pdev handle id * * Return: none */ static void dp_process_wow_ack_rsp(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (qdf_unlikely(!pdev)) { dp_err("pdev is NULL"); return; } /* * As part of wow enable FW disables the mon status ring and in wow ack * response from FW reap mon status ring to make sure no packets pending * in the ring. */ dp_monitor_reap_timer_suspend(soc); } /** * dp_process_target_suspend_req() - process target suspend request * @soc_hdl: datapath soc handle * @pdev_id: data path pdev handle id * * Return: none */ static void dp_process_target_suspend_req(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (qdf_unlikely(!pdev)) { dp_err("pdev is NULL"); return; } /* Stop monitor reap timer and reap any pending frames in ring */ dp_monitor_reap_timer_suspend(soc); } static struct cdp_bus_ops dp_ops_bus = { .bus_suspend = dp_bus_suspend, .bus_resume = dp_bus_resume, .process_wow_ack_rsp = dp_process_wow_ack_rsp, .process_target_suspend_req = dp_process_target_suspend_req }; #endif #ifdef DP_FLOW_CTL static struct cdp_throttle_ops dp_ops_throttle = { /* WIFI 3.0 DP NOT IMPLEMENTED YET */ }; static struct cdp_cfg_ops dp_ops_cfg = { /* WIFI 3.0 DP NOT IMPLEMENTED YET */ }; #endif #ifdef DP_PEER_EXTENDED_API static struct cdp_ocb_ops dp_ops_ocb = { /* WIFI 3.0 DP NOT IMPLEMENTED YET */ }; static struct cdp_mob_stats_ops dp_ops_mob_stats = { .clear_stats = dp_txrx_clear_dump_stats, }; static struct cdp_peer_ops dp_ops_peer = { .register_peer = dp_register_peer, .clear_peer = dp_clear_peer, .find_peer_exist = dp_find_peer_exist, .find_peer_exist_on_vdev = dp_find_peer_exist_on_vdev, .find_peer_exist_on_other_vdev = dp_find_peer_exist_on_other_vdev, .peer_state_update = dp_peer_state_update, .get_vdevid = dp_get_vdevid, .get_vdev_by_peer_addr = dp_get_vdev_by_peer_addr, .peer_get_peer_mac_addr = dp_peer_get_peer_mac_addr, .get_peer_state = dp_get_peer_state, .peer_flush_frags = dp_peer_flush_frags, .set_peer_as_tdls_peer = dp_set_peer_as_tdls_peer, }; #endif static void dp_soc_txrx_ops_attach(struct dp_soc *soc) { soc->cdp_soc.ops->cmn_drv_ops = &dp_ops_cmn; soc->cdp_soc.ops->ctrl_ops = &dp_ops_ctrl; soc->cdp_soc.ops->me_ops = &dp_ops_me; soc->cdp_soc.ops->host_stats_ops = &dp_ops_host_stats; soc->cdp_soc.ops->wds_ops = &dp_ops_wds; soc->cdp_soc.ops->raw_ops = &dp_ops_raw; #ifdef PEER_FLOW_CONTROL soc->cdp_soc.ops->pflow_ops = &dp_ops_pflow; #endif /* PEER_FLOW_CONTROL */ #ifdef DP_PEER_EXTENDED_API soc->cdp_soc.ops->misc_ops = &dp_ops_misc; soc->cdp_soc.ops->ocb_ops = &dp_ops_ocb; soc->cdp_soc.ops->peer_ops = &dp_ops_peer; soc->cdp_soc.ops->mob_stats_ops = &dp_ops_mob_stats; #endif #ifdef DP_FLOW_CTL soc->cdp_soc.ops->cfg_ops = &dp_ops_cfg; soc->cdp_soc.ops->flowctl_ops = &dp_ops_flowctl; soc->cdp_soc.ops->l_flowctl_ops = &dp_ops_l_flowctl; soc->cdp_soc.ops->throttle_ops = &dp_ops_throttle; #endif #ifdef IPA_OFFLOAD soc->cdp_soc.ops->ipa_ops = &dp_ops_ipa; #endif #ifdef DP_POWER_SAVE soc->cdp_soc.ops->bus_ops = &dp_ops_bus; #endif #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) soc->cdp_soc.ops->cfr_ops = &dp_ops_cfr; #endif #ifdef WLAN_SUPPORT_MSCS soc->cdp_soc.ops->mscs_ops = &dp_ops_mscs; #endif #ifdef WLAN_SUPPORT_MESH_LATENCY soc->cdp_soc.ops->mesh_latency_ops = &dp_ops_mesh_latency; #endif #ifdef CONFIG_SAWF_DEF_QUEUES soc->cdp_soc.ops->sawf_ops = &dp_ops_sawf; #endif #ifdef WLAN_SUPPORT_SCS soc->cdp_soc.ops->scs_ops = &dp_ops_scs; #endif #ifdef WLAN_SUPPORT_RX_FLOW_TAG soc->cdp_soc.ops->fse_ops = &dp_ops_fse; #endif }; #if defined(QCA_WIFI_QCA8074) || defined(QCA_WIFI_QCA6018) || \ defined(QCA_WIFI_QCA5018) || defined(QCA_WIFI_QCA9574) || \ defined(QCA_WIFI_QCA5332) /** * dp_soc_attach_wifi3() - Attach txrx SOC * @ctrl_psoc: Opaque SOC handle from control plane * @params: SOC attach params * * Return: DP SOC handle on success, NULL on failure */ struct cdp_soc_t * dp_soc_attach_wifi3(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, struct cdp_soc_attach_params *params) { struct dp_soc *dp_soc = NULL; dp_soc = dp_soc_attach(ctrl_psoc, params); return dp_soc_to_cdp_soc_t(dp_soc); } static inline void dp_soc_set_def_pdev(struct dp_soc *soc) { int lmac_id; for (lmac_id = 0; lmac_id < MAX_NUM_LMAC_HW; lmac_id++) { /*Set default host PDEV ID for lmac_id*/ wlan_cfg_set_pdev_idx(soc->wlan_cfg_ctx, INVALID_PDEV_ID, lmac_id); } } static void dp_soc_unset_qref_debug_list(struct dp_soc *soc) { uint32_t max_list_size = soc->wlan_cfg_ctx->qref_control_size; if (max_list_size == 0) return; qdf_mem_free(soc->list_shared_qaddr_del); qdf_mem_free(soc->reo_write_list); qdf_mem_free(soc->list_qdesc_addr_free); qdf_mem_free(soc->list_qdesc_addr_alloc); } static void dp_soc_set_qref_debug_list(struct dp_soc *soc) { uint32_t max_list_size = soc->wlan_cfg_ctx->qref_control_size; if (max_list_size == 0) return; soc->list_shared_qaddr_del = (struct test_qaddr_del *) qdf_mem_malloc(sizeof(struct test_qaddr_del) * max_list_size); soc->reo_write_list = (struct test_qaddr_del *) qdf_mem_malloc(sizeof(struct test_qaddr_del) * max_list_size); soc->list_qdesc_addr_free = (struct test_mem_free *) qdf_mem_malloc(sizeof(struct test_mem_free) * max_list_size); soc->list_qdesc_addr_alloc = (struct test_mem_free *) qdf_mem_malloc(sizeof(struct test_mem_free) * max_list_size); } static uint32_t dp_get_link_desc_id_start(uint16_t arch_id) { switch (arch_id) { case CDP_ARCH_TYPE_LI: case CDP_ARCH_TYPE_RH: return LINK_DESC_ID_START_21_BITS_COOKIE; case CDP_ARCH_TYPE_BE: return LINK_DESC_ID_START_20_BITS_COOKIE; default: dp_err("unknown arch_id 0x%x", arch_id); QDF_BUG(0); return LINK_DESC_ID_START_21_BITS_COOKIE; } } #ifdef DP_TX_PACKET_INSPECT_FOR_ILP static inline void dp_soc_init_tx_ilp(struct dp_soc *soc) { soc->tx_ilp_enable = false; } #else static inline void dp_soc_init_tx_ilp(struct dp_soc *soc) { } #endif /** * dp_soc_attach() - Attach txrx SOC * @ctrl_psoc: Opaque SOC handle from control plane * @params: SOC attach params * * Return: DP SOC handle on success, NULL on failure */ static struct dp_soc * dp_soc_attach(struct cdp_ctrl_objmgr_psoc *ctrl_psoc, struct cdp_soc_attach_params *params) { struct dp_soc *soc = NULL; uint16_t arch_id; struct hif_opaque_softc *hif_handle = params->hif_handle; qdf_device_t qdf_osdev = params->qdf_osdev; struct ol_if_ops *ol_ops = params->ol_ops; uint16_t device_id = params->device_id; if (!hif_handle) { dp_err("HIF handle is NULL"); goto fail0; } arch_id = cdp_get_arch_type_from_devid(device_id); soc = qdf_mem_common_alloc(dp_get_soc_context_size(device_id)); if (!soc) { dp_err("DP SOC memory allocation failed"); goto fail0; } dp_info("soc memory allocated %pK", soc); soc->hif_handle = hif_handle; soc->hal_soc = hif_get_hal_handle(soc->hif_handle); if (!soc->hal_soc) goto fail1; hif_get_cmem_info(soc->hif_handle, &soc->cmem_base, &soc->cmem_total_size); soc->cmem_avail_size = soc->cmem_total_size; soc->device_id = device_id; soc->cdp_soc.ops = (struct cdp_ops *)qdf_mem_malloc(sizeof(struct cdp_ops)); if (!soc->cdp_soc.ops) goto fail1; dp_soc_txrx_ops_attach(soc); soc->cdp_soc.ol_ops = ol_ops; soc->ctrl_psoc = ctrl_psoc; soc->osdev = qdf_osdev; soc->num_hw_dscp_tid_map = HAL_MAX_HW_DSCP_TID_MAPS; dp_soc_init_tx_ilp(soc); hal_rx_get_tlv_size(soc->hal_soc, &soc->rx_pkt_tlv_size, &soc->rx_mon_pkt_tlv_size); soc->idle_link_bm_id = hal_get_idle_link_bm_id(soc->hal_soc, params->mlo_chip_id); soc->features.dmac_cmn_src_rxbuf_ring_enabled = hal_dmac_cmn_src_rxbuf_ring_get(soc->hal_soc); soc->arch_id = arch_id; soc->link_desc_id_start = dp_get_link_desc_id_start(soc->arch_id); dp_configure_arch_ops(soc); /* Reset wbm sg list and flags */ dp_rx_wbm_sg_list_reset(soc); dp_soc_cfg_history_attach(soc); dp_soc_tx_hw_desc_history_attach(soc); dp_soc_rx_history_attach(soc); dp_soc_mon_status_ring_history_attach(soc); dp_soc_tx_history_attach(soc); dp_soc_msdu_done_fail_desc_list_attach(soc); dp_soc_msdu_done_fail_history_attach(soc); wlan_set_srng_cfg(&soc->wlan_srng_cfg); soc->wlan_cfg_ctx = wlan_cfg_soc_attach(soc->ctrl_psoc); if (!soc->wlan_cfg_ctx) { dp_err("wlan_cfg_ctx failed"); goto fail2; } qdf_ssr_driver_dump_register_region("wlan_cfg_ctx", soc->wlan_cfg_ctx, sizeof(*soc->wlan_cfg_ctx)); /*sync DP soc cfg items with profile support after cfg_soc_attach*/ wlan_dp_soc_cfg_sync_profile((struct cdp_soc_t *)soc); soc->arch_ops.soc_cfg_attach(soc); qdf_ssr_driver_dump_register_region("tcl_wbm_map_array", &soc->wlan_cfg_ctx->tcl_wbm_map_array, sizeof(struct wlan_cfg_tcl_wbm_ring_num_map)); if (dp_hw_link_desc_pool_banks_alloc(soc, WLAN_INVALID_PDEV_ID)) { dp_err("failed to allocate link desc pool banks"); goto fail3; } if (dp_hw_link_desc_ring_alloc(soc)) { dp_err("failed to allocate link_desc_ring"); goto fail4; } if (!QDF_IS_STATUS_SUCCESS(soc->arch_ops.txrx_soc_attach(soc, params))) { dp_err("unable to do target specific attach"); goto fail5; } if (dp_soc_srng_alloc(soc)) { dp_err("failed to allocate soc srng rings"); goto fail6; } if (dp_soc_tx_desc_sw_pools_alloc(soc)) { dp_err("dp_soc_tx_desc_sw_pools_alloc failed"); goto fail7; } if (!dp_monitor_modularized_enable()) { if (dp_mon_soc_attach_wrapper(soc)) { dp_err("failed to attach monitor"); goto fail8; } } if (hal_reo_shared_qaddr_setup((hal_soc_handle_t)soc->hal_soc, &soc->reo_qref) != QDF_STATUS_SUCCESS) { dp_err("unable to setup reo shared qaddr"); goto fail9; } if (dp_sysfs_initialize_stats(soc) != QDF_STATUS_SUCCESS) { dp_err("failed to initialize dp stats sysfs file"); dp_sysfs_deinitialize_stats(soc); } dp_soc_swlm_attach(soc); dp_soc_set_interrupt_mode(soc); dp_soc_set_def_pdev(soc); dp_soc_set_qref_debug_list(soc); qdf_ssr_driver_dump_register_region("dp_soc", soc, sizeof(*soc)); qdf_nbuf_ssr_register_region(); dp_info("Mem stats: DMA = %u HEAP = %u SKB = %u", qdf_dma_mem_stats_read(), qdf_heap_mem_stats_read(), qdf_skb_total_mem_stats_read()); return soc; fail9: if (!dp_monitor_modularized_enable()) dp_mon_soc_detach_wrapper(soc); fail8: dp_soc_tx_desc_sw_pools_free(soc); fail7: dp_soc_srng_free(soc); fail6: soc->arch_ops.txrx_soc_detach(soc); fail5: dp_hw_link_desc_ring_free(soc); fail4: dp_hw_link_desc_pool_banks_free(soc, WLAN_INVALID_PDEV_ID); fail3: wlan_cfg_soc_detach(soc->wlan_cfg_ctx); fail2: dp_soc_msdu_done_fail_history_detach(soc); qdf_mem_free(soc->cdp_soc.ops); fail1: qdf_mem_common_free(soc); fail0: return NULL; } void *dp_soc_init_wifi3(struct cdp_soc_t *cdp_soc, struct cdp_ctrl_objmgr_psoc *ctrl_psoc, struct hif_opaque_softc *hif_handle, HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, struct ol_if_ops *ol_ops, uint16_t device_id) { struct dp_soc *soc = (struct dp_soc *)cdp_soc; return soc->arch_ops.txrx_soc_init(soc, htc_handle, hif_handle); } #endif void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id) { if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) return (mac_id < MAX_PDEV_CNT) ? soc->pdev_list[mac_id] : NULL; /* Typically for MCL as there only 1 PDEV*/ return soc->pdev_list[0]; } void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc, int *max_mac_rings) { bool dbs_enable = false; if (soc->cdp_soc.ol_ops->is_hw_dbs_capable) dbs_enable = soc->cdp_soc.ol_ops-> is_hw_dbs_capable((void *)soc->ctrl_psoc); *max_mac_rings = dbs_enable ? (*max_mac_rings) : 1; dp_info("dbs_enable %d, max_mac_rings %d", dbs_enable, *max_mac_rings); } qdf_export_symbol(dp_update_num_mac_rings_for_dbs); #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) /** * dp_get_cfr_rcc() - get cfr rcc config * @soc_hdl: Datapath soc handle * @pdev_id: id of objmgr pdev * * Return: true/false based on cfr mode setting */ static bool dp_get_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = NULL; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL"); return false; } return pdev->cfr_rcc_mode; } /** * dp_set_cfr_rcc() - enable/disable cfr rcc config * @soc_hdl: Datapath soc handle * @pdev_id: id of objmgr pdev * @enable: Enable/Disable cfr rcc mode * * Return: none */ static void dp_set_cfr_rcc(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, bool enable) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = NULL; pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL"); return; } pdev->cfr_rcc_mode = enable; } /** * dp_get_cfr_dbg_stats - Get the debug statistics for CFR * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * @cfr_rcc_stats: CFR RCC debug statistics buffer * * Return: none */ static inline void dp_get_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_cfr_rcc_stats *cfr_rcc_stats) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("pdev is NULL"); return; } qdf_mem_copy(cfr_rcc_stats, &pdev->stats.rcc, sizeof(struct cdp_cfr_rcc_stats)); } /** * dp_clear_cfr_dbg_stats - Clear debug statistics for CFR * @soc_hdl: Datapath soc handle * @pdev_id: id of data path pdev handle * * Return: none */ static void dp_clear_cfr_dbg_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("dp pdev is NULL"); return; } qdf_mem_zero(&pdev->stats.rcc, sizeof(pdev->stats.rcc)); } #endif /** * dp_bucket_index() - Return index from array * * @delay: delay measured * @array: array used to index corresponding delay * @delay_in_us: flag to indicate whether the delay in ms or us * * Return: index */ static uint8_t dp_bucket_index(uint32_t delay, uint16_t *array, bool delay_in_us) { uint8_t i = CDP_DELAY_BUCKET_0; uint32_t thr_low, thr_high; for (; i < CDP_DELAY_BUCKET_MAX - 1; i++) { thr_low = array[i]; thr_high = array[i + 1]; if (delay_in_us) { thr_low = thr_low * USEC_PER_MSEC; thr_high = thr_high * USEC_PER_MSEC; } if (delay >= thr_low && delay <= thr_high) return i; } return (CDP_DELAY_BUCKET_MAX - 1); } #ifdef HW_TX_DELAY_STATS_ENABLE /* * cdp_fw_to_hw_delay_range * Fw to hw delay ranges in milliseconds */ static uint16_t cdp_fw_to_hw_delay[CDP_DELAY_BUCKET_MAX] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 250, 500}; #else static uint16_t cdp_fw_to_hw_delay[CDP_DELAY_BUCKET_MAX] = { 0, 2, 4, 6, 8, 10, 20, 30, 40, 50, 100, 250, 500}; #endif /* * cdp_sw_enq_delay_range * Software enqueue delay ranges in milliseconds */ static uint16_t cdp_sw_enq_delay[CDP_DELAY_BUCKET_MAX] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; /* * cdp_intfrm_delay_range * Interframe delay ranges in milliseconds */ static uint16_t cdp_intfrm_delay[CDP_DELAY_BUCKET_MAX] = { 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60}; /** * dp_fill_delay_buckets() - Fill delay statistics bucket for each * type of delay * @tstats: tid tx stats * @rstats: tid rx stats * @delay: delay in ms * @tid: tid value * @mode: type of tx delay mode * @ring_id: ring number * @delay_in_us: flag to indicate whether the delay in ms or us * * Return: pointer to cdp_delay_stats structure */ static struct cdp_delay_stats * dp_fill_delay_buckets(struct cdp_tid_tx_stats *tstats, struct cdp_tid_rx_stats *rstats, uint32_t delay, uint8_t tid, uint8_t mode, uint8_t ring_id, bool delay_in_us) { uint8_t delay_index = 0; struct cdp_delay_stats *stats = NULL; /* * Update delay stats in proper bucket */ switch (mode) { /* Software Enqueue delay ranges */ case CDP_DELAY_STATS_SW_ENQ: if (!tstats) break; delay_index = dp_bucket_index(delay, cdp_sw_enq_delay, delay_in_us); tstats->swq_delay.delay_bucket[delay_index]++; stats = &tstats->swq_delay; break; /* Tx Completion delay ranges */ case CDP_DELAY_STATS_FW_HW_TRANSMIT: if (!tstats) break; delay_index = dp_bucket_index(delay, cdp_fw_to_hw_delay, delay_in_us); tstats->hwtx_delay.delay_bucket[delay_index]++; stats = &tstats->hwtx_delay; break; /* Interframe tx delay ranges */ case CDP_DELAY_STATS_TX_INTERFRAME: if (!tstats) break; delay_index = dp_bucket_index(delay, cdp_intfrm_delay, delay_in_us); tstats->intfrm_delay.delay_bucket[delay_index]++; stats = &tstats->intfrm_delay; break; /* Interframe rx delay ranges */ case CDP_DELAY_STATS_RX_INTERFRAME: if (!rstats) break; delay_index = dp_bucket_index(delay, cdp_intfrm_delay, delay_in_us); rstats->intfrm_delay.delay_bucket[delay_index]++; stats = &rstats->intfrm_delay; break; /* Ring reap to indication to network stack */ case CDP_DELAY_STATS_REAP_STACK: if (!rstats) break; delay_index = dp_bucket_index(delay, cdp_intfrm_delay, delay_in_us); rstats->to_stack_delay.delay_bucket[delay_index]++; stats = &rstats->to_stack_delay; break; default: dp_debug("Incorrect delay mode: %d", mode); } return stats; } void dp_update_delay_stats(struct cdp_tid_tx_stats *tstats, struct cdp_tid_rx_stats *rstats, uint32_t delay, uint8_t tid, uint8_t mode, uint8_t ring_id, bool delay_in_us) { struct cdp_delay_stats *dstats = NULL; /* * Delay ranges are different for different delay modes * Get the correct index to update delay bucket */ dstats = dp_fill_delay_buckets(tstats, rstats, delay, tid, mode, ring_id, delay_in_us); if (qdf_unlikely(!dstats)) return; if (delay != 0) { /* * Compute minimum,average and maximum * delay */ if (delay < dstats->min_delay) dstats->min_delay = delay; if (delay > dstats->max_delay) dstats->max_delay = delay; /* * Average over delay measured till now */ if (!dstats->avg_delay) dstats->avg_delay = delay; else dstats->avg_delay = ((delay + dstats->avg_delay) >> 1); } } uint16_t dp_get_peer_mac_list(ol_txrx_soc_handle soc, uint8_t vdev_id, u_int8_t newmac[][QDF_MAC_ADDR_SIZE], u_int16_t mac_cnt, bool limit) { struct dp_soc *dp_soc = (struct dp_soc *)soc; struct dp_vdev *vdev = dp_vdev_get_ref_by_id(dp_soc, vdev_id, DP_MOD_ID_CDP); struct dp_peer *peer; uint16_t new_mac_cnt = 0; if (!vdev) return new_mac_cnt; if (limit && (vdev->num_peers > mac_cnt)) { dp_vdev_unref_delete(dp_soc, vdev, DP_MOD_ID_CDP); return 0; } qdf_spin_lock_bh(&vdev->peer_list_lock); TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) { if (peer->bss_peer) continue; if (new_mac_cnt < mac_cnt) { WLAN_ADDR_COPY(newmac[new_mac_cnt], peer->mac_addr.raw); new_mac_cnt++; } } qdf_spin_unlock_bh(&vdev->peer_list_lock); dp_vdev_unref_delete(dp_soc, vdev, DP_MOD_ID_CDP); return new_mac_cnt; } uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac) { struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, mac, 0, vdev_id, DP_MOD_ID_CDP); uint16_t peer_id = HTT_INVALID_PEER; if (!peer) { dp_cdp_debug("%pK: Peer is NULL!", (struct dp_soc *)soc); return peer_id; } peer_id = peer->peer_id; dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return peer_id; } #ifdef QCA_SUPPORT_WDS_EXTENDED QDF_STATUS dp_wds_ext_set_peer_rx(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac, ol_txrx_rx_fp rx, ol_osif_peer_handle osif_peer) { struct dp_txrx_peer *txrx_peer = NULL; struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, mac, 0, vdev_id, DP_MOD_ID_CDP); QDF_STATUS status = QDF_STATUS_E_INVAL; if (!peer) { dp_cdp_debug("%pK: Peer is NULL!", (struct dp_soc *)soc); return status; } txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) { dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } if (rx) { if (txrx_peer->osif_rx) { status = QDF_STATUS_E_ALREADY; } else { txrx_peer->osif_rx = rx; status = QDF_STATUS_SUCCESS; } } else { if (txrx_peer->osif_rx) { txrx_peer->osif_rx = NULL; status = QDF_STATUS_SUCCESS; } else { status = QDF_STATUS_E_ALREADY; } } txrx_peer->wds_ext.osif_peer = osif_peer; dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return status; } QDF_STATUS dp_wds_ext_get_peer_osif_handle( ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac, ol_osif_peer_handle *osif_peer) { struct dp_soc *dp_soc = (struct dp_soc *)soc; struct dp_txrx_peer *txrx_peer = NULL; struct dp_peer *peer = dp_peer_find_hash_find(dp_soc, mac, 0, vdev_id, DP_MOD_ID_CDP); if (!peer) { dp_cdp_debug("%pK: Peer is NULL!", dp_soc); return QDF_STATUS_E_INVAL; } txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) { dp_cdp_debug("%pK: TXRX Peer is NULL!", dp_soc); dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_E_INVAL; } *osif_peer = txrx_peer->wds_ext.osif_peer; dp_peer_unref_delete(peer, DP_MOD_ID_CDP); return QDF_STATUS_SUCCESS; } QDF_STATUS dp_wds_ext_set_peer_bit(ol_txrx_soc_handle soc, uint8_t *mac) { struct dp_txrx_peer *txrx_peer = NULL; struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, mac, 0, DP_VDEV_ALL, DP_MOD_ID_IPA); if (!peer) { dp_cdp_debug("%pK: Peer is NULL!\n", (struct dp_soc *)soc); return QDF_STATUS_E_INVAL; } txrx_peer = dp_get_txrx_peer(peer); if (!txrx_peer) { dp_peer_unref_delete(peer, DP_MOD_ID_IPA); return QDF_STATUS_E_INVAL; } qdf_atomic_test_and_set_bit(WDS_EXT_PEER_INIT_BIT, &txrx_peer->wds_ext.init); dp_peer_unref_delete(peer, DP_MOD_ID_IPA); return QDF_STATUS_SUCCESS; } #endif /* QCA_SUPPORT_WDS_EXTENDED */ /** * dp_pdev_srng_deinit() - de-initialize all pdev srng ring including * monitor rings * @pdev: Datapath pdev handle * */ static void dp_pdev_srng_deinit(struct dp_pdev *pdev) { struct dp_soc *soc = pdev->soc; uint8_t i; if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) dp_srng_deinit(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], RXDMA_BUF, pdev->lmac_id); if (!soc->rxdma2sw_rings_not_supported) { for (i = 0; i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, pdev->pdev_id); wlan_minidump_remove(soc->rxdma_err_dst_ring[lmac_id]. base_vaddr_unaligned, soc->rxdma_err_dst_ring[lmac_id]. alloc_size, soc->ctrl_psoc, WLAN_MD_DP_SRNG_RXDMA_ERR_DST, "rxdma_err_dst"); dp_srng_deinit(soc, &soc->rxdma_err_dst_ring[lmac_id], RXDMA_DST, lmac_id); } } } /** * dp_pdev_srng_init() - initialize all pdev srng rings including * monitor rings * @pdev: Datapath pdev handle * * Return: QDF_STATUS_SUCCESS on success * QDF_STATUS_E_NOMEM on failure */ static QDF_STATUS dp_pdev_srng_init(struct dp_pdev *pdev) { struct dp_soc *soc = pdev->soc; struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; uint32_t i; soc_cfg_ctx = soc->wlan_cfg_ctx; if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) { if (dp_srng_init(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], RXDMA_BUF, 0, pdev->lmac_id)) { dp_init_err("%pK: dp_srng_init failed rx refill ring", soc); goto fail1; } } /* LMAC RxDMA to SW Rings configuration */ if (!wlan_cfg_per_pdev_lmac_ring(soc_cfg_ctx)) /* Only valid for MCL */ pdev = soc->pdev_list[0]; if (!soc->rxdma2sw_rings_not_supported) { for (i = 0; i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, pdev->pdev_id); struct dp_srng *srng = &soc->rxdma_err_dst_ring[lmac_id]; if (srng->hal_srng) continue; if (dp_srng_init(soc, srng, RXDMA_DST, 0, lmac_id)) { dp_init_err("%pK:" RNG_ERR "rxdma_err_dst_ring", soc); goto fail1; } wlan_minidump_log(soc->rxdma_err_dst_ring[lmac_id]. base_vaddr_unaligned, soc->rxdma_err_dst_ring[lmac_id]. alloc_size, soc->ctrl_psoc, WLAN_MD_DP_SRNG_RXDMA_ERR_DST, "rxdma_err_dst"); } } return QDF_STATUS_SUCCESS; fail1: dp_pdev_srng_deinit(pdev); return QDF_STATUS_E_NOMEM; } /** * dp_pdev_srng_free() - free all pdev srng rings including monitor rings * @pdev: Datapath pdev handle * */ static void dp_pdev_srng_free(struct dp_pdev *pdev) { struct dp_soc *soc = pdev->soc; uint8_t i; if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) dp_srng_free(soc, &soc->rx_refill_buf_ring[pdev->lmac_id]); if (!soc->rxdma2sw_rings_not_supported) { for (i = 0; i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, pdev->pdev_id); dp_srng_free(soc, &soc->rxdma_err_dst_ring[lmac_id]); } } } /** * dp_pdev_srng_alloc() - allocate memory for all pdev srng rings including * monitor rings * @pdev: Datapath pdev handle * * Return: QDF_STATUS_SUCCESS on success * QDF_STATUS_E_NOMEM on failure */ static QDF_STATUS dp_pdev_srng_alloc(struct dp_pdev *pdev) { struct dp_soc *soc = pdev->soc; struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; uint32_t ring_size; uint32_t i; soc_cfg_ctx = soc->wlan_cfg_ctx; ring_size = wlan_cfg_get_dp_soc_rxdma_refill_ring_size(soc_cfg_ctx); if (!soc->features.dmac_cmn_src_rxbuf_ring_enabled) { if (dp_srng_alloc(soc, &soc->rx_refill_buf_ring[pdev->lmac_id], RXDMA_BUF, ring_size, 0)) { dp_init_err("%pK: dp_srng_alloc failed rx refill ring", soc); goto fail1; } } ring_size = wlan_cfg_get_dp_soc_rxdma_err_dst_ring_size(soc_cfg_ctx); /* LMAC RxDMA to SW Rings configuration */ if (!wlan_cfg_per_pdev_lmac_ring(soc_cfg_ctx)) /* Only valid for MCL */ pdev = soc->pdev_list[0]; if (!soc->rxdma2sw_rings_not_supported) { for (i = 0; i < soc->wlan_cfg_ctx->num_rxdma_dst_rings_per_pdev; i++) { int lmac_id = dp_get_lmac_id_for_pdev_id(soc, i, pdev->pdev_id); struct dp_srng *srng = &soc->rxdma_err_dst_ring[lmac_id]; if (srng->base_vaddr_unaligned) continue; if (dp_srng_alloc(soc, srng, RXDMA_DST, ring_size, 0)) { dp_init_err("%pK:" RNG_ERR "rxdma_err_dst_ring", soc); goto fail1; } } } return QDF_STATUS_SUCCESS; fail1: dp_pdev_srng_free(pdev); return QDF_STATUS_E_NOMEM; } #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT) /** * dp_init_link_peer_stats_enabled() - Init link_peer_stats as per config * @pdev: DP pdev * * Return: None */ static inline void dp_init_link_peer_stats_enabled(struct dp_pdev *pdev) { pdev->link_peer_stats = wlan_cfg_is_peer_link_stats_enabled( pdev->soc->wlan_cfg_ctx); } #else static inline void dp_init_link_peer_stats_enabled(struct dp_pdev *pdev) { } #endif static QDF_STATUS dp_pdev_init(struct cdp_soc_t *txrx_soc, HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, uint8_t pdev_id) { struct wlan_cfg_dp_soc_ctxt *soc_cfg_ctx; int nss_cfg; void *sojourn_buf; struct dp_soc *soc = (struct dp_soc *)txrx_soc; struct dp_pdev *pdev = soc->pdev_list[pdev_id]; soc_cfg_ctx = soc->wlan_cfg_ctx; pdev->soc = soc; pdev->pdev_id = pdev_id; /* * Variable to prevent double pdev deinitialization during * radio detach execution .i.e. in the absence of any vdev. */ pdev->pdev_deinit = 0; if (dp_wdi_event_attach(pdev)) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "dp_wdi_evet_attach failed"); goto fail0; } if (dp_pdev_srng_init(pdev)) { dp_init_err("%pK: Failed to initialize pdev srng rings", soc); goto fail1; } /* Initialize descriptors in TCL Rings used by IPA */ if (wlan_cfg_is_ipa_enabled(soc->wlan_cfg_ctx)) { hal_tx_init_data_ring(soc->hal_soc, soc->tcl_data_ring[IPA_TCL_DATA_RING_IDX].hal_srng); dp_ipa_hal_tx_init_alt_data_ring(soc); } /* * Initialize command/credit ring descriptor * Command/CREDIT ring also used for sending DATA cmds */ dp_tx_init_cmd_credit_ring(soc); dp_tx_pdev_init(pdev); /* * set nss pdev config based on soc config */ nss_cfg = wlan_cfg_get_dp_soc_nss_cfg(soc_cfg_ctx); wlan_cfg_set_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx, (nss_cfg & (1 << pdev_id))); pdev->target_pdev_id = dp_calculate_target_pdev_id_from_host_pdev_id(soc, pdev_id); if (soc->preferred_hw_mode == WMI_HOST_HW_MODE_2G_PHYB && pdev->lmac_id == PHYB_2G_LMAC_ID) { pdev->target_pdev_id = PHYB_2G_TARGET_PDEV_ID; } /* Reset the cpu ring map if radio is NSS offloaded */ if (wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) { dp_soc_reset_cpu_ring_map(soc); dp_soc_reset_intr_mask(soc); } /* Reset the ring interrupt mask if DPDK is enabled */ if (wlan_cfg_get_dp_soc_dpdk_cfg(soc->ctrl_psoc)) { dp_soc_reset_dpdk_intr_mask(soc); } /* Reset the cpu ring map if radio is NSS offloaded */ dp_soc_reset_ipa_vlan_intr_mask(soc); TAILQ_INIT(&pdev->vdev_list); qdf_spinlock_create(&pdev->vdev_list_lock); pdev->vdev_count = 0; pdev->is_lro_hash_configured = 0; qdf_spinlock_create(&pdev->tx_mutex); pdev->ch_band_lmac_id_mapping[REG_BAND_2G] = DP_MON_INVALID_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_5G] = DP_MON_INVALID_LMAC_ID; pdev->ch_band_lmac_id_mapping[REG_BAND_6G] = DP_MON_INVALID_LMAC_ID; DP_STATS_INIT(pdev); dp_local_peer_id_pool_init(pdev); dp_dscp_tid_map_setup(pdev); dp_pcp_tid_map_setup(pdev); /* set the reo destination during initialization */ dp_pdev_set_default_reo(pdev); qdf_mem_zero(&pdev->sojourn_stats, sizeof(struct cdp_tx_sojourn_stats)); pdev->sojourn_buf = qdf_nbuf_alloc(pdev->soc->osdev, sizeof(struct cdp_tx_sojourn_stats), 0, 4, TRUE); if (!pdev->sojourn_buf) { dp_init_err("%pK: Failed to allocate sojourn buf", soc); goto fail2; } sojourn_buf = qdf_nbuf_data(pdev->sojourn_buf); qdf_mem_zero(sojourn_buf, sizeof(struct cdp_tx_sojourn_stats)); qdf_event_create(&pdev->fw_peer_stats_event); qdf_event_create(&pdev->fw_stats_event); qdf_event_create(&pdev->fw_obss_stats_event); pdev->num_tx_allowed = wlan_cfg_get_num_tx_desc(soc->wlan_cfg_ctx); pdev->num_tx_spl_allowed = wlan_cfg_get_num_tx_spl_desc(soc->wlan_cfg_ctx); pdev->num_reg_tx_allowed = pdev->num_tx_allowed - pdev->num_tx_spl_allowed; if (dp_rxdma_ring_setup(soc, pdev)) { dp_init_err("%pK: RXDMA ring config failed", soc); goto fail3; } if (dp_init_ipa_rx_refill_buf_ring(soc, pdev)) goto fail3; if (dp_ipa_ring_resource_setup(soc, pdev)) goto fail4; if (dp_ipa_uc_attach(soc, pdev) != QDF_STATUS_SUCCESS) { dp_init_err("%pK: dp_ipa_uc_attach failed", soc); goto fail4; } if (dp_pdev_bkp_stats_attach(pdev) != QDF_STATUS_SUCCESS) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, FL("dp_pdev_bkp_stats_attach failed")); goto fail5; } if (dp_monitor_pdev_init(pdev)) { dp_init_err("%pK: dp_monitor_pdev_init failed", soc); goto fail6; } /* initialize sw rx descriptors */ dp_rx_pdev_desc_pool_init(pdev); /* allocate buffers and replenish the RxDMA ring */ dp_rx_pdev_buffers_alloc(pdev); dp_init_tso_stats(pdev); dp_init_link_peer_stats_enabled(pdev); /* Initialize dp tx fast path flag */ pdev->tx_fast_flag = DP_TX_DESC_FLAG_SIMPLE; if (soc->hw_txrx_stats_en) pdev->tx_fast_flag |= DP_TX_DESC_FLAG_FASTPATH_SIMPLE; pdev->rx_fast_flag = false; dp_info("Mem stats: DMA = %u HEAP = %u SKB = %u", qdf_dma_mem_stats_read(), qdf_heap_mem_stats_read(), qdf_skb_total_mem_stats_read()); return QDF_STATUS_SUCCESS; fail6: dp_pdev_bkp_stats_detach(pdev); fail5: dp_ipa_uc_detach(soc, pdev); fail4: dp_deinit_ipa_rx_refill_buf_ring(soc, pdev); fail3: dp_rxdma_ring_cleanup(soc, pdev); qdf_nbuf_free(pdev->sojourn_buf); fail2: qdf_spinlock_destroy(&pdev->tx_mutex); qdf_spinlock_destroy(&pdev->vdev_list_lock); dp_pdev_srng_deinit(pdev); fail1: dp_wdi_event_detach(pdev); fail0: return QDF_STATUS_E_FAILURE; } /** * dp_pdev_init_wifi3() - Init txrx pdev * @txrx_soc: * @htc_handle: HTC handle for host-target interface * @qdf_osdev: QDF OS device * @pdev_id: pdev Id * * Return: QDF_STATUS */ static QDF_STATUS dp_pdev_init_wifi3(struct cdp_soc_t *txrx_soc, HTC_HANDLE htc_handle, qdf_device_t qdf_osdev, uint8_t pdev_id) { return dp_pdev_init(txrx_soc, htc_handle, qdf_osdev, pdev_id); } #ifdef FEATURE_DIRECT_LINK struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("DP pdev is NULL"); return NULL; } if (dp_srng_alloc(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, DIRECT_LINK_REFILL_RING_ENTRIES, false)) { dp_err("SRNG alloc failed for rx_refill_buf_ring4"); return NULL; } if (dp_srng_init(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, DIRECT_LINK_REFILL_RING_IDX, 0)) { dp_err("SRNG init failed for rx_refill_buf_ring4"); dp_srng_free(soc, &pdev->rx_refill_buf_ring4); return NULL; } if (htt_srng_setup(soc->htt_handle, pdev_id, pdev->rx_refill_buf_ring4.hal_srng, RXDMA_BUF)) { dp_srng_deinit(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, DIRECT_LINK_REFILL_RING_IDX); dp_srng_free(soc, &pdev->rx_refill_buf_ring4); return NULL; } return &pdev->rx_refill_buf_ring4; } void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); if (!pdev) { dp_err("DP pdev is NULL"); return; } dp_srng_deinit(soc, &pdev->rx_refill_buf_ring4, RXDMA_BUF, 0); dp_srng_free(soc, &pdev->rx_refill_buf_ring4); } #endif #ifdef QCA_MULTIPASS_SUPPORT QDF_STATUS dp_set_vlan_groupkey(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint16_t vlan_id, uint16_t group_key) { struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_TX_MULTIPASS); QDF_STATUS status; dp_info("Try: vdev_id %d, vdev %pK, multipass_en %d, vlan_id %d, group_key %d", vdev_id, vdev, vdev ? vdev->multipass_en : 0, vlan_id, group_key); if (!vdev || !vdev->multipass_en) { status = QDF_STATUS_E_INVAL; goto fail; } if (!vdev->iv_vlan_map) { uint16_t vlan_map_size = (sizeof(uint16_t)) * DP_MAX_VLAN_IDS; vdev->iv_vlan_map = (uint16_t *)qdf_mem_malloc(vlan_map_size); if (!vdev->iv_vlan_map) { QDF_TRACE_ERROR(QDF_MODULE_ID_DP, "iv_vlan_map"); status = QDF_STATUS_E_NOMEM; goto fail; } /* * 0 is invalid group key. * Initilalize array with invalid group keys. */ qdf_mem_zero(vdev->iv_vlan_map, vlan_map_size); } if (vlan_id >= DP_MAX_VLAN_IDS) { status = QDF_STATUS_E_INVAL; goto fail; } dp_info("Successful setting: vdev_id %d, vlan_id %d, group_key %d", vdev_id, vlan_id, group_key); vdev->iv_vlan_map[vlan_id] = group_key; status = QDF_STATUS_SUCCESS; fail: if (vdev) dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_TX_MULTIPASS); return status; } void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf) { struct vlan_ethhdr veth_hdr; struct vlan_ethhdr *veh = (struct vlan_ethhdr *)nbuf->data; /* * Extract VLAN header of 4 bytes: * Frame Format : {dst_addr[6], src_addr[6], 802.1Q header[4], * EtherType[2], Payload} * Before Removal : xx xx xx xx xx xx xx xx xx xx xx xx 81 00 00 02 * 08 00 45 00 00... * After Removal : xx xx xx xx xx xx xx xx xx xx xx xx 08 00 45 00 * 00... */ qdf_mem_copy(&veth_hdr, veh, sizeof(veth_hdr)); qdf_nbuf_pull_head(nbuf, ETHERTYPE_VLAN_LEN); veh = (struct vlan_ethhdr *)nbuf->data; qdf_mem_copy(veh, &veth_hdr, 2 * QDF_MAC_ADDR_SIZE); } void dp_tx_vdev_multipass_deinit(struct dp_vdev *vdev) { struct dp_txrx_peer *txrx_peer = NULL; qdf_spin_lock_bh(&vdev->mpass_peer_mutex); TAILQ_FOREACH(txrx_peer, &vdev->mpass_peer_list, mpass_peer_list_elem) qdf_err("Peers present in mpass list : %d", txrx_peer->peer_id); qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); if (vdev->iv_vlan_map) { qdf_mem_free(vdev->iv_vlan_map); vdev->iv_vlan_map = NULL; } qdf_spinlock_destroy(&vdev->mpass_peer_mutex); } void dp_peer_multipass_list_init(struct dp_vdev *vdev) { /* * vdev->iv_vlan_map is allocated when the first configuration command * is issued to avoid unnecessary allocation for regular mode VAP. */ TAILQ_INIT(&vdev->mpass_peer_list); qdf_spinlock_create(&vdev->mpass_peer_mutex); } #endif /* QCA_MULTIPASS_SUPPORT */ #ifdef WLAN_FEATURE_SSR_DRIVER_DUMP #define MAX_STR_LEN 50 #define MAX_SRNG_STR_LEN 30 void dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num) { char ring[MAX_SRNG_STR_LEN], ring_handle[MAX_STR_LEN]; if (num >= 0) qdf_snprint(ring, MAX_SRNG_STR_LEN, "%s%s%d", region_name, "_", num); else qdf_snprint(ring, MAX_SRNG_STR_LEN, "%s", region_name); qdf_snprint(ring_handle, MAX_STR_LEN, "%s%s", ring, "_handle"); qdf_ssr_driver_dump_register_region(ring_handle, srng->hal_srng, sizeof(struct hal_srng)); qdf_ssr_driver_dump_register_region(ring, srng->base_vaddr_aligned, srng->alloc_size); } void dp_ssr_dump_srng_unregister(char *region_name, int num) { char ring[MAX_SRNG_STR_LEN], ring_handle[MAX_STR_LEN]; if (num >= 0) qdf_snprint(ring, MAX_SRNG_STR_LEN, "%s%s%d", region_name, "_", num); else qdf_snprint(ring, MAX_SRNG_STR_LEN, "%s", region_name); qdf_snprint(ring_handle, MAX_STR_LEN, "%s%s", ring, "_handle"); qdf_ssr_driver_dump_unregister_region(ring); qdf_ssr_driver_dump_unregister_region(ring_handle); } void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id) { char pdev_str[MAX_STR_LEN]; qdf_snprint(pdev_str, MAX_STR_LEN, "%s%s%d", "dp_pdev", "_", pdev_id); qdf_ssr_driver_dump_register_region(pdev_str, pdev, sizeof(*pdev)); } void dp_ssr_dump_pdev_unregister(uint8_t pdev_id) { char pdev_str[MAX_STR_LEN]; qdf_snprint(pdev_str, MAX_STR_LEN, "%s%s%d", "dp_pdev", "_", pdev_id); qdf_ssr_driver_dump_unregister_region(pdev_str); } #endif