/* * 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. */ #ifndef _DP_INTERNAL_H_ #define _DP_INTERNAL_H_ #include "dp_types.h" #include "dp_htt.h" #include "dp_rx_tid.h" #define RX_BUFFER_SIZE_PKTLOG_LITE 1024 #define DP_PEER_WDS_COUNT_INVALID UINT_MAX #define DP_BLOCKMEM_SIZE 4096 #define WBM2_SW_PPE_REL_RING_ID 6 #define WBM2_SW_PPE_REL_MAP_ID 11 #define DP_TX_PPEDS_POOL_ID 0xF /* Alignment for consistent memory for DP rings*/ #define DP_RING_BASE_ALIGN 32 #define DP_RSSI_INVAL 0x80 #define DP_RSSI_AVG_WEIGHT 2 /* * Formula to derive avg_rssi is taken from wifi2.o firmware */ #define DP_GET_AVG_RSSI(avg_rssi, last_rssi) \ (((avg_rssi) - (((uint8_t)(avg_rssi)) >> DP_RSSI_AVG_WEIGHT)) \ + ((((uint8_t)(last_rssi)) >> DP_RSSI_AVG_WEIGHT))) /* Macro For NYSM value received in VHT TLV */ #define VHT_SGI_NYSM 3 #define INVALID_WBM_RING_NUM 0xF #ifdef FEATURE_DIRECT_LINK #define DIRECT_LINK_REFILL_RING_ENTRIES 64 #ifdef IPA_OFFLOAD #ifdef IPA_WDI3_VLAN_SUPPORT #define DIRECT_LINK_REFILL_RING_IDX 4 #else #define DIRECT_LINK_REFILL_RING_IDX 3 #endif #else #define DIRECT_LINK_REFILL_RING_IDX 2 #endif #endif #define DP_MAX_VLAN_IDS 4096 #define DP_VLAN_UNTAGGED 0 #define DP_VLAN_TAGGED_MULTICAST 1 #define DP_VLAN_TAGGED_UNICAST 2 /** * struct htt_dbgfs_cfg - structure to maintain required htt data * @msg_word: htt msg sent to upper layer * @m: qdf debugfs file pointer */ struct htt_dbgfs_cfg { uint32_t *msg_word; qdf_debugfs_file_t m; }; /* Cookie MSB bits assigned for different use case. * Note: User can't use last 3 bits, as it is reserved for pdev_id. * If in future number of pdev are more than 3. */ /* Reserve for default case */ #define DBG_STATS_COOKIE_DEFAULT 0x0 /* Reserve for DP Stats: 3rd bit */ #define DBG_STATS_COOKIE_DP_STATS BIT(3) /* Reserve for HTT Stats debugfs support: 4th bit */ #define DBG_STATS_COOKIE_HTT_DBGFS BIT(4) /*Reserve for HTT Stats debugfs support: 5th bit */ #define DBG_SYSFS_STATS_COOKIE BIT(5) /* Reserve for HTT Stats OBSS PD support: 6th bit */ #define DBG_STATS_COOKIE_HTT_OBSS BIT(6) /* * Bitmap of HTT PPDU TLV types for Default mode */ #define HTT_PPDU_DEFAULT_TLV_BITMAP \ (1 << HTT_PPDU_STATS_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) /* PPDU STATS CFG */ #define DP_PPDU_STATS_CFG_ALL 0xFFFF /* PPDU stats mask sent to FW to enable enhanced stats */ #define DP_PPDU_STATS_CFG_ENH_STATS \ (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ (1 << HTT_PPDU_STATS_USERS_INFO_TLV) /* PPDU stats mask sent to FW to support debug sniffer feature */ #define DP_PPDU_STATS_CFG_SNIFFER \ (HTT_PPDU_DEFAULT_TLV_BITMAP) | \ (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV) | \ (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV) | \ (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ (1 << HTT_PPDU_STATS_USERS_INFO_TLV) /* PPDU stats mask sent to FW to support BPR feature*/ #define DP_PPDU_STATS_CFG_BPR \ (1 << HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) | \ (1 << HTT_PPDU_STATS_USERS_INFO_TLV) /* PPDU stats mask sent to FW to support BPR and enhanced stats feature */ #define DP_PPDU_STATS_CFG_BPR_ENH (DP_PPDU_STATS_CFG_BPR | \ DP_PPDU_STATS_CFG_ENH_STATS) /* PPDU stats mask sent to FW to support BPR and pcktlog stats feature */ #define DP_PPDU_STATS_CFG_BPR_PKTLOG (DP_PPDU_STATS_CFG_BPR | \ DP_PPDU_TXLITE_STATS_BITMASK_CFG) /* * Bitmap of HTT PPDU delayed ba TLV types for Default mode */ #define HTT_PPDU_DELAYED_BA_TLV_BITMAP \ (1 << HTT_PPDU_STATS_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_RATE_TLV) /* * Bitmap of HTT PPDU TLV types for Delayed BA */ #define HTT_PPDU_STATUS_TLV_BITMAP \ (1 << HTT_PPDU_STATS_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) /* * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 64 */ #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64 \ ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV) | \ (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV)) /* * Bitmap of HTT PPDU TLV types for Sniffer mode bitmap 256 */ #define HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256 \ ((1 << HTT_PPDU_STATS_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_RATE_TLV) | \ (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) | \ (1 << HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV) | \ (1 << HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV)) static const enum cdp_packet_type hal_2_dp_pkt_type_map[HAL_DOT11_MAX] = { [HAL_DOT11A] = DOT11_A, [HAL_DOT11B] = DOT11_B, [HAL_DOT11N_MM] = DOT11_N, [HAL_DOT11AC] = DOT11_AC, [HAL_DOT11AX] = DOT11_AX, [HAL_DOT11BA] = DOT11_MAX, #ifdef WLAN_FEATURE_11BE [HAL_DOT11BE] = DOT11_BE, #else [HAL_DOT11BE] = DOT11_MAX, #endif [HAL_DOT11AZ] = DOT11_MAX, [HAL_DOT11N_GF] = DOT11_MAX, }; #ifdef GLOBAL_ASSERT_AVOIDANCE #define dp_assert_always_internal_stat(_expr, _handle, _field) \ (qdf_unlikely(!(_expr)) ? ((_handle)->stats._field++, true) : false) #define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \ ((_handle)->ppeds_stats._field++) static inline bool dp_assert_always_internal(bool expr) { return !expr; } #else static inline bool __dp_assert_always_internal(bool expr) { qdf_assert_always(expr); return false; } #define dp_assert_always_internal(_expr) __dp_assert_always_internal(_expr) #define dp_assert_always_internal_stat(_expr, _handle, _field) \ dp_assert_always_internal(_expr) #define dp_assert_always_internal_ds_stat(_expr, _handle, _field) \ dp_assert_always_internal(_expr) #endif #ifdef WLAN_FEATURE_11BE /** * dp_get_mcs_array_index_by_pkt_type_mcs() - get the destination mcs index * in array * @pkt_type: host SW pkt type * @mcs: mcs value for TX/RX rate * * Return: succeeded - valid index in mcs array * fail - same value as MCS_MAX */ static inline uint8_t dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) { uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; switch (pkt_type) { case DOT11_A: dst_mcs_idx = mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; break; case DOT11_B: dst_mcs_idx = mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; break; case DOT11_N: dst_mcs_idx = mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; break; case DOT11_AC: dst_mcs_idx = mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; break; case DOT11_AX: dst_mcs_idx = mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; break; case DOT11_BE: dst_mcs_idx = mcs >= MAX_MCS_11BE ? (MAX_MCS - 1) : mcs; break; default: break; } return dst_mcs_idx; } #else static inline uint8_t dp_get_mcs_array_index_by_pkt_type_mcs(uint32_t pkt_type, uint32_t mcs) { uint8_t dst_mcs_idx = MCS_INVALID_ARRAY_INDEX; switch (pkt_type) { case DOT11_A: dst_mcs_idx = mcs >= MAX_MCS_11A ? (MAX_MCS - 1) : mcs; break; case DOT11_B: dst_mcs_idx = mcs >= MAX_MCS_11B ? (MAX_MCS - 1) : mcs; break; case DOT11_N: dst_mcs_idx = mcs >= MAX_MCS_11N ? (MAX_MCS - 1) : mcs; break; case DOT11_AC: dst_mcs_idx = mcs >= MAX_MCS_11AC ? (MAX_MCS - 1) : mcs; break; case DOT11_AX: dst_mcs_idx = mcs >= MAX_MCS_11AX ? (MAX_MCS - 1) : mcs; break; default: break; } return dst_mcs_idx; } #endif #ifdef WIFI_MONITOR_SUPPORT QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc); QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc); #else static inline QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif /** * dp_rx_err_match_dhost() - function to check whether dest-mac is correct * @eh: Ethernet header of incoming packet * @vdev: dp_vdev object of the VAP on which this data packet is received * * Return: 1 if the destination mac is correct, * 0 if this frame is not correctly destined to this VAP/MLD */ int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev); #ifdef MONITOR_MODULARIZED_ENABLE static inline bool dp_monitor_modularized_enable(void) { return TRUE; } static inline QDF_STATUS dp_mon_soc_attach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_mon_soc_detach_wrapper(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #else static inline bool dp_monitor_modularized_enable(void) { return FALSE; } static inline QDF_STATUS dp_mon_soc_attach_wrapper(struct dp_soc *soc) { return dp_mon_soc_attach(soc); } static inline QDF_STATUS dp_mon_soc_detach_wrapper(struct dp_soc *soc) { return dp_mon_soc_detach(soc); } #endif #ifndef WIFI_MONITOR_SUPPORT #define MON_BUF_MIN_ENTRIES 64 static inline QDF_STATUS dp_monitor_pdev_attach(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_pdev_detach(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_vdev_attach(struct dp_vdev *vdev) { return QDF_STATUS_E_FAILURE; } static inline QDF_STATUS dp_monitor_vdev_detach(struct dp_vdev *vdev) { return QDF_STATUS_E_FAILURE; } static inline QDF_STATUS dp_monitor_peer_attach(struct dp_soc *soc, struct dp_peer *peer) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_peer_detach(struct dp_soc *soc, struct dp_peer *peer) { return QDF_STATUS_E_FAILURE; } static inline struct cdp_peer_rate_stats_ctx* dp_monitor_peer_get_peerstats_ctx(struct dp_soc *soc, struct dp_peer *peer) { return NULL; } static inline void dp_monitor_peer_reset_stats(struct dp_soc *soc, struct dp_peer *peer) { } static inline void dp_monitor_peer_get_stats(struct dp_soc *soc, struct dp_peer *peer, void *arg, enum cdp_stat_update_type type) { } static inline void dp_monitor_invalid_peer_update_pdev_stats(struct dp_soc *soc, struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_peer_get_stats_param(struct dp_soc *soc, struct dp_peer *peer, enum cdp_peer_stats_type type, cdp_peer_stats_param_t *buf) { return QDF_STATUS_E_FAILURE; } static inline QDF_STATUS dp_monitor_pdev_init(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_pdev_deinit(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_soc_cfg_init(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_config_debug_sniffer(struct dp_pdev *pdev, int val) { return QDF_STATUS_E_FAILURE; } static inline void dp_monitor_flush_rings(struct dp_soc *soc) { } static inline QDF_STATUS dp_monitor_htt_srng_setup(struct dp_soc *soc, struct dp_pdev *pdev, int mac_id, int mac_for_pdev) { return QDF_STATUS_SUCCESS; } static inline void dp_monitor_service_mon_rings(struct dp_soc *soc, uint32_t quota) { } static inline uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx, uint32_t mac_id, uint32_t quota) { return 0; } static inline uint32_t dp_monitor_drop_packets_for_mac(struct dp_pdev *pdev, uint32_t mac_id, uint32_t quota) { return 0; } static inline void dp_monitor_peer_tx_init(struct dp_pdev *pdev, struct dp_peer *peer) { } static inline void dp_monitor_peer_tx_cleanup(struct dp_vdev *vdev, struct dp_peer *peer) { } static inline void dp_monitor_peer_tid_peer_id_update(struct dp_soc *soc, struct dp_peer *peer, uint16_t peer_id) { } static inline void dp_monitor_tx_ppdu_stats_attach(struct dp_pdev *pdev) { } static inline void dp_monitor_tx_ppdu_stats_detach(struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_tx_capture_debugfs_init(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline void dp_monitor_peer_tx_capture_filter_check(struct dp_pdev *pdev, struct dp_peer *peer) { } static inline QDF_STATUS dp_monitor_tx_add_to_comp_queue(struct dp_soc *soc, struct dp_tx_desc_s *desc, struct hal_tx_completion_status *ts, uint16_t peer_id) { return QDF_STATUS_E_FAILURE; } static inline QDF_STATUS monitor_update_msdu_to_list(struct dp_soc *soc, struct dp_pdev *pdev, struct dp_peer *peer, struct hal_tx_completion_status *ts, qdf_nbuf_t netbuf) { return QDF_STATUS_E_FAILURE; } static inline bool dp_monitor_ppdu_stats_ind_handler(struct htt_soc *soc, uint32_t *msg_word, qdf_nbuf_t htt_t2h_msg) { return true; } static inline QDF_STATUS dp_monitor_htt_ppdu_stats_attach(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } static inline void dp_monitor_htt_ppdu_stats_detach(struct dp_pdev *pdev) { } static inline void dp_monitor_print_pdev_rx_mon_stats(struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_config_enh_tx_capture(struct dp_pdev *pdev, uint32_t val) { return QDF_STATUS_E_INVAL; } static inline QDF_STATUS dp_monitor_tx_peer_filter(struct dp_pdev *pdev, struct dp_peer *peer, uint8_t is_tx_pkt_cap_enable, uint8_t *peer_mac) { return QDF_STATUS_E_INVAL; } static inline QDF_STATUS dp_monitor_config_enh_rx_capture(struct dp_pdev *pdev, uint32_t val) { return QDF_STATUS_E_INVAL; } static inline QDF_STATUS dp_monitor_set_bpr_enable(struct dp_pdev *pdev, uint32_t val) { return QDF_STATUS_E_FAILURE; } static inline int dp_monitor_set_filter_neigh_peers(struct dp_pdev *pdev, bool val) { return 0; } static inline void dp_monitor_set_atf_stats_enable(struct dp_pdev *pdev, bool value) { } static inline void dp_monitor_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor) { } static inline bool dp_monitor_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle) { return false; } static inline bool dp_monitor_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle) { return false; } static inline bool dp_monitor_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle) { return false; } static inline int dp_monitor_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event, bool enable) { return 0; } static inline void dp_monitor_pktlogmod_exit(struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev) { return QDF_STATUS_E_FAILURE; } static inline void dp_monitor_neighbour_peers_detach(struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_filter_neighbour_peer(struct dp_pdev *pdev, uint8_t *rx_pkt_hdr) { return QDF_STATUS_E_FAILURE; } static inline void dp_monitor_print_pdev_tx_capture_stats(struct dp_pdev *pdev) { } static inline void dp_monitor_reap_timer_init(struct dp_soc *soc) { } static inline void dp_monitor_reap_timer_deinit(struct dp_soc *soc) { } static inline bool dp_monitor_reap_timer_start(struct dp_soc *soc, enum cdp_mon_reap_source source) { return false; } static inline bool dp_monitor_reap_timer_stop(struct dp_soc *soc, enum cdp_mon_reap_source source) { return false; } static inline void dp_monitor_reap_timer_suspend(struct dp_soc *soc) { } static inline void dp_monitor_vdev_timer_init(struct dp_soc *soc) { } static inline void dp_monitor_vdev_timer_deinit(struct dp_soc *soc) { } static inline void dp_monitor_vdev_timer_start(struct dp_soc *soc) { } static inline bool dp_monitor_vdev_timer_stop(struct dp_soc *soc) { return false; } static inline struct qdf_mem_multi_page_t* dp_monitor_get_link_desc_pages(struct dp_soc *soc, uint32_t mac_id) { return NULL; } static inline struct dp_srng* dp_monitor_get_link_desc_ring(struct dp_soc *soc, uint32_t mac_id) { return NULL; } static inline uint32_t dp_monitor_get_num_link_desc_ring_entries(struct dp_soc *soc) { return 0; } static inline uint32_t * dp_monitor_get_total_link_descs(struct dp_soc *soc, uint32_t mac_id) { return NULL; } static inline QDF_STATUS dp_monitor_drop_inv_peer_pkts(struct dp_vdev *vdev) { return QDF_STATUS_E_FAILURE; } static inline bool dp_is_enable_reap_timer_non_pkt(struct dp_pdev *pdev) { return false; } static inline void dp_monitor_vdev_register_osif(struct dp_vdev *vdev, struct ol_txrx_ops *txrx_ops) { } static inline bool dp_monitor_is_vdev_timer_running(struct dp_soc *soc) { return false; } static inline void dp_monitor_pdev_set_mon_vdev(struct dp_vdev *vdev) { } static inline void dp_monitor_vdev_delete(struct dp_soc *soc, struct dp_vdev *vdev) { } static inline void dp_peer_ppdu_delayed_ba_init(struct dp_peer *peer) { } static inline void dp_monitor_neighbour_peer_add_ast(struct dp_pdev *pdev, struct dp_peer *ta_peer, uint8_t *mac_addr, qdf_nbuf_t nbuf, uint32_t flags) { } static inline void dp_monitor_set_chan_band(struct dp_pdev *pdev, enum reg_wifi_band chan_band) { } static inline void dp_monitor_set_chan_freq(struct dp_pdev *pdev, qdf_freq_t chan_freq) { } static inline void dp_monitor_set_chan_num(struct dp_pdev *pdev, int chan_num) { } static inline bool dp_monitor_is_enable_mcopy_mode(struct dp_pdev *pdev) { return false; } static inline void dp_monitor_neighbour_peer_list_remove(struct dp_pdev *pdev, struct dp_vdev *vdev, struct dp_neighbour_peer *peer) { } static inline bool dp_monitor_is_chan_band_known(struct dp_pdev *pdev) { return false; } static inline enum reg_wifi_band dp_monitor_get_chan_band(struct dp_pdev *pdev) { return 0; } static inline int dp_monitor_get_chan_num(struct dp_pdev *pdev) { return 0; } static inline qdf_freq_t dp_monitor_get_chan_freq(struct dp_pdev *pdev) { return 0; } static inline void dp_monitor_get_mpdu_status(struct dp_pdev *pdev, struct dp_soc *soc, uint8_t *rx_tlv_hdr) { } static inline void dp_monitor_print_tx_stats(struct dp_pdev *pdev) { } static inline QDF_STATUS dp_monitor_mcopy_check_deliver(struct dp_pdev *pdev, uint16_t peer_id, uint32_t ppdu_id, uint8_t first_msdu) { return QDF_STATUS_SUCCESS; } static inline bool dp_monitor_is_enable_tx_sniffer(struct dp_pdev *pdev) { return false; } static inline struct dp_vdev* dp_monitor_get_monitor_vdev_from_pdev(struct dp_pdev *pdev) { return NULL; } static inline QDF_STATUS dp_monitor_check_com_info_ppdu_id(struct dp_pdev *pdev, void *rx_desc) { return QDF_STATUS_E_FAILURE; } static inline struct mon_rx_status* dp_monitor_get_rx_status(struct dp_pdev *pdev) { return NULL; } static inline void dp_monitor_pdev_config_scan_spcl_vap(struct dp_pdev *pdev, bool val) { } static inline void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev, bool val) { } static inline QDF_STATUS dp_monitor_peer_tx_capture_get_stats(struct dp_soc *soc, struct dp_peer *peer, struct cdp_peer_tx_capture_stats *stats) { return QDF_STATUS_E_FAILURE; } static inline QDF_STATUS dp_monitor_pdev_tx_capture_get_stats(struct dp_soc *soc, struct dp_pdev *pdev, struct cdp_pdev_tx_capture_stats *stats) { return QDF_STATUS_E_FAILURE; } #ifdef DP_POWER_SAVE static inline void dp_monitor_pktlog_reap_pending_frames(struct dp_pdev *pdev) { } static inline void dp_monitor_pktlog_start_reap_timer(struct dp_pdev *pdev) { } #endif static inline bool dp_monitor_is_configured(struct dp_pdev *pdev) { return false; } static inline void dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_monitor_soc_init(struct dp_soc *soc) { } static inline void dp_monitor_soc_deinit(struct dp_soc *soc) { } static inline QDF_STATUS dp_monitor_config_undecoded_metadata_capture(struct dp_pdev *pdev, int val) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_config_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, int mask1, int mask2) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_get_undecoded_metadata_phyrx_error_mask(struct dp_pdev *pdev, int *mask, int *mask_cont) { return QDF_STATUS_SUCCESS; } static inline QDF_STATUS dp_monitor_soc_htt_srng_setup(struct dp_soc *soc) { return QDF_STATUS_E_FAILURE; } static inline bool dp_is_monitor_mode_using_poll(struct dp_soc *soc) { return false; } static inline uint32_t dp_tx_mon_buf_refill(struct dp_intr *int_ctx) { return 0; } static inline uint32_t dp_tx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx, uint32_t mac_id, uint32_t quota) { return 0; } static inline uint32_t dp_print_txmon_ring_stat_from_hal(struct dp_pdev *pdev) { return 0; } static inline uint32_t dp_rx_mon_buf_refill(struct dp_intr *int_ctx) { return 0; } static inline bool dp_monitor_is_tx_cap_enabled(struct dp_peer *peer) { return 0; } static inline bool dp_monitor_is_rx_cap_enabled(struct dp_peer *peer) { return 0; } static inline void dp_rx_mon_enable(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_wmask_subscribe(struct dp_soc *soc, uint32_t *msg_word, int pdev_id, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_mac_filter_set(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_enable_pkt_tlv_offset(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } static inline void dp_mon_rx_enable_fpmo(struct dp_soc *soc, uint32_t *msg_word, struct htt_rx_ring_tlv_filter *tlv_filter) { } #ifdef WLAN_CONFIG_TELEMETRY_AGENT static inline void dp_monitor_peer_telemetry_stats(struct dp_peer *peer, struct cdp_peer_telemetry_stats *stats) { } static inline void dp_monitor_peer_deter_stats(struct dp_peer *peer, struct cdp_peer_telemetry_stats *stats) { } #endif /* WLAN_CONFIG_TELEMETRY_AGENT */ #endif /* !WIFI_MONITOR_SUPPORT */ /** * cdp_soc_t_to_dp_soc() - typecast cdp_soc_t to * dp soc handle * @psoc: CDP psoc handle * * Return: struct dp_soc pointer */ static inline struct dp_soc *cdp_soc_t_to_dp_soc(struct cdp_soc_t *psoc) { return (struct dp_soc *)psoc; } #define DP_MAX_TIMER_EXEC_TIME_TICKS \ (QDF_LOG_TIMESTAMP_CYCLES_PER_10_US * 100 * 20) /** * enum timer_yield_status - yield status code used in monitor mode timer. * @DP_TIMER_NO_YIELD: do not yield * @DP_TIMER_WORK_DONE: yield because work is done * @DP_TIMER_WORK_EXHAUST: yield because work quota is exhausted * @DP_TIMER_TIME_EXHAUST: yield due to time slot exhausted */ enum timer_yield_status { DP_TIMER_NO_YIELD, DP_TIMER_WORK_DONE, DP_TIMER_WORK_EXHAUST, DP_TIMER_TIME_EXHAUST, }; #if DP_PRINT_ENABLE #include /* qdf_vprint */ #include enum { /* FATAL_ERR - print only irrecoverable error messages */ DP_PRINT_LEVEL_FATAL_ERR, /* ERR - include non-fatal err messages */ DP_PRINT_LEVEL_ERR, /* WARN - include warnings */ DP_PRINT_LEVEL_WARN, /* INFO1 - include fundamental, infrequent events */ DP_PRINT_LEVEL_INFO1, /* INFO2 - include non-fundamental but infrequent events */ DP_PRINT_LEVEL_INFO2, }; #define dp_print(level, fmt, ...) do { \ if (level <= g_txrx_print_level) \ qdf_print(fmt, ## __VA_ARGS__); \ while (0) #define DP_PRINT(level, fmt, ...) do { \ dp_print(level, "DP: " fmt, ## __VA_ARGS__); \ while (0) #else #define DP_PRINT(level, fmt, ...) #endif /* DP_PRINT_ENABLE */ #define DP_TRACE(LVL, fmt, args ...) \ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_##LVL, \ fmt, ## args) #ifdef WLAN_SYSFS_DP_STATS void DP_PRINT_STATS(const char *fmt, ...); #else /* WLAN_SYSFS_DP_STATS */ #ifdef DP_PRINT_NO_CONSOLE /* Stat prints should not go to console or kernel logs.*/ #define DP_PRINT_STATS(fmt, args ...)\ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_HIGH, \ fmt, ## args) #else #define DP_PRINT_STATS(fmt, args ...)\ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,\ fmt, ## args) #endif #endif /* WLAN_SYSFS_DP_STATS */ #define DP_STATS_INIT(_handle) \ qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) #define DP_TXRX_PEER_STATS_INIT(_handle, size) \ qdf_mem_zero(&((_handle)->stats[0]), size) #define DP_STATS_CLR(_handle) \ qdf_mem_zero(&((_handle)->stats), sizeof((_handle)->stats)) #define DP_TXRX_PEER_STATS_CLR(_handle, size) \ qdf_mem_zero(&((_handle)->stats[0]), size) #ifndef DISABLE_DP_STATS #define DP_STATS_INC(_handle, _field, _delta) \ { \ if (likely(_handle)) \ _handle->stats._field += _delta; \ } #define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link) \ { \ if (likely(_handle)) \ _handle->stats[_link]._field += _delta; \ } #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) \ { \ if (likely(_handle)) \ _handle->_field += _delta; \ } #define DP_STATS_INCC(_handle, _field, _delta, _cond) \ { \ if (_cond && likely(_handle)) \ _handle->stats._field += _delta; \ } #define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link) \ { \ if (_cond && likely(_handle)) \ _handle->stats[_link]._field += _delta; \ } #define DP_STATS_DEC(_handle, _field, _delta) \ { \ if (likely(_handle)) \ _handle->stats._field -= _delta; \ } #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) \ { \ if (likely(_handle)) \ _handle->_field -= _delta; \ } #define DP_STATS_UPD(_handle, _field, _delta) \ { \ if (likely(_handle)) \ _handle->stats._field = _delta; \ } #define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link) \ { \ if (likely(_handle)) \ _handle->stats[_link]._field = _delta; \ } #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) \ { \ DP_STATS_INC(_handle, _field.num, _count); \ DP_STATS_INC(_handle, _field.bytes, _bytes) \ } #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) \ { \ DP_PEER_STATS_FLAT_INC(_handle, _field.num, _count); \ DP_PEER_STATS_FLAT_INC(_handle, _field.bytes, _bytes) \ } #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) \ { \ DP_STATS_INCC(_handle, _field.num, _count, _cond); \ DP_STATS_INCC(_handle, _field.bytes, _bytes, _cond) \ } #define DP_STATS_AGGR(_handle_a, _handle_b, _field) \ { \ _handle_a->stats._field += _handle_b->stats._field; \ } #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) \ { \ DP_STATS_AGGR(_handle_a, _handle_b, _field.num); \ DP_STATS_AGGR(_handle_a, _handle_b, _field.bytes);\ } #define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx) \ { \ _handle_a->stats._arr._field += _handle_b->stats._arr[_idx]._field; \ } #define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx)\ { \ DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.num, _idx); \ DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field.bytes, _idx);\ } #define DP_STATS_UPD_STRUCT(_handle_a, _handle_b, _field) \ { \ _handle_a->stats._field = _handle_b->stats._field; \ } #else #define DP_STATS_INC(_handle, _field, _delta) #define DP_PEER_LINK_STATS_INC(_handle, _field, _delta, _link) #define DP_PEER_STATS_FLAT_INC(_handle, _field, _delta) #define DP_STATS_INCC(_handle, _field, _delta, _cond) #define DP_PEER_LINK_STATS_INCC(_handle, _field, _delta, _cond, _link) #define DP_STATS_DEC(_handle, _field, _delta) #define DP_PEER_STATS_FLAT_DEC(_handle, _field, _delta) #define DP_STATS_UPD(_handle, _field, _delta) #define DP_PEER_LINK_STATS_UPD(_handle, _field, _delta, _link) #define DP_STATS_INC_PKT(_handle, _field, _count, _bytes) #define DP_PEER_STATS_FLAT_INC_PKT(_handle, _field, _count, _bytes) #define DP_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond) #define DP_STATS_AGGR(_handle_a, _handle_b, _field) #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field) #define DP_STATS_AGGR_IDX(_handle_a, _handle_b, _arr, _field, _idx) #define DP_STATS_AGGR_PKT_IDX(_handle_a, _handle_b, _arr, _field, _idx) #endif #define DP_PEER_PER_PKT_STATS_INC(_handle, _field, _delta, _link) \ { \ DP_PEER_LINK_STATS_INC(_handle, per_pkt_stats._field, _delta, _link); \ } #define DP_PEER_PER_PKT_STATS_INCC(_handle, _field, _delta, _cond, _link) \ { \ DP_PEER_LINK_STATS_INCC(_handle, per_pkt_stats._field, _delta, _cond, _link); \ } #define DP_PEER_PER_PKT_STATS_INC_PKT(_handle, _field, _count, _bytes, _link) \ { \ DP_PEER_PER_PKT_STATS_INC(_handle, _field.num, _count, _link); \ DP_PEER_PER_PKT_STATS_INC(_handle, _field.bytes, _bytes, _link) \ } #define DP_PEER_PER_PKT_STATS_INCC_PKT(_handle, _field, _count, _bytes, _cond, _link) \ { \ DP_PEER_PER_PKT_STATS_INCC(_handle, _field.num, _count, _cond, _link); \ DP_PEER_PER_PKT_STATS_INCC(_handle, _field.bytes, _bytes, _cond, _link) \ } #define DP_PEER_PER_PKT_STATS_UPD(_handle, _field, _delta, _link) \ { \ DP_PEER_LINK_STATS_UPD(_handle, per_pkt_stats._field, _delta, _link); \ } #ifndef QCA_ENHANCED_STATS_SUPPORT #define DP_PEER_EXTD_STATS_INC(_handle, _field, _delta, _link) \ { \ DP_PEER_LINK_STATS_INC(_handle, extd_stats._field, _delta, _link); \ } #define DP_PEER_EXTD_STATS_INCC(_handle, _field, _delta, _cond, _link) \ { \ DP_PEER_LINK_STATS_INCC(_handle, extd_stats._field, _delta, _cond, _link); \ } #define DP_PEER_EXTD_STATS_UPD(_handle, _field, _delta, _link) \ { \ DP_PEER_LINK_STATS_UPD(_handle, extd_stats._field, _delta, _link); \ } #endif #if defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) && \ defined(QCA_ENHANCED_STATS_SUPPORT) #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ { \ if (_cond || !(_handle->hw_txrx_stats_en)) \ DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ } #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ { \ if (_cond || !(_handle->hw_txrx_stats_en)) \ DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ } #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (_cond || !(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \ } #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (_cond || !(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \ } #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (_cond || !(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \ } #elif defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ { \ if (!(_handle->hw_txrx_stats_en)) \ DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); \ } #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ { \ if (!(_handle->hw_txrx_stats_en)) \ DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); \ } #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (!(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); \ } #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (!(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); \ } #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ { \ if (!(_handle->hw_txrx_stats_en)) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); \ } #else #define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \ DP_PEER_STATS_FLAT_INC_PKT(_handle, to_stack, _count, _bytes); #define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \ DP_PEER_STATS_FLAT_DEC(_handle, to_stack.num, _count); #define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes, _link); #define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes, _link); #define DP_PEER_UC_INCC_PKT(_handle, _count, _bytes, _cond, _link) \ DP_PEER_PER_PKT_STATS_INC_PKT(_handle, rx.unicast, _count, _bytes, _link); #endif #ifdef ENABLE_DP_HIST_STATS #define DP_HIST_INIT() \ uint32_t num_of_packets[MAX_PDEV_CNT] = {0}; #define DP_HIST_PACKET_COUNT_INC(_pdev_id) \ { \ ++num_of_packets[_pdev_id]; \ } #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ do { \ if (_p_cntrs == 1) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_1, 1); \ } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_2_20, 1); \ } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_21_40, 1); \ } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_41_60, 1); \ } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_61_80, 1); \ } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_81_100, 1); \ } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_101_200, 1); \ } else if (_p_cntrs > 200) { \ DP_STATS_INC(_pdev, \ tx_comp_histogram.pkts_201_plus, 1); \ } \ } while (0) #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) \ do { \ if (_p_cntrs == 1) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_1, 1); \ } else if (_p_cntrs > 1 && _p_cntrs <= 20) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_2_20, 1); \ } else if (_p_cntrs > 20 && _p_cntrs <= 40) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_21_40, 1); \ } else if (_p_cntrs > 40 && _p_cntrs <= 60) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_41_60, 1); \ } else if (_p_cntrs > 60 && _p_cntrs <= 80) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_61_80, 1); \ } else if (_p_cntrs > 80 && _p_cntrs <= 100) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_81_100, 1); \ } else if (_p_cntrs > 100 && _p_cntrs <= 200) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_101_200, 1); \ } else if (_p_cntrs > 200) { \ DP_STATS_INC(_pdev, \ rx_ind_histogram.pkts_201_plus, 1); \ } \ } while (0) #define DP_TX_HIST_STATS_PER_PDEV() \ do { \ uint8_t hist_stats = 0; \ for (hist_stats = 0; hist_stats < soc->pdev_count; \ hist_stats++) { \ DP_TX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ num_of_packets[hist_stats]); \ } \ } while (0) #define DP_RX_HIST_STATS_PER_PDEV() \ do { \ uint8_t hist_stats = 0; \ for (hist_stats = 0; hist_stats < soc->pdev_count; \ hist_stats++) { \ DP_RX_HISTOGRAM_UPDATE(soc->pdev_list[hist_stats], \ num_of_packets[hist_stats]); \ } \ } while (0) #else #define DP_HIST_INIT() #define DP_HIST_PACKET_COUNT_INC(_pdev_id) #define DP_TX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) #define DP_RX_HISTOGRAM_UPDATE(_pdev, _p_cntrs) #define DP_RX_HIST_STATS_PER_PDEV() #define DP_TX_HIST_STATS_PER_PDEV() #endif /* DISABLE_DP_STATS */ #define FRAME_MASK_IPV4_ARP 0x1 #define FRAME_MASK_IPV4_DHCP 0x2 #define FRAME_MASK_IPV4_EAPOL 0x4 #define FRAME_MASK_IPV6_DHCP 0x8 #define FRAME_MASK_DNS_QUERY 0x10 #define FRAME_MASK_DNS_RESP 0x20 static inline int dp_log2_ceil(unsigned int value) { unsigned int tmp = value; int log2 = -1; if (qdf_unlikely(value == 0)) return 0; while (tmp) { log2++; tmp >>= 1; } if (1 << log2 != value) log2++; return log2; } #ifdef QCA_SUPPORT_PEER_ISOLATION #define dp_get_peer_isolation(_peer) ((_peer)->isolation) static inline void dp_set_peer_isolation(struct dp_txrx_peer *txrx_peer, bool val) { txrx_peer->isolation = val; } #else #define dp_get_peer_isolation(_peer) (0) static inline void dp_set_peer_isolation(struct dp_txrx_peer *peer, bool val) { } #endif /* QCA_SUPPORT_PEER_ISOLATION */ bool dp_vdev_is_wds_ext_enabled(struct dp_vdev *vdev); #ifdef QCA_SUPPORT_WDS_EXTENDED static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) { txrx_peer->wds_ext.osif_peer = NULL; txrx_peer->wds_ext.init = 0; } #else static inline void dp_wds_ext_peer_init(struct dp_txrx_peer *txrx_peer) { } #endif /* QCA_SUPPORT_WDS_EXTENDED */ #ifdef QCA_HOST2FW_RXBUF_RING static inline struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) { return &pdev->rx_mac_buf_ring[lmac_id]; } #else static inline struct dp_srng *dp_get_rxdma_ring(struct dp_pdev *pdev, int lmac_id) { return &pdev->soc->rx_refill_buf_ring[lmac_id]; } #endif /* * The lmac ID for a particular channel band is fixed. * 2.4GHz band uses lmac_id = 1 * 5GHz/6GHz band uses lmac_id=0 */ #define DP_INVALID_LMAC_ID (-1) #define DP_MON_INVALID_LMAC_ID (-1) #define DP_MAC0_LMAC_ID 0 #define DP_MAC1_LMAC_ID 1 #ifdef FEATURE_TSO_STATS /** * dp_init_tso_stats() - Clear tso stats * @pdev: pdev handle * * Return: None */ static inline void dp_init_tso_stats(struct dp_pdev *pdev) { if (pdev) { qdf_mem_zero(&((pdev)->stats.tso_stats), sizeof((pdev)->stats.tso_stats)); qdf_atomic_init(&pdev->tso_idx); } } /** * dp_stats_tso_segment_histogram_update() - TSO Segment Histogram * @pdev: pdev handle * @_p_cntrs: number of tso segments for a tso packet * * Return: None */ void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, uint8_t _p_cntrs); /** * dp_tso_segment_update() - Collect tso segment information * @pdev: pdev handle * @stats_idx: tso packet number * @idx: tso segment number * @seg: tso segment * * Return: None */ void dp_tso_segment_update(struct dp_pdev *pdev, uint32_t stats_idx, uint8_t idx, struct qdf_tso_seg_t seg); /** * dp_tso_packet_update() - TSO Packet information * @pdev: pdev handle * @stats_idx: tso packet number * @msdu: nbuf handle * @num_segs: tso segments * * Return: None */ void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, qdf_nbuf_t msdu, uint16_t num_segs); /** * dp_tso_segment_stats_update() - TSO Segment stats * @pdev: pdev handle * @stats_seg: tso segment list * @stats_idx: tso packet number * * Return: None */ void dp_tso_segment_stats_update(struct dp_pdev *pdev, struct qdf_tso_seg_elem_t *stats_seg, uint32_t stats_idx); /** * dp_print_tso_stats() - dump tso statistics * @soc:soc handle * @level: verbosity level * * Return: None */ void dp_print_tso_stats(struct dp_soc *soc, enum qdf_stats_verbosity_level level); /** * dp_txrx_clear_tso_stats() - clear tso stats * @soc: soc handle * * Return: None */ void dp_txrx_clear_tso_stats(struct dp_soc *soc); #else static inline void dp_init_tso_stats(struct dp_pdev *pdev) { } static inline void dp_stats_tso_segment_histogram_update(struct dp_pdev *pdev, uint8_t _p_cntrs) { } static inline void dp_tso_segment_update(struct dp_pdev *pdev, uint32_t stats_idx, uint32_t idx, struct qdf_tso_seg_t seg) { } static inline void dp_tso_packet_update(struct dp_pdev *pdev, uint32_t stats_idx, qdf_nbuf_t msdu, uint16_t num_segs) { } static inline void dp_tso_segment_stats_update(struct dp_pdev *pdev, struct qdf_tso_seg_elem_t *stats_seg, uint32_t stats_idx) { } static inline void dp_print_tso_stats(struct dp_soc *soc, enum qdf_stats_verbosity_level level) { } static inline void dp_txrx_clear_tso_stats(struct dp_soc *soc) { } #endif /* FEATURE_TSO_STATS */ /** * dp_txrx_get_peer_per_pkt_stats_param() - Get peer per pkt stats param * @peer: DP peer handle * @type: Requested stats type * @buf: Buffer to hold the value * * Return: status success/failure */ QDF_STATUS dp_txrx_get_peer_per_pkt_stats_param(struct dp_peer *peer, enum cdp_peer_stats_type type, cdp_peer_stats_param_t *buf); /** * dp_txrx_get_peer_extd_stats_param() - Get peer extd stats param * @peer: DP peer handle * @type: Requested stats type * @buf: Buffer to hold the value * * Return: status success/failure */ QDF_STATUS dp_txrx_get_peer_extd_stats_param(struct dp_peer *peer, enum cdp_peer_stats_type type, cdp_peer_stats_param_t *buf); #define DP_HTT_T2H_HP_PIPE 5 /** * dp_update_pdev_stats(): Update the pdev stats * @tgtobj: pdev handle * @srcobj: vdev stats structure * * Update the pdev stats from the specified vdev stats * * Return: None */ void dp_update_pdev_stats(struct dp_pdev *tgtobj, struct cdp_vdev_stats *srcobj); /** * dp_update_vdev_ingress_stats(): Update the vdev ingress stats * @tgtobj: vdev handle * * Update the vdev ingress stats * * Return: None */ void dp_update_vdev_ingress_stats(struct dp_vdev *tgtobj); /** * dp_update_vdev_rate_stats() - Update the vdev rate stats * @tgtobj: tgt buffer for cdp vdev stats * @srcobj: srcobj dp vdev stats * * Return: None */ void dp_update_vdev_rate_stats(struct cdp_vdev_stats *tgtobj, struct dp_vdev_stats *srcobj); /** * dp_update_pdev_ingress_stats(): Update the pdev ingress stats * @tgtobj: pdev handle * @srcobj: vdev stats structure * * Update the pdev ingress stats from the specified vdev stats * * Return: None */ void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj, struct dp_vdev *srcobj); /** * dp_copy_vdev_stats_to_tgt_buf(): Update the cdp vdev ingress stats from * dp vdev ingress stats * @vdev_stats: cdp vdev stats structure * @stats: dp vdev stats structure * @xmit_type: xmit type of packet - MLD/Link * * Update the cdp vdev ingress stats from dp vdev ingress stats * * Return: None */ void dp_copy_vdev_stats_to_tgt_buf(struct cdp_vdev_stats *vdev_stats, struct dp_vdev_stats *stats, enum dp_pkt_xmit_type xmit_type); /** * dp_update_vdev_stats(): Update the vdev stats * @soc: soc handle * @srcobj: DP_PEER object * @arg: point to vdev stats structure * * Update the vdev stats from the specified peer stats * * Return: None */ void dp_update_vdev_stats(struct dp_soc *soc, struct dp_peer *srcobj, void *arg); /** * dp_update_vdev_stats_on_peer_unmap() - Update the vdev stats on peer unmap * @vdev: DP_VDEV handle * @peer: DP_PEER handle * * Return: None */ void dp_update_vdev_stats_on_peer_unmap(struct dp_vdev *vdev, struct dp_peer *peer); #ifdef IPA_OFFLOAD #define DP_IPA_UPDATE_RX_STATS(__tgtobj, __srcobj) \ { \ DP_STATS_AGGR_PKT(__tgtobj, __srcobj, rx.rx_total); \ } #define DP_IPA_UPDATE_PER_PKT_RX_STATS(__tgtobj, __srcobj) \ { \ (__tgtobj)->rx.rx_total.num += (__srcobj)->rx.rx_total.num; \ (__tgtobj)->rx.rx_total.bytes += (__srcobj)->rx.rx_total.bytes; \ } #else #define DP_IPA_UPDATE_PER_PKT_RX_STATS(tgtobj, srcobj) \ #define DP_IPA_UPDATE_RX_STATS(tgtobj, srcobj) #endif #define DP_UPDATE_STATS(_tgtobj, _srcobj) \ do { \ uint8_t i; \ uint8_t pream_type; \ for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ for (i = 0; i < MAX_MCS; i++) { \ DP_STATS_AGGR(_tgtobj, _srcobj, \ tx.pkt_type[pream_type].mcs_count[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, \ rx.pkt_type[pream_type].mcs_count[i]); \ } \ } \ \ for (i = 0; i < MAX_BW; i++) { \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.bw[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.bw[i]); \ } \ \ for (i = 0; i < SS_COUNT; i++) { \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.nss[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.nss[i]); \ } \ for (i = 0; i < WME_AC_MAX; i++) { \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.wme_ac_type[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.wme_ac_type[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, \ tx.wme_ac_type_bytes[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, \ rx.wme_ac_type_bytes[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.excess_retries_per_ac[i]); \ \ } \ \ for (i = 0; i < MAX_GI; i++) { \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.sgi_count[i]); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.sgi_count[i]); \ } \ \ for (i = 0; i < MAX_RECEPTION_TYPES; i++) \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.reception_type[i]); \ \ if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) { \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.comp_pkt); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.tx_failed); \ } \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.ucast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.mcast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.bcast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_success); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.nawds_mcast); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.nawds_mcast_drop); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.ofdma); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.stbc); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.ldpc); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.retries); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_amsdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.amsdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.non_ampdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.ampdu_cnt); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.dropped.fw_rem); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_tx); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_notx); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason1); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason2); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_reason3); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_queue_disable); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.fw_rem_no_match); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_threshold); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.drop_link_desc_na); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_drop); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.mcast_vdev_drop); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.invalid_rr); \ DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.age_out); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_total); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, tx.tx_ucast_success); \ \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.mic_err); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.fcserr); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.pn_err); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.oor_err); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.jump_2k_err); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.rxdma_wifi_parse_err); \ if (_srcobj->stats.rx.snr != 0) \ DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.snr); \ DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.rx_rate); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_ampdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.ampdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_amsdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.amsdu_cnt); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.nawds_mcast_drop); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.to_stack); \ \ for (i = 0; i < CDP_MAX_RX_RINGS; i++) \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rcvd_reo[i]); \ \ for (i = 0; i < CDP_MAX_LMACS; i++) \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.rx_lmac[i]); \ \ _srcobj->stats.rx.unicast.num = \ _srcobj->stats.rx.to_stack.num - \ _srcobj->stats.rx.multicast.num; \ _srcobj->stats.rx.unicast.bytes = \ _srcobj->stats.rx.to_stack.bytes - \ _srcobj->stats.rx.multicast.bytes; \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.unicast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.multicast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.bcast); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.raw); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.pkts); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.intra_bss.fail); \ DP_STATS_AGGR_PKT(_tgtobj, _srcobj, rx.mec_drop); \ \ _tgtobj->stats.tx.last_ack_rssi = \ _srcobj->stats.tx.last_ack_rssi; \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.multipass_rx_pkt_drop); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.peer_unauth_rx_pkt_drop); \ DP_STATS_AGGR(_tgtobj, _srcobj, rx.policy_check_drop); \ DP_IPA_UPDATE_RX_STATS(_tgtobj, _srcobj); \ } while (0) #ifdef VDEV_PEER_PROTOCOL_COUNT #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) \ { \ uint8_t j; \ for (j = 0; j < CDP_TRACE_MAX; j++) { \ _tgtobj->tx.protocol_trace_cnt[j].egress_cnt += \ _srcobj->tx.protocol_trace_cnt[j].egress_cnt; \ _tgtobj->tx.protocol_trace_cnt[j].ingress_cnt += \ _srcobj->tx.protocol_trace_cnt[j].ingress_cnt; \ _tgtobj->rx.protocol_trace_cnt[j].egress_cnt += \ _srcobj->rx.protocol_trace_cnt[j].egress_cnt; \ _tgtobj->rx.protocol_trace_cnt[j].ingress_cnt += \ _srcobj->rx.protocol_trace_cnt[j].ingress_cnt; \ } \ } #else #define DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj) #endif #ifdef WLAN_FEATURE_11BE #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) \ do { \ uint8_t i, mu_type; \ for (i = 0; i < MAX_MCS; i++) { \ _tgtobj->tx.su_be_ppdu_cnt.mcs_count[i] += \ _srcobj->tx.su_be_ppdu_cnt.mcs_count[i]; \ _tgtobj->rx.su_be_ppdu_cnt.mcs_count[i] += \ _srcobj->rx.su_be_ppdu_cnt.mcs_count[i]; \ } \ for (mu_type = 0; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ for (i = 0; i < MAX_MCS; i++) { \ _tgtobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ _srcobj->tx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ _tgtobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i] += \ _srcobj->rx.mu_be_ppdu_cnt[mu_type].mcs_count[i]; \ } \ } \ for (i = 0; i < MAX_PUNCTURED_MODE; i++) { \ _tgtobj->tx.punc_bw[i] += _srcobj->tx.punc_bw[i]; \ _tgtobj->rx.punc_bw[i] += _srcobj->rx.punc_bw[i]; \ } \ } while (0) #else #define DP_UPDATE_11BE_STATS(_tgtobj, _srcobj) #endif #define DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj) \ do { \ _tgtobj->tx.comp_pkt.num += _srcobj->tx.comp_pkt.num; \ _tgtobj->tx.comp_pkt.bytes += _srcobj->tx.comp_pkt.bytes; \ _tgtobj->tx.tx_failed += _srcobj->tx.tx_failed; \ _tgtobj->rx.to_stack.num += _srcobj->rx.to_stack.num; \ _tgtobj->rx.to_stack.bytes += _srcobj->rx.to_stack.bytes; \ } while (0) #define DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj) \ do { \ uint8_t i; \ _tgtobj->tx.ucast.num += _srcobj->tx.ucast.num; \ _tgtobj->tx.ucast.bytes += _srcobj->tx.ucast.bytes; \ _tgtobj->tx.mcast.num += _srcobj->tx.mcast.num; \ _tgtobj->tx.mcast.bytes += _srcobj->tx.mcast.bytes; \ _tgtobj->tx.bcast.num += _srcobj->tx.bcast.num; \ _tgtobj->tx.bcast.bytes += _srcobj->tx.bcast.bytes; \ _tgtobj->tx.nawds_mcast.num += _srcobj->tx.nawds_mcast.num; \ _tgtobj->tx.nawds_mcast.bytes += \ _srcobj->tx.nawds_mcast.bytes; \ _tgtobj->tx.tx_success.num += _srcobj->tx.tx_success.num; \ _tgtobj->tx.tx_success.bytes += _srcobj->tx.tx_success.bytes; \ _tgtobj->tx.nawds_mcast_drop += _srcobj->tx.nawds_mcast_drop; \ _tgtobj->tx.ofdma += _srcobj->tx.ofdma; \ _tgtobj->tx.non_amsdu_cnt += _srcobj->tx.non_amsdu_cnt; \ _tgtobj->tx.amsdu_cnt += _srcobj->tx.amsdu_cnt; \ _tgtobj->tx.dropped.fw_rem.num += \ _srcobj->tx.dropped.fw_rem.num; \ _tgtobj->tx.dropped.fw_rem.bytes += \ _srcobj->tx.dropped.fw_rem.bytes; \ _tgtobj->tx.dropped.fw_rem_notx += \ _srcobj->tx.dropped.fw_rem_notx; \ _tgtobj->tx.dropped.fw_rem_tx += \ _srcobj->tx.dropped.fw_rem_tx; \ _tgtobj->tx.dropped.age_out += _srcobj->tx.dropped.age_out; \ _tgtobj->tx.dropped.fw_reason1 += \ _srcobj->tx.dropped.fw_reason1; \ _tgtobj->tx.dropped.fw_reason2 += \ _srcobj->tx.dropped.fw_reason2; \ _tgtobj->tx.dropped.fw_reason3 += \ _srcobj->tx.dropped.fw_reason3; \ _tgtobj->tx.dropped.fw_rem_queue_disable += \ _srcobj->tx.dropped.fw_rem_queue_disable; \ _tgtobj->tx.dropped.fw_rem_no_match += \ _srcobj->tx.dropped.fw_rem_no_match; \ _tgtobj->tx.dropped.drop_threshold += \ _srcobj->tx.dropped.drop_threshold; \ _tgtobj->tx.dropped.drop_link_desc_na += \ _srcobj->tx.dropped.drop_link_desc_na; \ _tgtobj->tx.dropped.invalid_drop += \ _srcobj->tx.dropped.invalid_drop; \ _tgtobj->tx.dropped.mcast_vdev_drop += \ _srcobj->tx.dropped.mcast_vdev_drop; \ _tgtobj->tx.dropped.invalid_rr += \ _srcobj->tx.dropped.invalid_rr; \ _tgtobj->tx.failed_retry_count += \ _srcobj->tx.failed_retry_count; \ _tgtobj->tx.retry_count += _srcobj->tx.retry_count; \ _tgtobj->tx.multiple_retry_count += \ _srcobj->tx.multiple_retry_count; \ _tgtobj->tx.tx_success_twt.num += \ _srcobj->tx.tx_success_twt.num; \ _tgtobj->tx.tx_success_twt.bytes += \ _srcobj->tx.tx_success_twt.bytes; \ _tgtobj->tx.last_tx_ts = _srcobj->tx.last_tx_ts; \ _tgtobj->tx.release_src_not_tqm += \ _srcobj->tx.release_src_not_tqm; \ for (i = 0; i < QDF_PROTO_SUBTYPE_MAX; i++) { \ _tgtobj->tx.no_ack_count[i] += \ _srcobj->tx.no_ack_count[i];\ } \ \ _tgtobj->rx.multicast.num += _srcobj->rx.multicast.num; \ _tgtobj->rx.multicast.bytes += _srcobj->rx.multicast.bytes; \ _tgtobj->rx.rx_success.num += _srcobj->rx.rx_success.num;\ _tgtobj->rx.rx_success.bytes += _srcobj->rx.rx_success.bytes;\ _tgtobj->rx.bcast.num += _srcobj->rx.bcast.num; \ _tgtobj->rx.bcast.bytes += _srcobj->rx.bcast.bytes; \ _tgtobj->rx.unicast.num += _srcobj->rx.unicast.num; \ _tgtobj->rx.unicast.bytes += _srcobj->rx.unicast.bytes; \ _tgtobj->rx.raw.num += _srcobj->rx.raw.num; \ _tgtobj->rx.raw.bytes += _srcobj->rx.raw.bytes; \ _tgtobj->rx.nawds_mcast_drop += _srcobj->rx.nawds_mcast_drop; \ _tgtobj->rx.mcast_3addr_drop += _srcobj->rx.mcast_3addr_drop; \ _tgtobj->rx.mec_drop.num += _srcobj->rx.mec_drop.num; \ _tgtobj->rx.mec_drop.bytes += _srcobj->rx.mec_drop.bytes; \ _tgtobj->rx.ppeds_drop.num += _srcobj->rx.ppeds_drop.num; \ _tgtobj->rx.ppeds_drop.bytes += _srcobj->rx.ppeds_drop.bytes; \ _tgtobj->rx.intra_bss.pkts.num += \ _srcobj->rx.intra_bss.pkts.num; \ _tgtobj->rx.intra_bss.pkts.bytes += \ _srcobj->rx.intra_bss.pkts.bytes; \ _tgtobj->rx.intra_bss.fail.num += \ _srcobj->rx.intra_bss.fail.num; \ _tgtobj->rx.intra_bss.fail.bytes += \ _srcobj->rx.intra_bss.fail.bytes; \ _tgtobj->rx.intra_bss.mdns_no_fwd += \ _srcobj->rx.intra_bss.mdns_no_fwd; \ _tgtobj->rx.err.mic_err += _srcobj->rx.err.mic_err; \ _tgtobj->rx.err.decrypt_err += _srcobj->rx.err.decrypt_err; \ _tgtobj->rx.err.fcserr += _srcobj->rx.err.fcserr; \ _tgtobj->rx.err.pn_err += _srcobj->rx.err.pn_err; \ _tgtobj->rx.err.oor_err += _srcobj->rx.err.oor_err; \ _tgtobj->rx.err.jump_2k_err += _srcobj->rx.err.jump_2k_err; \ _tgtobj->rx.err.rxdma_wifi_parse_err += \ _srcobj->rx.err.rxdma_wifi_parse_err; \ _tgtobj->rx.non_amsdu_cnt += _srcobj->rx.non_amsdu_cnt; \ _tgtobj->rx.amsdu_cnt += _srcobj->rx.amsdu_cnt; \ _tgtobj->rx.rx_retries += _srcobj->rx.rx_retries; \ _tgtobj->rx.multipass_rx_pkt_drop += \ _srcobj->rx.multipass_rx_pkt_drop; \ _tgtobj->rx.peer_unauth_rx_pkt_drop += \ _srcobj->rx.peer_unauth_rx_pkt_drop; \ _tgtobj->rx.policy_check_drop += \ _srcobj->rx.policy_check_drop; \ _tgtobj->rx.to_stack_twt.num += _srcobj->rx.to_stack_twt.num; \ _tgtobj->rx.to_stack_twt.bytes += \ _srcobj->rx.to_stack_twt.bytes; \ _tgtobj->rx.last_rx_ts = _srcobj->rx.last_rx_ts; \ for (i = 0; i < CDP_MAX_RX_RINGS; i++) { \ _tgtobj->rx.rcvd_reo[i].num += \ _srcobj->rx.rcvd_reo[i].num; \ _tgtobj->rx.rcvd_reo[i].bytes += \ _srcobj->rx.rcvd_reo[i].bytes; \ _tgtobj->rx.rcvd.num += \ _srcobj->rx.rcvd_reo[i].num; \ _tgtobj->rx.rcvd.bytes += \ _srcobj->rx.rcvd_reo[i].bytes; \ } \ for (i = 0; i < CDP_MAX_LMACS; i++) { \ _tgtobj->rx.rx_lmac[i].num += \ _srcobj->rx.rx_lmac[i].num; \ _tgtobj->rx.rx_lmac[i].bytes += \ _srcobj->rx.rx_lmac[i].bytes; \ } \ DP_IPA_UPDATE_PER_PKT_RX_STATS(_tgtobj, _srcobj); \ DP_UPDATE_PROTOCOL_COUNT_STATS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj) \ do { \ uint8_t i, pream_type, mu_type; \ _tgtobj->tx.stbc += _srcobj->tx.stbc; \ _tgtobj->tx.ldpc += _srcobj->tx.ldpc; \ _tgtobj->tx.retries += _srcobj->tx.retries; \ _tgtobj->tx.ampdu_cnt += _srcobj->tx.ampdu_cnt; \ _tgtobj->tx.non_ampdu_cnt += _srcobj->tx.non_ampdu_cnt; \ _tgtobj->tx.num_ppdu_cookie_valid += \ _srcobj->tx.num_ppdu_cookie_valid; \ _tgtobj->tx.tx_ppdus += _srcobj->tx.tx_ppdus; \ _tgtobj->tx.tx_mpdus_success += _srcobj->tx.tx_mpdus_success; \ _tgtobj->tx.tx_mpdus_tried += _srcobj->tx.tx_mpdus_tried; \ _tgtobj->tx.tx_rate = _srcobj->tx.tx_rate; \ _tgtobj->tx.last_tx_rate = _srcobj->tx.last_tx_rate; \ _tgtobj->tx.last_tx_rate_mcs = _srcobj->tx.last_tx_rate_mcs; \ _tgtobj->tx.mcast_last_tx_rate = \ _srcobj->tx.mcast_last_tx_rate; \ _tgtobj->tx.mcast_last_tx_rate_mcs = \ _srcobj->tx.mcast_last_tx_rate_mcs; \ _tgtobj->tx.rnd_avg_tx_rate = _srcobj->tx.rnd_avg_tx_rate; \ _tgtobj->tx.avg_tx_rate = _srcobj->tx.avg_tx_rate; \ _tgtobj->tx.tx_ratecode = _srcobj->tx.tx_ratecode; \ _tgtobj->tx.pream_punct_cnt += _srcobj->tx.pream_punct_cnt; \ _tgtobj->tx.ru_start = _srcobj->tx.ru_start; \ _tgtobj->tx.ru_tones = _srcobj->tx.ru_tones; \ _tgtobj->tx.last_ack_rssi = _srcobj->tx.last_ack_rssi; \ _tgtobj->tx.nss_info = _srcobj->tx.nss_info; \ _tgtobj->tx.mcs_info = _srcobj->tx.mcs_info; \ _tgtobj->tx.bw_info = _srcobj->tx.bw_info; \ _tgtobj->tx.gi_info = _srcobj->tx.gi_info; \ _tgtobj->tx.preamble_info = _srcobj->tx.preamble_info; \ _tgtobj->tx.retries_mpdu += _srcobj->tx.retries_mpdu; \ _tgtobj->tx.mpdu_success_with_retries += \ _srcobj->tx.mpdu_success_with_retries; \ _tgtobj->tx.rts_success = _srcobj->tx.rts_success; \ _tgtobj->tx.rts_failure = _srcobj->tx.rts_failure; \ _tgtobj->tx.bar_cnt = _srcobj->tx.bar_cnt; \ _tgtobj->tx.ndpa_cnt = _srcobj->tx.ndpa_cnt; \ for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ for (i = 0; i < MAX_MCS; i++) \ _tgtobj->tx.pkt_type[pream_type].mcs_count[i] += \ _srcobj->tx.pkt_type[pream_type].mcs_count[i]; \ } \ for (i = 0; i < WME_AC_MAX; i++) { \ _tgtobj->tx.wme_ac_type[i] += _srcobj->tx.wme_ac_type[i]; \ _tgtobj->tx.wme_ac_type_bytes[i] += \ _srcobj->tx.wme_ac_type_bytes[i]; \ _tgtobj->tx.excess_retries_per_ac[i] += \ _srcobj->tx.excess_retries_per_ac[i]; \ } \ for (i = 0; i < MAX_GI; i++) { \ _tgtobj->tx.sgi_count[i] += _srcobj->tx.sgi_count[i]; \ } \ for (i = 0; i < SS_COUNT; i++) { \ _tgtobj->tx.nss[i] += _srcobj->tx.nss[i]; \ } \ for (i = 0; i < MAX_BW; i++) { \ _tgtobj->tx.bw[i] += _srcobj->tx.bw[i]; \ } \ for (i = 0; i < MAX_RU_LOCATIONS; i++) { \ _tgtobj->tx.ru_loc[i].num_msdu += \ _srcobj->tx.ru_loc[i].num_msdu; \ _tgtobj->tx.ru_loc[i].num_mpdu += \ _srcobj->tx.ru_loc[i].num_mpdu; \ _tgtobj->tx.ru_loc[i].mpdu_tried += \ _srcobj->tx.ru_loc[i].mpdu_tried; \ } \ for (i = 0; i < MAX_TRANSMIT_TYPES; i++) { \ _tgtobj->tx.transmit_type[i].num_msdu += \ _srcobj->tx.transmit_type[i].num_msdu; \ _tgtobj->tx.transmit_type[i].num_mpdu += \ _srcobj->tx.transmit_type[i].num_mpdu; \ _tgtobj->tx.transmit_type[i].mpdu_tried += \ _srcobj->tx.transmit_type[i].mpdu_tried; \ } \ for (i = 0; i < MAX_MU_GROUP_ID; i++) { \ _tgtobj->tx.mu_group_id[i] = _srcobj->tx.mu_group_id[i]; \ } \ _tgtobj->tx.tx_ucast_total.num += \ _srcobj->tx.tx_ucast_total.num;\ _tgtobj->tx.tx_ucast_total.bytes += \ _srcobj->tx.tx_ucast_total.bytes;\ _tgtobj->tx.tx_ucast_success.num += \ _srcobj->tx.tx_ucast_success.num; \ _tgtobj->tx.tx_ucast_success.bytes += \ _srcobj->tx.tx_ucast_success.bytes; \ \ for (i = 0; i < CDP_RSSI_CHAIN_LEN; i++) \ _tgtobj->tx.rssi_chain[i] = _srcobj->tx.rssi_chain[i]; \ _tgtobj->rx.mpdu_cnt_fcs_ok += _srcobj->rx.mpdu_cnt_fcs_ok; \ _tgtobj->rx.mpdu_cnt_fcs_err += _srcobj->rx.mpdu_cnt_fcs_err; \ _tgtobj->rx.non_ampdu_cnt += _srcobj->rx.non_ampdu_cnt; \ _tgtobj->rx.ampdu_cnt += _srcobj->rx.ampdu_cnt; \ _tgtobj->rx.rx_mpdus += _srcobj->rx.rx_mpdus; \ _tgtobj->rx.rx_ppdus += _srcobj->rx.rx_ppdus; \ _tgtobj->rx.rx_rate = _srcobj->rx.rx_rate; \ _tgtobj->rx.last_rx_rate = _srcobj->rx.last_rx_rate; \ _tgtobj->rx.rnd_avg_rx_rate = _srcobj->rx.rnd_avg_rx_rate; \ _tgtobj->rx.avg_rx_rate = _srcobj->rx.avg_rx_rate; \ _tgtobj->rx.rx_ratecode = _srcobj->rx.rx_ratecode; \ _tgtobj->rx.avg_snr = _srcobj->rx.avg_snr; \ _tgtobj->rx.rx_snr_measured_time = \ _srcobj->rx.rx_snr_measured_time; \ _tgtobj->rx.snr = _srcobj->rx.snr; \ _tgtobj->rx.last_snr = _srcobj->rx.last_snr; \ _tgtobj->rx.nss_info = _srcobj->rx.nss_info; \ _tgtobj->rx.mcs_info = _srcobj->rx.mcs_info; \ _tgtobj->rx.bw_info = _srcobj->rx.bw_info; \ _tgtobj->rx.gi_info = _srcobj->rx.gi_info; \ _tgtobj->rx.preamble_info = _srcobj->rx.preamble_info; \ _tgtobj->rx.mpdu_retry_cnt += _srcobj->rx.mpdu_retry_cnt; \ _tgtobj->rx.bar_cnt = _srcobj->rx.bar_cnt; \ _tgtobj->rx.ndpa_cnt = _srcobj->rx.ndpa_cnt; \ for (pream_type = 0; pream_type < DOT11_MAX; pream_type++) { \ for (i = 0; i < MAX_MCS; i++) { \ _tgtobj->rx.pkt_type[pream_type].mcs_count[i] += \ _srcobj->rx.pkt_type[pream_type].mcs_count[i]; \ } \ } \ for (i = 0; i < WME_AC_MAX; i++) { \ _tgtobj->rx.wme_ac_type[i] += _srcobj->rx.wme_ac_type[i]; \ _tgtobj->rx.wme_ac_type_bytes[i] += \ _srcobj->rx.wme_ac_type_bytes[i]; \ } \ for (i = 0; i < MAX_MCS; i++) { \ _tgtobj->rx.su_ax_ppdu_cnt.mcs_count[i] += \ _srcobj->rx.su_ax_ppdu_cnt.mcs_count[i]; \ _tgtobj->rx.rx_mpdu_cnt[i] += _srcobj->rx.rx_mpdu_cnt[i]; \ } \ for (mu_type = 0 ; mu_type < TXRX_TYPE_MU_MAX; mu_type++) { \ _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok += \ _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_ok; \ _tgtobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err += \ _srcobj->rx.rx_mu[mu_type].mpdu_cnt_fcs_err; \ for (i = 0; i < SS_COUNT; i++) \ _tgtobj->rx.rx_mu[mu_type].ppdu_nss[i] += \ _srcobj->rx.rx_mu[mu_type].ppdu_nss[i]; \ for (i = 0; i < MAX_MCS; i++) \ _tgtobj->rx.rx_mu[mu_type].ppdu.mcs_count[i] += \ _srcobj->rx.rx_mu[mu_type].ppdu.mcs_count[i]; \ } \ for (i = 0; i < MAX_RECEPTION_TYPES; i++) { \ _tgtobj->rx.reception_type[i] += \ _srcobj->rx.reception_type[i]; \ _tgtobj->rx.ppdu_cnt[i] += _srcobj->rx.ppdu_cnt[i]; \ } \ for (i = 0; i < MAX_GI; i++) { \ _tgtobj->rx.sgi_count[i] += _srcobj->rx.sgi_count[i]; \ } \ for (i = 0; i < SS_COUNT; i++) { \ _tgtobj->rx.nss[i] += _srcobj->rx.nss[i]; \ _tgtobj->rx.ppdu_nss[i] += _srcobj->rx.ppdu_nss[i]; \ } \ for (i = 0; i < MAX_BW; i++) { \ _tgtobj->rx.bw[i] += _srcobj->rx.bw[i]; \ } \ DP_UPDATE_11BE_STATS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj) \ do { \ DP_UPDATE_BASIC_STATS(_tgtobj, _srcobj); \ DP_UPDATE_PER_PKT_STATS(_tgtobj, _srcobj); \ DP_UPDATE_EXTD_STATS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj) \ do { \ _tgtobj->rx_i.reo_rcvd_pkt.num += \ _srcobj->rx_i.reo_rcvd_pkt.num; \ _tgtobj->rx_i.reo_rcvd_pkt.bytes += \ _srcobj->rx_i.reo_rcvd_pkt.bytes; \ _tgtobj->rx_i.null_q_desc_pkt.num += \ _srcobj->rx_i.null_q_desc_pkt.num; \ _tgtobj->rx_i.null_q_desc_pkt.bytes += \ _srcobj->rx_i.null_q_desc_pkt.bytes; \ _tgtobj->rx_i.routed_eapol_pkt.num += \ _srcobj->rx_i.routed_eapol_pkt.num; \ _tgtobj->rx_i.routed_eapol_pkt.bytes += \ _srcobj->rx_i.routed_eapol_pkt.bytes; \ } while (0) #define DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \ do { \ uint8_t i = 0; \ uint8_t idx = 0; \ enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \ if (temp_xmit_type == DP_XMIT_MLD) { \ idx = DP_VDEV_XMIT_TYPE; \ temp_xmit_type = DP_VDEV_XMIT_TYPE; \ } else if (temp_xmit_type == DP_XMIT_TOTAL) { \ temp_xmit_type = DP_VDEV_XMIT_TYPE; \ } \ for (; idx <= temp_xmit_type; idx++) { \ _tgtobj->tx_i.rcvd.num += _srcobj->tx_i[idx].rcvd.num; \ _tgtobj->tx_i.rcvd.bytes += \ _srcobj->tx_i[idx].rcvd.bytes; \ _tgtobj->tx_i.rcvd_in_fast_xmit_flow += \ _srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \ for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \ _tgtobj->tx_i.rcvd_per_core[i] += \ _srcobj->tx_i[idx].rcvd_per_core[i]; \ } \ _tgtobj->tx_i.processed.num += \ _srcobj->tx_i[idx].processed.num; \ _tgtobj->tx_i.processed.bytes += \ _srcobj->tx_i[idx].processed.bytes; \ _tgtobj->tx_i.reinject_pkts.num += \ _srcobj->tx_i[idx].reinject_pkts.num; \ _tgtobj->tx_i.reinject_pkts.bytes += \ _srcobj->tx_i[idx].reinject_pkts.bytes; \ _tgtobj->tx_i.inspect_pkts.num += \ _srcobj->tx_i[idx].inspect_pkts.num; \ _tgtobj->tx_i.inspect_pkts.bytes += \ _srcobj->tx_i[idx].inspect_pkts.bytes; \ _tgtobj->tx_i.nawds_mcast.num += \ _srcobj->tx_i[idx].nawds_mcast.num; \ _tgtobj->tx_i.nawds_mcast.bytes += \ _srcobj->tx_i[idx].nawds_mcast.bytes; \ _tgtobj->tx_i.bcast.num += \ _srcobj->tx_i[idx].bcast.num; \ _tgtobj->tx_i.bcast.bytes += \ _srcobj->tx_i[idx].bcast.bytes; \ _tgtobj->tx_i.raw.raw_pkt.num += \ _srcobj->tx_i[idx].raw.raw_pkt.num; \ _tgtobj->tx_i.raw.raw_pkt.bytes += \ _srcobj->tx_i[idx].raw.raw_pkt.bytes; \ _tgtobj->tx_i.raw.dma_map_error += \ _srcobj->tx_i[idx].raw.dma_map_error; \ _tgtobj->tx_i.raw.invalid_raw_pkt_datatype += \ _srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \ _tgtobj->tx_i.raw.num_frags_overflow_err += \ _srcobj->tx_i[idx].raw.num_frags_overflow_err; \ _tgtobj->tx_i.sg.sg_pkt.num += \ _srcobj->tx_i[idx].sg.sg_pkt.num; \ _tgtobj->tx_i.sg.sg_pkt.bytes += \ _srcobj->tx_i[idx].sg.sg_pkt.bytes; \ _tgtobj->tx_i.sg.non_sg_pkts.num += \ _srcobj->tx_i[idx].sg.non_sg_pkts.num; \ _tgtobj->tx_i.sg.non_sg_pkts.bytes += \ _srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \ _tgtobj->tx_i.sg.dropped_host.num += \ _srcobj->tx_i[idx].sg.dropped_host.num; \ _tgtobj->tx_i.sg.dropped_host.bytes += \ _srcobj->tx_i[idx].sg.dropped_host.bytes; \ _tgtobj->tx_i.sg.dropped_target += \ _srcobj->tx_i[idx].sg.dropped_target; \ _tgtobj->tx_i.sg.dma_map_error += \ _srcobj->tx_i[idx].sg.dma_map_error; \ _tgtobj->tx_i.mcast_en.mcast_pkt.num += \ _srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \ _tgtobj->tx_i.mcast_en.mcast_pkt.bytes += \ _srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \ _tgtobj->tx_i.mcast_en.dropped_map_error += \ _srcobj->tx_i[idx].mcast_en.dropped_map_error; \ _tgtobj->tx_i.mcast_en.dropped_self_mac += \ _srcobj->tx_i[idx].mcast_en.dropped_self_mac; \ _tgtobj->tx_i.mcast_en.dropped_send_fail += \ _srcobj->tx_i[idx].mcast_en.dropped_send_fail; \ _tgtobj->tx_i.mcast_en.ucast += \ _srcobj->tx_i[idx].mcast_en.ucast; \ _tgtobj->tx_i.mcast_en.fail_seg_alloc += \ _srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \ _tgtobj->tx_i.mcast_en.clone_fail += \ _srcobj->tx_i[idx].mcast_en.clone_fail; \ _tgtobj->tx_i.igmp_mcast_en.igmp_rcvd += \ _srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \ _tgtobj->tx_i.igmp_mcast_en.igmp_ucast_converted += \ _srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \ _tgtobj->tx_i.dropped.desc_na.num += \ _srcobj->tx_i[idx].dropped.desc_na.num; \ _tgtobj->tx_i.dropped.desc_na.bytes += \ _srcobj->tx_i[idx].dropped.desc_na.bytes; \ _tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.num += \ _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \ _tgtobj->tx_i.dropped.desc_na_exc_alloc_fail.bytes += \ _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \ _tgtobj->tx_i.dropped.desc_na_exc_outstand.num += \ _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \ _tgtobj->tx_i.dropped.desc_na_exc_outstand.bytes += \ _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \ _tgtobj->tx_i.dropped.exc_desc_na.num += \ _srcobj->tx_i[idx].dropped.exc_desc_na.num; \ _tgtobj->tx_i.dropped.exc_desc_na.bytes += \ _srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \ _tgtobj->tx_i.dropped.ring_full += \ _srcobj->tx_i[idx].dropped.ring_full; \ _tgtobj->tx_i.dropped.enqueue_fail += \ _srcobj->tx_i[idx].dropped.enqueue_fail; \ _tgtobj->tx_i.dropped.dma_error += \ _srcobj->tx_i[idx].dropped.dma_error; \ _tgtobj->tx_i.dropped.res_full += \ _srcobj->tx_i[idx].dropped.res_full; \ _tgtobj->tx_i.dropped.headroom_insufficient += \ _srcobj->tx_i[idx].dropped.headroom_insufficient; \ _tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check += \ _srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \ _tgtobj->tx_i.dropped.drop_ingress += \ _srcobj->tx_i[idx].dropped.drop_ingress; \ _tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path += \ _srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \ _tgtobj->tx_i.dropped.tx_mcast_drop += \ _srcobj->tx_i[idx].dropped.tx_mcast_drop; \ _tgtobj->tx_i.dropped.fw2wbm_tx_drop += \ _srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ _tgtobj->tx_i.dropped.dropped_pkt.bytes += \ _srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \ _tgtobj->tx_i.mesh.exception_fw += \ _srcobj->tx_i[idx].mesh.exception_fw; \ _tgtobj->tx_i.mesh.completion_fw += \ _srcobj->tx_i[idx].mesh.completion_fw; \ _tgtobj->tx_i.cce_classified += \ _srcobj->tx_i[idx].cce_classified; \ _tgtobj->tx_i.cce_classified_raw += \ _srcobj->tx_i[idx].cce_classified_raw; \ _tgtobj->tx_i.sniffer_rcvd.num += \ _srcobj->tx_i[idx].sniffer_rcvd.num; \ _tgtobj->tx_i.sniffer_rcvd.bytes += \ _srcobj->tx_i[idx].sniffer_rcvd.bytes; \ } \ _tgtobj->tx_i.dropped.dropped_pkt.num = \ _tgtobj->tx_i.dropped.dma_error + \ _tgtobj->tx_i.dropped.ring_full + \ _tgtobj->tx_i.dropped.enqueue_fail + \ _tgtobj->tx_i.dropped.fail_per_pkt_vdev_id_check + \ _tgtobj->tx_i.dropped.desc_na.num + \ _tgtobj->tx_i.dropped.res_full + \ _tgtobj->tx_i.dropped.drop_ingress + \ _tgtobj->tx_i.dropped.headroom_insufficient + \ _tgtobj->tx_i.dropped.invalid_peer_id_in_exc_path + \ _tgtobj->tx_i.dropped.tx_mcast_drop + \ _tgtobj->tx_i.dropped.fw2wbm_tx_drop; \ DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type) \ do { \ uint8_t i = 0; \ uint8_t idx = 0; \ enum dp_pkt_xmit_type temp_xmit_type = _xmit_type; \ if (temp_xmit_type == DP_XMIT_MLD) { \ idx = DP_VDEV_XMIT_TYPE; \ temp_xmit_type = DP_VDEV_XMIT_TYPE; \ } else if (temp_xmit_type == DP_XMIT_TOTAL) { \ temp_xmit_type = DP_VDEV_XMIT_TYPE; \ } \ for (; idx <= temp_xmit_type; idx++) { \ _tgtobj->tx_i[idx].rcvd.num += _srcobj->tx_i[idx].rcvd.num; \ _tgtobj->tx_i[idx].rcvd.bytes += \ _srcobj->tx_i[idx].rcvd.bytes; \ _tgtobj->tx_i[idx].rcvd_in_fast_xmit_flow += \ _srcobj->tx_i[idx].rcvd_in_fast_xmit_flow; \ for (i = 0; i < CDP_MAX_TX_DATA_RINGS; i++) { \ _tgtobj->tx_i[idx].rcvd_per_core[i] += \ _srcobj->tx_i[idx].rcvd_per_core[i]; \ } \ _tgtobj->tx_i[idx].processed.num += \ _srcobj->tx_i[idx].processed.num; \ _tgtobj->tx_i[idx].processed.bytes += \ _srcobj->tx_i[idx].processed.bytes; \ _tgtobj->tx_i[idx].reinject_pkts.num += \ _srcobj->tx_i[idx].reinject_pkts.num; \ _tgtobj->tx_i[idx].reinject_pkts.bytes += \ _srcobj->tx_i[idx].reinject_pkts.bytes; \ _tgtobj->tx_i[idx].inspect_pkts.num += \ _srcobj->tx_i[idx].inspect_pkts.num; \ _tgtobj->tx_i[idx].inspect_pkts.bytes += \ _srcobj->tx_i[idx].inspect_pkts.bytes; \ _tgtobj->tx_i[idx].nawds_mcast.num += \ _srcobj->tx_i[idx].nawds_mcast.num; \ _tgtobj->tx_i[idx].nawds_mcast.bytes += \ _srcobj->tx_i[idx].nawds_mcast.bytes; \ _tgtobj->tx_i[idx].bcast.num += \ _srcobj->tx_i[idx].bcast.num; \ _tgtobj->tx_i[idx].bcast.bytes += \ _srcobj->tx_i[idx].bcast.bytes; \ _tgtobj->tx_i[idx].raw.raw_pkt.num += \ _srcobj->tx_i[idx].raw.raw_pkt.num; \ _tgtobj->tx_i[idx].raw.raw_pkt.bytes += \ _srcobj->tx_i[idx].raw.raw_pkt.bytes; \ _tgtobj->tx_i[idx].raw.dma_map_error += \ _srcobj->tx_i[idx].raw.dma_map_error; \ _tgtobj->tx_i[idx].raw.invalid_raw_pkt_datatype += \ _srcobj->tx_i[idx].raw.invalid_raw_pkt_datatype; \ _tgtobj->tx_i[idx].raw.num_frags_overflow_err += \ _srcobj->tx_i[idx].raw.num_frags_overflow_err; \ _tgtobj->tx_i[idx].sg.sg_pkt.num += \ _srcobj->tx_i[idx].sg.sg_pkt.num; \ _tgtobj->tx_i[idx].sg.sg_pkt.bytes += \ _srcobj->tx_i[idx].sg.sg_pkt.bytes; \ _tgtobj->tx_i[idx].sg.non_sg_pkts.num += \ _srcobj->tx_i[idx].sg.non_sg_pkts.num; \ _tgtobj->tx_i[idx].sg.non_sg_pkts.bytes += \ _srcobj->tx_i[idx].sg.non_sg_pkts.bytes; \ _tgtobj->tx_i[idx].sg.dropped_host.num += \ _srcobj->tx_i[idx].sg.dropped_host.num; \ _tgtobj->tx_i[idx].sg.dropped_host.bytes += \ _srcobj->tx_i[idx].sg.dropped_host.bytes; \ _tgtobj->tx_i[idx].sg.dropped_target += \ _srcobj->tx_i[idx].sg.dropped_target; \ _tgtobj->tx_i[idx].sg.dma_map_error += \ _srcobj->tx_i[idx].sg.dma_map_error; \ _tgtobj->tx_i[idx].mcast_en.mcast_pkt.num += \ _srcobj->tx_i[idx].mcast_en.mcast_pkt.num; \ _tgtobj->tx_i[idx].mcast_en.mcast_pkt.bytes += \ _srcobj->tx_i[idx].mcast_en.mcast_pkt.bytes; \ _tgtobj->tx_i[idx].mcast_en.dropped_map_error += \ _srcobj->tx_i[idx].mcast_en.dropped_map_error; \ _tgtobj->tx_i[idx].mcast_en.dropped_self_mac += \ _srcobj->tx_i[idx].mcast_en.dropped_self_mac; \ _tgtobj->tx_i[idx].mcast_en.dropped_send_fail += \ _srcobj->tx_i[idx].mcast_en.dropped_send_fail; \ _tgtobj->tx_i[idx].mcast_en.ucast += \ _srcobj->tx_i[idx].mcast_en.ucast; \ _tgtobj->tx_i[idx].mcast_en.fail_seg_alloc += \ _srcobj->tx_i[idx].mcast_en.fail_seg_alloc; \ _tgtobj->tx_i[idx].mcast_en.clone_fail += \ _srcobj->tx_i[idx].mcast_en.clone_fail; \ _tgtobj->tx_i[idx].igmp_mcast_en.igmp_rcvd += \ _srcobj->tx_i[idx].igmp_mcast_en.igmp_rcvd; \ _tgtobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted += \ _srcobj->tx_i[idx].igmp_mcast_en.igmp_ucast_converted; \ _tgtobj->tx_i[idx].dropped.desc_na.num += \ _srcobj->tx_i[idx].dropped.desc_na.num; \ _tgtobj->tx_i[idx].dropped.desc_na.bytes += \ _srcobj->tx_i[idx].dropped.desc_na.bytes; \ _tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num += \ _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.num; \ _tgtobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes += \ _srcobj->tx_i[idx].dropped.desc_na_exc_alloc_fail.bytes; \ _tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.num += \ _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.num; \ _tgtobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes += \ _srcobj->tx_i[idx].dropped.desc_na_exc_outstand.bytes; \ _tgtobj->tx_i[idx].dropped.exc_desc_na.num += \ _srcobj->tx_i[idx].dropped.exc_desc_na.num; \ _tgtobj->tx_i[idx].dropped.exc_desc_na.bytes += \ _srcobj->tx_i[idx].dropped.exc_desc_na.bytes; \ _tgtobj->tx_i[idx].dropped.ring_full += \ _srcobj->tx_i[idx].dropped.ring_full; \ _tgtobj->tx_i[idx].dropped.enqueue_fail += \ _srcobj->tx_i[idx].dropped.enqueue_fail; \ _tgtobj->tx_i[idx].dropped.dma_error += \ _srcobj->tx_i[idx].dropped.dma_error; \ _tgtobj->tx_i[idx].dropped.res_full += \ _srcobj->tx_i[idx].dropped.res_full; \ _tgtobj->tx_i[idx].dropped.headroom_insufficient += \ _srcobj->tx_i[idx].dropped.headroom_insufficient; \ _tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check += \ _srcobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check; \ _tgtobj->tx_i[idx].dropped.drop_ingress += \ _srcobj->tx_i[idx].dropped.drop_ingress; \ _tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path += \ _srcobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path; \ _tgtobj->tx_i[idx].dropped.tx_mcast_drop += \ _srcobj->tx_i[idx].dropped.tx_mcast_drop; \ _tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop += \ _srcobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ _tgtobj->tx_i[idx].dropped.dropped_pkt.bytes += \ _srcobj->tx_i[idx].dropped.dropped_pkt.bytes; \ _tgtobj->tx_i[idx].mesh.exception_fw += \ _srcobj->tx_i[idx].mesh.exception_fw; \ _tgtobj->tx_i[idx].mesh.completion_fw += \ _srcobj->tx_i[idx].mesh.completion_fw; \ _tgtobj->tx_i[idx].cce_classified += \ _srcobj->tx_i[idx].cce_classified; \ _tgtobj->tx_i[idx].cce_classified_raw += \ _srcobj->tx_i[idx].cce_classified_raw; \ _tgtobj->tx_i[idx].sniffer_rcvd.num += \ _srcobj->tx_i[idx].sniffer_rcvd.num; \ _tgtobj->tx_i[idx].sniffer_rcvd.bytes += \ _srcobj->tx_i[idx].sniffer_rcvd.bytes; \ _tgtobj->tx_i[idx].dropped.dropped_pkt.num = \ _tgtobj->tx_i[idx].dropped.dma_error + \ _tgtobj->tx_i[idx].dropped.ring_full + \ _tgtobj->tx_i[idx].dropped.enqueue_fail + \ _tgtobj->tx_i[idx].dropped.fail_per_pkt_vdev_id_check + \ _tgtobj->tx_i[idx].dropped.desc_na.num + \ _tgtobj->tx_i[idx].dropped.res_full + \ _tgtobj->tx_i[idx].dropped.drop_ingress + \ _tgtobj->tx_i[idx].dropped.headroom_insufficient + \ _tgtobj->tx_i[idx].dropped.invalid_peer_id_in_exc_path + \ _tgtobj->tx_i[idx].dropped.tx_mcast_drop + \ _tgtobj->tx_i[idx].dropped.fw2wbm_tx_drop; \ } \ DP_UPDATE_RX_INGRESS_STATS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_TO_MLD_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \ do { \ DP_UPDATE_MLD_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \ DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \ } while (0) #define DP_UPDATE_TO_LINK_VDEV_STATS(_tgtobj, _srcobj, _xmit_type) \ do { \ DP_UPDATE_LINK_VDEV_INGRESS_STATS(_tgtobj, _srcobj, _xmit_type); \ DP_UPDATE_VDEV_STATS_FOR_UNMAPPED_PEERS(_tgtobj, _srcobj); \ } while (0) /** * dp_peer_find_attach() - Allocates memory for peer objects * @soc: SoC handle * * Return: QDF_STATUS */ QDF_STATUS dp_peer_find_attach(struct dp_soc *soc); /** * dp_peer_find_detach() - Frees memory for peer objects * @soc: SoC handle * * Return: none */ void dp_peer_find_detach(struct dp_soc *soc); /** * dp_peer_find_hash_add() - add peer to peer_hash_table * @soc: soc handle * @peer: peer handle * * Return: none */ void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer); /** * dp_peer_find_hash_remove() - remove peer from peer_hash_table * @soc: soc handle * @peer: peer handle * * Return: none */ void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer); /* unused?? */ void dp_peer_find_hash_erase(struct dp_soc *soc); /** * dp_peer_vdev_list_add() - add peer into vdev's peer list * @soc: soc handle * @vdev: vdev handle * @peer: peer handle * * Return: none */ void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev, struct dp_peer *peer); /** * dp_peer_vdev_list_remove() - remove peer from vdev's peer list * @soc: SoC handle * @vdev: VDEV handle * @peer: peer handle * * Return: none */ void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev, struct dp_peer *peer); /** * dp_peer_find_id_to_obj_add() - Add peer into peer_id table * @soc: SoC handle * @peer: peer handle * @peer_id: peer_id * * Return: None */ void dp_peer_find_id_to_obj_add(struct dp_soc *soc, struct dp_peer *peer, uint16_t peer_id); /** * dp_txrx_peer_attach_add() - Attach txrx_peer and add it to peer_id table * @soc: SoC handle * @peer: peer handle * @txrx_peer: txrx peer handle * * Return: None */ void dp_txrx_peer_attach_add(struct dp_soc *soc, struct dp_peer *peer, struct dp_txrx_peer *txrx_peer); /** * dp_peer_find_id_to_obj_remove() - remove peer from peer_id table * @soc: SoC handle * @peer_id: peer_id * * Return: None */ void dp_peer_find_id_to_obj_remove(struct dp_soc *soc, uint16_t peer_id); /** * dp_vdev_unref_delete() - check and process vdev delete * @soc: DP specific soc pointer * @vdev: DP specific vdev pointer * @mod_id: module id * */ void dp_vdev_unref_delete(struct dp_soc *soc, struct dp_vdev *vdev, enum dp_mod_id mod_id); /** * dp_peer_ppdu_delayed_ba_cleanup() - free ppdu allocated in peer * @peer: Datapath peer * * Return: void */ void dp_peer_ppdu_delayed_ba_cleanup(struct dp_peer *peer); /** * dp_peer_rx_init() - Initialize receive TID state * @pdev: Datapath pdev * @peer: Datapath peer * */ void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer); /** * dp_peer_rx_init_wrapper() - Initialize receive TID state, based on peer type * @pdev: Datapath pdev * @peer: Datapath peer * @setup_info: setup info received for setting up the peer * * Return: None */ void dp_peer_rx_init_wrapper(struct dp_pdev *pdev, struct dp_peer *peer, struct cdp_peer_setup_info *setup_info); /** * dp_peer_cleanup() - Cleanup peer information * @vdev: Datapath vdev * @peer: Datapath peer * */ void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer); #ifdef DP_PEER_EXTENDED_API /** * dp_register_peer() - Register peer into physical device * @soc_hdl: data path soc handle * @pdev_id: device instance id * @sta_desc: peer description * * Register peer into physical device * * Return: QDF_STATUS_SUCCESS registration success * QDF_STATUS_E_FAULT peer not found */ QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct ol_txrx_desc_type *sta_desc); /** * dp_clear_peer() - remove peer from physical device * @soc_hdl: data path soc handle * @pdev_id: device instance id * @peer_addr: peer mac address * * remove peer from physical device * * Return: QDF_STATUS_SUCCESS registration success * QDF_STATUS_E_FAULT peer not found */ QDF_STATUS dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct qdf_mac_addr peer_addr); /** * dp_find_peer_exist_on_vdev - find if peer exists on the given vdev * @soc_hdl: datapath soc handle * @vdev_id: vdev instance id * @peer_addr: peer mac address * * Return: true or false */ bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_addr); /** * dp_find_peer_exist_on_other_vdev - find if peer exists * on other than the given vdev * @soc_hdl: datapath soc handle * @vdev_id: vdev instance id * @peer_addr: peer mac address * @max_bssid: max number of bssids * * Return: true or false */ bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_addr, uint16_t max_bssid); /** * dp_peer_state_update() - update peer local state * @soc: datapath soc handle * @peer_mac: peer mac address * @state: new peer local state * * update peer local state * * Return: QDF_STATUS_SUCCESS registration success */ QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc, uint8_t *peer_mac, enum ol_txrx_peer_state state); /** * dp_get_vdevid() - Get virtual interface id which peer registered * @soc_hdl: datapath soc handle * @peer_mac: peer mac address * @vdev_id: virtual interface id which peer registered * * Get virtual interface id which peer registered * * Return: QDF_STATUS_SUCCESS registration success */ QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, uint8_t *vdev_id); struct cdp_vdev *dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle, struct qdf_mac_addr peer_addr); /** * dp_get_vdev_for_peer() - Get virtual interface instance which peer belongs * @peer: peer instance * * Get virtual interface instance which peer belongs * * Return: virtual interface instance pointer * NULL in case cannot find */ struct cdp_vdev *dp_get_vdev_for_peer(void *peer); /** * dp_peer_get_peer_mac_addr() - Get peer mac address * @peer: peer instance * * Get peer mac address * * Return: peer mac address pointer * NULL in case cannot find */ uint8_t *dp_peer_get_peer_mac_addr(void *peer); /** * dp_get_peer_state() - Get local peer state * @soc: datapath soc handle * @vdev_id: vdev id * @peer_mac: peer mac addr * @slowpath: call from slowpath or not * * Get local peer state * * Return: peer status */ int dp_get_peer_state(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, bool slowpath); /** * dp_local_peer_id_pool_init() - local peer id pool alloc for physical device * @pdev: data path device instance * * local peer id pool alloc for physical device * * Return: none */ void dp_local_peer_id_pool_init(struct dp_pdev *pdev); /** * dp_local_peer_id_alloc() - allocate local peer id * @pdev: data path device instance * @peer: new peer instance * * allocate local peer id * * Return: none */ void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer); /** * dp_local_peer_id_free() - remove local peer id * @pdev: data path device instance * @peer: peer instance should be removed * * remove local peer id * * Return: none */ void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer); /** * dp_set_peer_as_tdls_peer() - set tdls peer flag to peer * @soc_hdl: datapath soc handle * @vdev_id: vdev_id * @peer_mac: peer mac addr * @val: tdls peer flag * * Return: none */ void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, bool val); #else static inline QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac, uint8_t *vdev_id) { return QDF_STATUS_E_NOSUPPORT; } static inline void dp_local_peer_id_pool_init(struct dp_pdev *pdev) { } static inline void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer) { } static inline void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer) { } static inline void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, bool val) { } #endif /** * dp_find_peer_exist - find peer if already exists * @soc_hdl: datapath soc handle * @pdev_id: physical device instance id * @peer_addr: peer mac address * * Return: true or false */ bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint8_t *peer_addr); #ifdef DP_UMAC_HW_RESET_SUPPORT /** * dp_pause_reo_send_cmd() - Pause Reo send commands. * @soc: dp soc * * Return: none */ void dp_pause_reo_send_cmd(struct dp_soc *soc); /** * dp_resume_reo_send_cmd() - Resume Reo send commands. * @soc: dp soc * * Return: none */ void dp_resume_reo_send_cmd(struct dp_soc *soc); /** * dp_cleanup_reo_cmd_module - Clean up the reo cmd module * @soc: DP SoC handle * * Return: none */ void dp_cleanup_reo_cmd_module(struct dp_soc *soc); /** * dp_reo_desc_freelist_destroy() - Flush REO descriptors from deferred freelist * @soc: DP SOC handle * * Return: none */ void dp_reo_desc_freelist_destroy(struct dp_soc *soc); /** * dp_reset_rx_reo_tid_queue() - Reset the reo tid queues * @soc: dp soc * @hw_qdesc_vaddr: starting address of the tid queues * @size: size of the memory pointed to by hw_qdesc_vaddr * * Return: none */ void dp_reset_rx_reo_tid_queue(struct dp_soc *soc, void *hw_qdesc_vaddr, uint32_t size); static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc) { notify_pre_reset_fw_callback callback = soc->notify_fw_callback; if (callback) callback(soc); } /** * dp_reset_global_tx_desc_cleanup_flag() - Reset cleanup needed flag * @soc: dp soc handle * * Return: None */ void dp_reset_global_tx_desc_cleanup_flag(struct dp_soc *soc); /** * dp_get_global_tx_desc_cleanup_flag() - Get cleanup needed flag * @soc: dp soc handle * * Return: cleanup needed/ not needed */ bool dp_get_global_tx_desc_cleanup_flag(struct dp_soc *soc); #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) /** * dp_umac_reset_complete_umac_recovery() - Complete Umac reset session * @soc: dp soc handle * * Return: void */ void dp_umac_reset_complete_umac_recovery(struct dp_soc *soc); /** * dp_umac_reset_initiate_umac_recovery() - Initiate Umac reset session * @soc: dp soc handle * @umac_reset_ctx: Umac reset context * @rx_event: Rx event received * @is_target_recovery: Flag to indicate if it is triggered for target recovery * * Return: status */ QDF_STATUS dp_umac_reset_initiate_umac_recovery(struct dp_soc *soc, struct dp_soc_umac_reset_ctx *umac_reset_ctx, enum umac_reset_rx_event rx_event, bool is_target_recovery); /** * dp_umac_reset_handle_action_cb() - Function to call action callback * @soc: dp soc handle * @umac_reset_ctx: Umac reset context * @action: Action to call the callback for * * Return: QDF_STATUS status */ QDF_STATUS dp_umac_reset_handle_action_cb(struct dp_soc *soc, struct dp_soc_umac_reset_ctx *umac_reset_ctx, enum umac_reset_action action); /** * dp_umac_reset_post_tx_cmd() - Iterate partner socs and post Tx command * @umac_reset_ctx: UMAC reset context * @tx_cmd: Tx command to be posted * * Return: QDF status of operation */ QDF_STATUS dp_umac_reset_post_tx_cmd(struct dp_soc_umac_reset_ctx *umac_reset_ctx, enum umac_reset_tx_cmd tx_cmd); /** * dp_umac_reset_initiator_check() - Check if soc is the Umac reset initiator * @soc: dp soc handle * * Return: true if the soc is initiator or false otherwise */ bool dp_umac_reset_initiator_check(struct dp_soc *soc); /** * dp_umac_reset_target_recovery_check() - Check if this is for target recovery * @soc: dp soc handle * * Return: true if the session is for target recovery or false otherwise */ bool dp_umac_reset_target_recovery_check(struct dp_soc *soc); /** * dp_umac_reset_is_soc_ignored() - Check if this soc is to be ignored * @soc: dp soc handle * * Return: true if the soc is ignored or false otherwise */ bool dp_umac_reset_is_soc_ignored(struct dp_soc *soc); /** * dp_mlo_umac_reset_stats_print() - API to print MLO umac reset stats * @soc: dp soc handle * * Return: QDF_STATUS */ QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc); #else static inline QDF_STATUS dp_mlo_umac_reset_stats_print(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif #else static inline void dp_umac_reset_trigger_pre_reset_notify_cb(struct dp_soc *soc) { } #endif #if defined(DP_UMAC_HW_RESET_SUPPORT) && defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) /** * dp_umac_reset_notify_asserted_soc() - API to notify the asserted SOC * @soc: dp soc * * Return: QDF_STATUS */ QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc); /** * dp_get_umac_reset_in_progress_state() - API to check umac reset in progress * state * @psoc: dp soc handle * * Return: umac reset state */ enum cdp_umac_reset_state dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc); #else static inline QDF_STATUS dp_umac_reset_notify_asserted_soc(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } static inline enum cdp_umac_reset_state dp_get_umac_reset_in_progress_state(struct cdp_soc_t *psoc) { return CDP_UMAC_RESET_NOT_IN_PROGRESS; } #endif #ifndef WLAN_SOFTUMAC_SUPPORT QDF_STATUS dp_reo_send_cmd(struct dp_soc *soc, enum hal_reo_cmd_type type, struct hal_reo_cmd_params *params, void (*callback_fn), void *data); /** * dp_reo_cmdlist_destroy() - Free REO commands in the queue * @soc: DP SoC handle * * Return: none */ void dp_reo_cmdlist_destroy(struct dp_soc *soc); /** * dp_reo_status_ring_handler() - Handler for REO Status ring * @int_ctx: pointer to DP interrupt context * @soc: DP Soc handle * * Return: Number of descriptors reaped */ uint32_t dp_reo_status_ring_handler(struct dp_intr *int_ctx, struct dp_soc *soc); #endif /** * dp_aggregate_vdev_stats() - Consolidate stats at VDEV level * @vdev: DP VDEV handle * @vdev_stats: aggregate statistics * @xmit_type: xmit type of packet - MLD/Link * return: void */ void dp_aggregate_vdev_stats(struct dp_vdev *vdev, struct cdp_vdev_stats *vdev_stats, enum dp_pkt_xmit_type xmit_type); /** * 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); /** * dp_rx_bar_stats_cb() - BAR received stats callback * @soc: SOC handle * @cb_ctxt: Call back context * @reo_status: Reo status * * Return: void */ void dp_rx_bar_stats_cb(struct dp_soc *soc, void *cb_ctxt, union hal_reo_status *reo_status); uint16_t dp_tx_me_send_convert_ucast(struct cdp_soc_t *soc, uint8_t vdev_id, qdf_nbuf_t nbuf, uint8_t newmac[][QDF_MAC_ADDR_SIZE], uint8_t new_mac_cnt, uint8_t tid, bool is_igmp, bool is_dms_pkt); void dp_tx_me_alloc_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); void dp_tx_me_free_descriptor(struct cdp_soc_t *soc, uint8_t pdev_id); /** * dp_h2t_ext_stats_msg_send(): function to construct HTT message to pass to FW * @pdev: DP PDEV handle * @stats_type_upload_mask: stats type requested by user * @config_param_0: extra configuration parameters * @config_param_1: extra configuration parameters * @config_param_2: extra configuration parameters * @config_param_3: extra configuration parameters * @cookie: * @cookie_msb: * @mac_id: mac number * * Return: QDF STATUS */ QDF_STATUS dp_h2t_ext_stats_msg_send(struct dp_pdev *pdev, uint32_t stats_type_upload_mask, uint32_t config_param_0, uint32_t config_param_1, uint32_t config_param_2, uint32_t config_param_3, int cookie, int cookie_msb, uint8_t mac_id); /** * dp_htt_stats_print_tag() - function to select the tag type and * print the corresponding tag structure * @pdev: pdev pointer * @tag_type: tag type that is to be printed * @tag_buf: pointer to the tag structure * * Return: void */ void dp_htt_stats_print_tag(struct dp_pdev *pdev, uint8_t tag_type, uint32_t *tag_buf); /** * dp_htt_stats_copy_tag() - function to select the tag type and * copy the corresponding tag structure * @pdev: DP_PDEV handle * @tag_type: tag type that is to be printed * @tag_buf: pointer to the tag structure * * Return: void */ void dp_htt_stats_copy_tag(struct dp_pdev *pdev, uint8_t tag_type, uint32_t *tag_buf); /** * dp_h2t_3tuple_config_send(): function to construct 3 tuple configuration * HTT message to pass to FW * @pdev: DP PDEV handle * @tuple_mask: tuple configuration to report 3 tuple hash value in either * toeplitz_2_or_4 or flow_id_toeplitz in MSDU START TLV. * * tuple_mask[1:0]: * 00 - Do not report 3 tuple hash value * 10 - Report 3 tuple hash value in toeplitz_2_or_4 * 01 - Report 3 tuple hash value in flow_id_toeplitz * 11 - Report 3 tuple hash value in both toeplitz_2_or_4 & flow_id_toeplitz * @mac_id: MAC ID * * Return: QDF STATUS */ QDF_STATUS dp_h2t_3tuple_config_send(struct dp_pdev *pdev, uint32_t tuple_mask, uint8_t mac_id); #ifdef IPA_OFFLOAD /** * dp_peer_update_tid_stats_from_reo() - update rx pkt and byte count from reo * @soc: soc handle * @cb_ctxt: combination of peer_id and tid * @reo_status: reo status * * Return: void */ void dp_peer_update_tid_stats_from_reo(struct dp_soc *soc, void *cb_ctxt, union hal_reo_status *reo_status); int dp_peer_get_rxtid_stats_ipa(struct dp_peer *peer, dp_rxtid_stats_cmd_cb dp_stats_cmd_cb); #ifdef IPA_OPT_WIFI_DP void dp_ipa_wdi_opt_dpath_notify_flt_rlsd(int flt0_rslt, int flt1_rslt); void dp_ipa_wdi_opt_dpath_notify_flt_add_rem_cb(int flt0_rslt, int flt1_rslt); void dp_ipa_wdi_opt_dpath_notify_flt_rsvd(bool is_success); #endif #ifdef QCA_ENHANCED_STATS_SUPPORT /** * dp_peer_aggregate_tid_stats - aggregate rx tid stats * @peer: Data Path peer * * Return: void */ void dp_peer_aggregate_tid_stats(struct dp_peer *peer); #endif #else static inline void dp_peer_aggregate_tid_stats(struct dp_peer *peer) { } #endif /** * dp_set_key_sec_type_wifi3() - set security mode of key * @soc: Datapath soc handle * @vdev_id: id of atapath vdev * @peer_mac: Datapath peer mac address * @sec_type: security type * @is_unicast: key type * */ QDF_STATUS dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, enum cdp_sec_type sec_type, bool is_unicast); /** * dp_get_pdev_for_mac_id() - Return pdev for mac_id * @soc: handle to DP soc * @mac_id: MAC id * * Return: Return pdev corresponding to MAC */ void *dp_get_pdev_for_mac_id(struct dp_soc *soc, uint32_t mac_id); QDF_STATUS dp_set_michael_key(struct cdp_soc_t *soc, uint8_t vdev_id, uint8_t *peer_mac, bool is_unicast, uint32_t *key); /** * dp_check_pdev_exists() - Validate pdev before use * @soc: dp soc handle * @data: pdev handle * * Return: 0 - success/invalid - failure */ bool dp_check_pdev_exists(struct dp_soc *soc, struct dp_pdev *data); /** * dp_update_delay_stats() - Update delay statistics in structure * and fill min, max and avg 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 is in ms or us * * Return: none */ 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); /** * dp_print_ring_stats(): Print tail and head pointer * @pdev: DP_PDEV handle * * Return: void */ void dp_print_ring_stats(struct dp_pdev *pdev); /** * dp_print_ring_stat_from_hal(): Print tail and head pointer through hal * @soc: soc handle * @srng: srng handle * @ring_type: ring type * * Return: void */ void dp_print_ring_stat_from_hal(struct dp_soc *soc, struct dp_srng *srng, enum hal_ring_type ring_type); /** * dp_print_pdev_cfg_params() - Print the pdev cfg parameters * @pdev: DP pdev handle * * Return: void */ void dp_print_pdev_cfg_params(struct dp_pdev *pdev); /** * dp_print_soc_cfg_params()- Dump soc wlan config parameters * @soc: Soc handle * * Return: void */ void dp_print_soc_cfg_params(struct dp_soc *soc); /** * dp_srng_get_str_from_hal_ring_type() - Return string name for a ring * @ring_type: Ring * * Return: char const pointer */ const char *dp_srng_get_str_from_hal_ring_type(enum hal_ring_type ring_type); /** * dp_txrx_path_stats() - Function to display dump stats * @soc: soc handle * * Return: none */ void dp_txrx_path_stats(struct dp_soc *soc); /** * dp_print_per_ring_stats(): Packet count per ring * @soc: soc handle * * Return: None */ void dp_print_per_ring_stats(struct dp_soc *soc); /** * dp_aggregate_pdev_stats(): Consolidate stats at PDEV level * @pdev: DP PDEV handle * * Return: void */ void dp_aggregate_pdev_stats(struct dp_pdev *pdev); /** * dp_print_rx_rates(): Print Rx rate stats * @vdev: DP_VDEV handle * * Return:void */ void dp_print_rx_rates(struct dp_vdev *vdev); /** * dp_print_tx_rates(): Print tx rates * @vdev: DP_VDEV handle * * Return:void */ void dp_print_tx_rates(struct dp_vdev *vdev); /** * dp_print_peer_stats():print peer stats * @peer: DP_PEER handle * @peer_stats: buffer holding peer stats * * return void */ void dp_print_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats); /** * dp_print_pdev_tx_stats(): Print Pdev level TX stats * @pdev: DP_PDEV Handle * * Return:void */ void dp_print_pdev_tx_stats(struct dp_pdev *pdev); #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MCAST_MLO) /** * dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats * @vdev: DP_VDEV Handle * * Return:void */ void dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev); #else /** * dp_print_vdev_mlo_mcast_tx_stats(): Print vdev level mlo mcast tx stats * @vdev: DP_VDEV Handle * * Return:void */ static inline void dp_print_vdev_mlo_mcast_tx_stats(struct dp_vdev *vdev) { } #endif /** * dp_print_pdev_rx_stats(): Print Pdev level RX stats * @pdev: DP_PDEV Handle * * Return: void */ void dp_print_pdev_rx_stats(struct dp_pdev *pdev); /** * dp_print_soc_tx_stats(): Print SOC level stats * @soc: DP_SOC Handle * * Return: void */ void dp_print_soc_tx_stats(struct dp_soc *soc); #ifdef QCA_SUPPORT_DP_GLOBAL_CTX /** * dp_print_global_desc_count(): Print global desc in use * * Return: void */ void dp_print_global_desc_count(void); #else /** * dp_print_global_desc_count(): Print global desc in use * * Return: void */ static inline void dp_print_global_desc_count(void) { } #endif /** * dp_print_soc_interrupt_stats() - Print interrupt stats for the soc * @soc: dp_soc handle * * Return: None */ void dp_print_soc_interrupt_stats(struct dp_soc *soc); /** * dp_print_tx_ppeds_stats() - Print Tx in use stats for the soc in DS * @soc: dp_soc handle * * Return: None */ void dp_print_tx_ppeds_stats(struct dp_soc *soc); /* REO destination ring's watermark mask */ #define DP_SRNG_WM_MASK_REO_DST BIT(REO_DST) /* TX completion ring's watermark mask */ #define DP_SRNG_WM_MASK_TX_COMP BIT(WBM2SW_RELEASE) /* All srng's watermark mask */ #define DP_SRNG_WM_MASK_ALL 0xFFFFFFFF #ifdef WLAN_DP_SRNG_USAGE_WM_TRACKING /** * dp_dump_srng_high_wm_stats() - Print the ring usage high watermark stats * for all SRNGs * @soc: DP soc handle * @srng_mask: SRNGs mask for dumping usage watermark stats * * Return: None */ void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask); #else static inline void dp_dump_srng_high_wm_stats(struct dp_soc *soc, uint64_t srng_mask) { } #endif /** * dp_print_soc_rx_stats() - Print SOC level Rx stats * @soc: DP_SOC Handle * * Return: void */ void dp_print_soc_rx_stats(struct dp_soc *soc); /** * dp_get_mac_id_for_pdev() - Return mac corresponding to pdev for mac * * @mac_id: MAC id * @pdev_id: pdev_id corresponding to pdev, 0 for MCL * * Single pdev using both MACs will operate on both MAC rings, * which is the case for MCL. * For WIN each PDEV will operate one ring, so index is zero. * */ static inline int dp_get_mac_id_for_pdev(uint32_t mac_id, uint32_t pdev_id) { if (mac_id && pdev_id) { qdf_print("Both mac_id and pdev_id cannot be non zero"); QDF_BUG(0); return 0; } return (mac_id + pdev_id); } /** * dp_get_lmac_id_for_pdev_id() - Return lmac id corresponding to host pdev id * @soc: soc pointer * @mac_id: MAC id * @pdev_id: pdev_id corresponding to pdev, 0 for MCL * * For MCL, Single pdev using both MACs will operate on both MAC rings. * * For WIN, each PDEV will operate one ring. * */ static inline int dp_get_lmac_id_for_pdev_id (struct dp_soc *soc, uint32_t mac_id, uint32_t pdev_id) { if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { if (mac_id && pdev_id) { qdf_print("Both mac_id and pdev_id cannot be non zero"); QDF_BUG(0); return 0; } return (mac_id + pdev_id); } return soc->pdev_list[pdev_id]->lmac_id; } /** * dp_get_pdev_for_lmac_id() - Return pdev pointer corresponding to lmac id * @soc: soc pointer * @lmac_id: LMAC id * * For MCL, Single pdev exists * * For WIN, each PDEV will operate one ring. * */ static inline struct dp_pdev * dp_get_pdev_for_lmac_id(struct dp_soc *soc, uint32_t lmac_id) { uint8_t i = 0; if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) { i = wlan_cfg_get_pdev_idx(soc->wlan_cfg_ctx, lmac_id); return ((i < MAX_PDEV_CNT) ? soc->pdev_list[i] : NULL); } /* Typically for MCL as there only 1 PDEV*/ return soc->pdev_list[0]; } /** * dp_calculate_target_pdev_id_from_host_pdev_id() - Return target pdev * corresponding to host pdev id * @soc: soc pointer * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL * * Return: target pdev_id for host pdev id. For WIN, this is derived through * a two step process: * 1. Get lmac_id corresponding to host pdev_id (lmac_id can change * during mode switch) * 2. Get target pdev_id (set up during WMI ready) from lmac_id * * For MCL, return the offset-1 translated mac_id */ static inline int dp_calculate_target_pdev_id_from_host_pdev_id (struct dp_soc *soc, uint32_t mac_for_pdev) { struct dp_pdev *pdev; if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) return DP_SW2HW_MACID(mac_for_pdev); pdev = soc->pdev_list[mac_for_pdev]; /*non-MCL case, get original target_pdev mapping*/ return wlan_cfg_get_target_pdev_id(soc->wlan_cfg_ctx, pdev->lmac_id); } /** * dp_get_target_pdev_id_for_host_pdev_id() - Return target pdev corresponding * to host pdev id * @soc: soc pointer * @mac_for_pdev: pdev_id corresponding to host pdev for WIN, mac id for MCL * * Return: target pdev_id for host pdev id. * For WIN, return the value stored in pdev object. * For MCL, return the offset-1 translated mac_id. */ static inline int dp_get_target_pdev_id_for_host_pdev_id (struct dp_soc *soc, uint32_t mac_for_pdev) { struct dp_pdev *pdev; if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) return DP_SW2HW_MACID(mac_for_pdev); pdev = soc->pdev_list[mac_for_pdev]; return pdev->target_pdev_id; } /** * dp_get_host_pdev_id_for_target_pdev_id() - Return host pdev corresponding * to target pdev id * @soc: soc pointer * @pdev_id: pdev_id corresponding to target pdev * * Return: host pdev_id for target pdev id. For WIN, this is derived through * a two step process: * 1. Get lmac_id corresponding to target pdev_id * 2. Get host pdev_id (set up during WMI ready) from lmac_id * * For MCL, return the 0-offset pdev_id */ static inline int dp_get_host_pdev_id_for_target_pdev_id (struct dp_soc *soc, uint32_t pdev_id) { struct dp_pdev *pdev; int lmac_id; if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) return DP_HW2SW_MACID(pdev_id); /*non-MCL case, get original target_lmac mapping from target pdev*/ lmac_id = wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, DP_HW2SW_MACID(pdev_id)); /*Get host pdev from lmac*/ pdev = dp_get_pdev_for_lmac_id(soc, lmac_id); return pdev ? pdev->pdev_id : INVALID_PDEV_ID; } /** * dp_get_mac_id_for_mac() - Return mac corresponding WIN and MCL mac_ids * * @soc: handle to DP soc * @mac_id: MAC id * * Single pdev using both MACs will operate on both MAC rings, * which is the case for MCL. * For WIN each PDEV will operate one ring, so index is zero. * */ static inline int dp_get_mac_id_for_mac(struct dp_soc *soc, uint32_t mac_id) { /* * Single pdev using both MACs will operate on both MAC rings, * which is the case for MCL. */ if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) return mac_id; /* For WIN each PDEV will operate one ring, so index is zero. */ return 0; } /** * dp_is_subtype_data() - check if the frame subtype is data * * @frame_ctrl: Frame control field * * check the frame control field and verify if the packet * is a data packet. * * Return: true or false */ static inline bool dp_is_subtype_data(uint16_t frame_ctrl) { if (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_TYPE_MASK) == QDF_IEEE80211_FC0_TYPE_DATA) && (((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == QDF_IEEE80211_FC0_SUBTYPE_DATA) || ((qdf_cpu_to_le16(frame_ctrl) & QDF_IEEE80211_FC0_SUBTYPE_MASK) == QDF_IEEE80211_FC0_SUBTYPE_QOS))) { return true; } return false; } #ifdef WDI_EVENT_ENABLE /** * dp_h2t_cfg_stats_msg_send(): function to construct HTT message to pass to FW * @pdev: DP PDEV handle * @stats_type_upload_mask: stats type requested by user * @mac_id: Mac id number * * return: QDF STATUS */ QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, uint32_t stats_type_upload_mask, uint8_t mac_id); /** * dp_wdi_event_unsub() - WDI event unsubscribe * @soc: soc handle * @pdev_id: id of pdev * @event_cb_sub_handle: subscribed event handle * @event: Event to be unsubscribe * * Return: 0 for success. nonzero for failure. */ int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, wdi_event_subscribe *event_cb_sub_handle, uint32_t event); /** * dp_wdi_event_sub() - Subscribe WDI event * @soc: soc handle * @pdev_id: id of pdev * @event_cb_sub_handle: subscribe event handle * @event: Event to be subscribe * * Return: 0 for success. nonzero for failure. */ int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, wdi_event_subscribe *event_cb_sub_handle, uint32_t event); /** * dp_wdi_event_handler() - Event handler for WDI event * @event: wdi event number * @soc: soc handle * @data: pointer to data * @peer_id: peer id number * @status: HTT rx status * @pdev_id: id of pdev * * It will be called to register WDI event * * Return: None */ void dp_wdi_event_handler(enum WDI_EVENT event, struct dp_soc *soc, void *data, u_int16_t peer_id, int status, u_int8_t pdev_id); /** * dp_wdi_event_attach() - Attach wdi event * @txrx_pdev: DP pdev handle * * Return: 0 for success. nonzero for failure. */ int dp_wdi_event_attach(struct dp_pdev *txrx_pdev); /** * dp_wdi_event_detach() - Detach WDI event * @txrx_pdev: DP pdev handle * * Return: 0 for success. nonzero for failure. */ int dp_wdi_event_detach(struct dp_pdev *txrx_pdev); static inline void dp_hif_update_pipe_callback(struct dp_soc *dp_soc, void *cb_context, QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), uint8_t pipe_id) { struct hif_msg_callbacks hif_pipe_callbacks = { 0 }; /* TODO: Temporary change to bypass HTC connection for this new * HIF pipe, which will be used for packet log and other high- * priority HTT messages. Proper HTC connection to be added * later once required FW changes are available */ hif_pipe_callbacks.rxCompletionHandler = callback; hif_pipe_callbacks.Context = cb_context; hif_update_pipe_callback(dp_soc->hif_handle, DP_HTT_T2H_HP_PIPE, &hif_pipe_callbacks); } #else static inline int dp_wdi_event_unsub(struct cdp_soc_t *soc, uint8_t pdev_id, wdi_event_subscribe *event_cb_sub_handle, uint32_t event) { return 0; } static inline int dp_wdi_event_sub(struct cdp_soc_t *soc, uint8_t pdev_id, wdi_event_subscribe *event_cb_sub_handle, uint32_t event) { return 0; } static inline void dp_wdi_event_handler(enum WDI_EVENT event, struct dp_soc *soc, void *data, u_int16_t peer_id, int status, u_int8_t pdev_id) { } static inline int dp_wdi_event_attach(struct dp_pdev *txrx_pdev) { return 0; } static inline int dp_wdi_event_detach(struct dp_pdev *txrx_pdev) { return 0; } static inline QDF_STATUS dp_h2t_cfg_stats_msg_send(struct dp_pdev *pdev, uint32_t stats_type_upload_mask, uint8_t mac_id) { return 0; } static inline void dp_hif_update_pipe_callback(struct dp_soc *dp_soc, void *cb_context, QDF_STATUS (*callback)(void *, qdf_nbuf_t, uint8_t), uint8_t pipe_id) { } #endif #ifdef VDEV_PEER_PROTOCOL_COUNT /** * dp_vdev_peer_stats_update_protocol_cnt() - update per-peer protocol counters * @vdev: VDEV DP object * @nbuf: data packet * @txrx_peer: DP TXRX Peer object * @is_egress: whether egress or ingress * @is_rx: whether rx or tx * * This function updates the per-peer protocol counters * Return: void */ void dp_vdev_peer_stats_update_protocol_cnt(struct dp_vdev *vdev, qdf_nbuf_t nbuf, struct dp_txrx_peer *txrx_peer, bool is_egress, bool is_rx); /** * dp_peer_stats_update_protocol_cnt() - update per-peer protocol counters * @soc: SOC DP object * @vdev_id: vdev_id * @nbuf: data packet * @is_egress: whether egress or ingress * @is_rx: whether rx or tx * * This function updates the per-peer protocol counters * * Return: void */ void dp_peer_stats_update_protocol_cnt(struct cdp_soc_t *soc, int8_t vdev_id, qdf_nbuf_t nbuf, bool is_egress, bool is_rx); void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, qdf_nbuf_t nbuf); #else #define dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, txrx_peer, \ is_egress, is_rx) static inline void dp_vdev_peer_stats_update_protocol_cnt_tx(struct dp_vdev *vdev_hdl, qdf_nbuf_t nbuf) { } #endif #ifdef QCA_LL_TX_FLOW_CONTROL_V2 /** * dp_tx_dump_flow_pool_info() - dump global_pool and flow_pool info * @soc_hdl: Handle to struct cdp_soc * * Return: none */ void dp_tx_dump_flow_pool_info(struct cdp_soc_t *soc_hdl); /** * dp_tx_dump_flow_pool_info_compact() - dump flow pool info * @soc: DP soc context * * Return: none */ void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc); int dp_tx_delete_flow_pool(struct dp_soc *soc, struct dp_tx_desc_pool_s *pool, bool force); #else static inline void dp_tx_dump_flow_pool_info_compact(struct dp_soc *soc) { } #endif /* QCA_LL_TX_FLOW_CONTROL_V2 */ #ifdef QCA_OL_DP_SRNG_LOCK_LESS_ACCESS static inline int dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) { return hal_srng_access_start_unlocked(soc, hal_ring_hdl); } static inline void dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) { hal_srng_access_end_unlocked(soc, hal_ring_hdl); } #else static inline int dp_hal_srng_access_start(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) { return hal_srng_access_start(soc, hal_ring_hdl); } static inline void dp_hal_srng_access_end(hal_soc_handle_t soc, hal_ring_handle_t hal_ring_hdl) { hal_srng_access_end(soc, hal_ring_hdl); } #endif #ifdef WLAN_FEATURE_DP_EVENT_HISTORY /** * dp_srng_access_start() - Wrapper function to log access start of a hal ring * @int_ctx: pointer to DP interrupt context. This should not be NULL * @dp_soc: DP Soc handle * @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be * serviced * * Return: 0 on success; error on failure */ int dp_srng_access_start(struct dp_intr *int_ctx, struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl); /** * dp_srng_access_end() - Wrapper function to log access end of a hal ring * @int_ctx: pointer to DP interrupt context. This should not be NULL * @dp_soc: DP Soc handle * @hal_ring_hdl: opaque pointer to the HAL Rx Error Ring, which will be * serviced * * Return: void */ void dp_srng_access_end(struct dp_intr *int_ctx, struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl); #else static inline 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; return dp_hal_srng_access_start(hal_soc, hal_ring_hdl); } static inline 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; return dp_hal_srng_access_end(hal_soc, hal_ring_hdl); } #endif /* WLAN_FEATURE_DP_EVENT_HISTORY */ #ifdef QCA_CACHED_RING_DESC /** * dp_srng_dst_get_next() - Wrapper function to get next ring desc * @dp_soc: DP Soc handle * @hal_ring_hdl: opaque pointer to the HAL Destination Ring * * Return: HAL ring descriptor */ static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl) { hal_soc_handle_t hal_soc = dp_soc->hal_soc; return hal_srng_dst_get_next_cached(hal_soc, hal_ring_hdl); } /** * dp_srng_dst_inv_cached_descs() - Wrapper function to invalidate cached * descriptors * @dp_soc: DP Soc handle * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring * @num_entries: Entry count * * Return: HAL ring descriptor */ static inline void *dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { hal_soc_handle_t hal_soc = dp_soc->hal_soc; return hal_srng_dst_inv_cached_descs(hal_soc, hal_ring_hdl, num_entries); } #else static inline void *dp_srng_dst_get_next(struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl) { hal_soc_handle_t hal_soc = dp_soc->hal_soc; return hal_srng_dst_get_next(hal_soc, hal_ring_hdl); } static inline void *dp_srng_dst_inv_cached_descs(struct dp_soc *dp_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { return NULL; } #endif /* QCA_CACHED_RING_DESC */ #if defined(QCA_CACHED_RING_DESC) && \ (defined(QCA_DP_RX_HW_SW_NBUF_DESC_PREFETCH) || \ defined(QCA_DP_TX_HW_SW_NBUF_DESC_PREFETCH)) /** * dp_srng_dst_prefetch() - Wrapper function to prefetch descs from dest ring * @hal_soc: HAL SOC handle * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring * @num_entries: Entry count * * Return: None */ static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { return hal_srng_dst_prefetch(hal_soc, hal_ring_hdl, num_entries); } /** * dp_srng_dst_prefetch_32_byte_desc() - Wrapper function to prefetch * 32 byte descriptor starting at * 64 byte offset * @hal_soc: HAL SOC handle * @hal_ring_hdl: opaque pointer to the HAL Rx Destination ring * @num_entries: Entry count * * Return: None */ static inline void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { return hal_srng_dst_prefetch_32_byte_desc(hal_soc, hal_ring_hdl, num_entries); } #else static inline void *dp_srng_dst_prefetch(hal_soc_handle_t hal_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { return NULL; } static inline void *dp_srng_dst_prefetch_32_byte_desc(hal_soc_handle_t hal_soc, hal_ring_handle_t hal_ring_hdl, uint32_t num_entries) { return NULL; } #endif #ifdef QCA_ENH_V3_STATS_SUPPORT /** * dp_pdev_print_delay_stats(): Print pdev level delay stats * @pdev: DP_PDEV handle * * Return:void */ void dp_pdev_print_delay_stats(struct dp_pdev *pdev); /** * dp_pdev_print_tid_stats(): Print pdev level tid stats * @pdev: DP_PDEV handle * * Return:void */ void dp_pdev_print_tid_stats(struct dp_pdev *pdev); /** * dp_pdev_print_rx_error_stats(): Print pdev level rx error stats * @pdev: DP_PDEV handle * * Return:void */ void dp_pdev_print_rx_error_stats(struct dp_pdev *pdev); #endif /* QCA_ENH_V3_STATS_SUPPORT */ /** * dp_pdev_get_tid_stats(): Get accumulated pdev level tid_stats * @soc_hdl: soc handle * @pdev_id: id of dp_pdev handle * @tid_stats: Pointer for cdp_tid_stats_intf * * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_INVAL */ QDF_STATUS dp_pdev_get_tid_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_tid_stats_intf *tid_stats); /** * dp_soc_set_txrx_ring_map() * @soc: DP handler for soc * * Return: Void */ void dp_soc_set_txrx_ring_map(struct dp_soc *soc); /** * dp_vdev_to_cdp_vdev() - typecast dp vdev to cdp vdev * @vdev: DP vdev handle * * Return: struct cdp_vdev pointer */ static inline struct cdp_vdev *dp_vdev_to_cdp_vdev(struct dp_vdev *vdev) { return (struct cdp_vdev *)vdev; } /** * dp_pdev_to_cdp_pdev() - typecast dp pdev to cdp pdev * @pdev: DP pdev handle * * Return: struct cdp_pdev pointer */ static inline struct cdp_pdev *dp_pdev_to_cdp_pdev(struct dp_pdev *pdev) { return (struct cdp_pdev *)pdev; } /** * dp_soc_to_cdp_soc() - typecast dp psoc to cdp psoc * @psoc: DP psoc handle * * Return: struct cdp_soc pointer */ static inline struct cdp_soc *dp_soc_to_cdp_soc(struct dp_soc *psoc) { return (struct cdp_soc *)psoc; } /** * dp_soc_to_cdp_soc_t() - typecast dp psoc to ol txrx soc handle * @psoc: DP psoc handle * * Return: struct cdp_soc_t pointer */ static inline struct cdp_soc_t *dp_soc_to_cdp_soc_t(struct dp_soc *psoc) { return (struct cdp_soc_t *)psoc; } #if defined(WLAN_SUPPORT_RX_FLOW_TAG) /** * dp_rx_flow_get_fse_stats() - Retrieve a flow's statistics * @pdev: pdev handle * @rx_flow_info: flow information in the Rx FST * @stats: stats to update * * Return: Success when flow statistcs is updated, error on failure */ QDF_STATUS dp_rx_flow_get_fse_stats(struct dp_pdev *pdev, struct cdp_rx_flow_info *rx_flow_info, struct cdp_flow_stats *stats); /** * dp_rx_flow_delete_entry() - Delete a flow entry from flow search table * @pdev: pdev handle * @rx_flow_info: DP flow parameters * * Return: Success when flow is deleted, error on failure */ QDF_STATUS dp_rx_flow_delete_entry(struct dp_pdev *pdev, struct cdp_rx_flow_info *rx_flow_info); /** * dp_rx_flow_add_entry() - Add a flow entry to flow search table * @pdev: DP pdev instance * @rx_flow_info: DP flow parameters * * Return: Success when flow is added, no-memory or already exists on error */ QDF_STATUS dp_rx_flow_add_entry(struct dp_pdev *pdev, struct cdp_rx_flow_info *rx_flow_info); /** * dp_rx_fst_attach() - Initialize Rx FST and setup necessary parameters * @soc: SoC handle * @pdev: Pdev handle * * Return: Handle to flow search table entry */ QDF_STATUS dp_rx_fst_attach(struct dp_soc *soc, struct dp_pdev *pdev); /** * dp_rx_fst_detach() - De-initialize Rx FST * @soc: SoC handle * @pdev: Pdev handle * * Return: None */ void dp_rx_fst_detach(struct dp_soc *soc, struct dp_pdev *pdev); /** * dp_mon_rx_update_rx_flow_tag_stats() - Update a mon flow's statistics * @pdev: pdev handle * @flow_id: flow index (truncated hash) in the Rx FST * * Return: Success when flow statistcs is updated, error on failure */ QDF_STATUS dp_mon_rx_update_rx_flow_tag_stats(struct dp_pdev *pdev, uint32_t flow_id); #endif #ifdef WLAN_SUPPORT_RX_FLOW_TAG /** * dp_rx_flow_send_fst_fw_setup() - Program FST parameters in FW/HW post-attach * @soc: SoC handle * @pdev: Pdev handle * * Return: Success when fst parameters are programmed in FW, error otherwise */ QDF_STATUS dp_rx_flow_send_fst_fw_setup(struct dp_soc *soc, struct dp_pdev *pdev); #endif /** * dp_rx_fst_attach_wrapper() - wrapper API for dp_rx_fst_attach * @soc: SoC handle * @pdev: Pdev handle * * Return: Handle to flow search table entry */ extern QDF_STATUS dp_rx_fst_attach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev); /** * dp_rx_fst_detach_wrapper() - wrapper API for dp_rx_fst_detach * @soc: SoC handle * @pdev: Pdev handle * * Return: None */ extern void dp_rx_fst_detach_wrapper(struct dp_soc *soc, struct dp_pdev *pdev); /** * dp_vdev_get_ref() - API to take a reference for VDEV object * * @soc : core DP soc context * @vdev : DP vdev * @mod_id : module id * * Return: QDF_STATUS_SUCCESS if reference held successfully * else QDF_STATUS_E_INVAL */ static inline QDF_STATUS dp_vdev_get_ref(struct dp_soc *soc, struct dp_vdev *vdev, enum dp_mod_id mod_id) { if (!qdf_atomic_inc_not_zero(&vdev->ref_cnt)) return QDF_STATUS_E_INVAL; qdf_atomic_inc(&vdev->mod_refs[mod_id]); return QDF_STATUS_SUCCESS; } /** * dp_vdev_get_ref_by_id() - Returns vdev object given the vdev id * @soc: core DP soc context * @vdev_id: vdev id from vdev object can be retrieved * @mod_id: module id which is requesting the reference * * Return: struct dp_vdev*: Pointer to DP vdev object */ static inline struct dp_vdev * dp_vdev_get_ref_by_id(struct dp_soc *soc, uint8_t vdev_id, enum dp_mod_id mod_id) { struct dp_vdev *vdev = NULL; if (qdf_unlikely(vdev_id >= MAX_VDEV_CNT)) return NULL; qdf_spin_lock_bh(&soc->vdev_map_lock); vdev = soc->vdev_id_map[vdev_id]; if (!vdev || dp_vdev_get_ref(soc, vdev, mod_id) != QDF_STATUS_SUCCESS) { qdf_spin_unlock_bh(&soc->vdev_map_lock); return NULL; } qdf_spin_unlock_bh(&soc->vdev_map_lock); return vdev; } /** * dp_get_pdev_from_soc_pdev_id_wifi3() - Returns pdev object given the pdev id * @soc: core DP soc context * @pdev_id: pdev id from pdev object can be retrieved * * Return: struct dp_pdev*: Pointer to DP pdev object */ static inline struct dp_pdev * dp_get_pdev_from_soc_pdev_id_wifi3(struct dp_soc *soc, uint8_t pdev_id) { if (qdf_unlikely(pdev_id >= MAX_PDEV_CNT)) return NULL; return soc->pdev_list[pdev_id]; } /** * dp_get_peer_mac_list(): function to get peer mac list of vdev * @soc: Datapath soc handle * @vdev_id: vdev id * @newmac: Table of the clients mac * @mac_cnt: No. of MACs required * @limit: Limit the number of clients * * Return: no of clients */ 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); /** * dp_update_num_mac_rings_for_dbs() - Update No of MAC rings based on * DBS check * @soc: DP SoC context * @max_mac_rings: Pointer to variable for No of MAC rings * * Return: None */ void dp_update_num_mac_rings_for_dbs(struct dp_soc *soc, int *max_mac_rings); #if defined(WLAN_SUPPORT_RX_FISA) /** * dp_rx_fst_update_cmem_params() - Update CMEM FST params * @soc: DP SoC context * @num_entries: Number of flow search entries * @cmem_ba_lo: CMEM base address low * @cmem_ba_hi: CMEM base address high * * Return: None */ void dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, uint32_t cmem_ba_lo, uint32_t cmem_ba_hi); /** * dp_fisa_config() - FISA config handler * @cdp_soc: CDP SoC handle * @pdev_id: PDEV ID * @config_id: FISA config ID * @cfg: FISA config msg data */ QDF_STATUS dp_fisa_config(ol_txrx_soc_handle cdp_soc, uint8_t pdev_id, enum cdp_fisa_config_id config_id, union cdp_fisa_config *cfg); #else static inline void dp_rx_fst_update_cmem_params(struct dp_soc *soc, uint16_t num_entries, uint32_t cmem_ba_lo, uint32_t cmem_ba_hi) { } #endif /* WLAN_SUPPORT_RX_FISA */ #ifdef MAX_ALLOC_PAGE_SIZE /** * dp_set_max_page_size() - Set the max page size for hw link desc. * @pages: link desc page handle * @max_alloc_size: max_alloc_size * * For MCL the page size is set to OS defined value and for WIN * the page size is set to the max_alloc_size cfg ini * param. * This is to ensure that WIN gets contiguous memory allocations * as per requirement. * * Return: None */ static inline void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, uint32_t max_alloc_size) { pages->page_size = qdf_page_size; } #else static inline void dp_set_max_page_size(struct qdf_mem_multi_page_t *pages, uint32_t max_alloc_size) { pages->page_size = max_alloc_size; } #endif /* MAX_ALLOC_PAGE_SIZE */ /** * dp_get_next_index() - get the next entry to record an entry * in the history. * @curr_idx: Current index where the last entry is written. * @max_entries: Max number of entries in the history * * This function assumes that the max number os entries is a power of 2. * * Return: The index where the next entry is to be written. */ static inline uint32_t dp_get_next_index(qdf_atomic_t *curr_idx, uint32_t max_entries) { uint32_t idx = qdf_atomic_inc_return(curr_idx); return idx & (max_entries - 1); } /** * dp_history_get_next_index() - get the next entry to record an entry * in the history. * @curr_idx: Current index where the last entry is written. * @max_entries: Max number of entries in the history * * This function assumes that the max number os entries is a power of 2. * * Return: The index where the next entry is to be written. */ static inline uint32_t dp_history_get_next_index(qdf_atomic_t *curr_idx, uint32_t max_entries) { return dp_get_next_index(curr_idx, max_entries); } /** * dp_rx_skip_tlvs() - Skip TLVs len + L3 padding, save in nbuf->cb * @soc: Datapath soc handle * @nbuf: nbuf cb to be updated * @l3_padding: L3 padding * * Return: None */ void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding); #ifndef FEATURE_WDS static inline void dp_hmwds_ast_add_notify(struct dp_peer *peer, uint8_t *mac_addr, enum cdp_txrx_ast_entry_type type, QDF_STATUS err, bool is_peer_map) { } #endif #ifdef HTT_STATS_DEBUGFS_SUPPORT /** * dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize * debugfs for HTT stats * @pdev: dp pdev handle * * Return: QDF_STATUS */ QDF_STATUS dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev); /** * dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for * HTT stats * @pdev: dp pdev handle * * Return: none */ void dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev); #else /** * dp_pdev_htt_stats_dbgfs_init() - Function to allocate memory and initialize * debugfs for HTT stats * @pdev: dp pdev handle * * Return: QDF_STATUS */ static inline QDF_STATUS dp_pdev_htt_stats_dbgfs_init(struct dp_pdev *pdev) { return QDF_STATUS_SUCCESS; } /** * dp_pdev_htt_stats_dbgfs_deinit() - Function to remove debugfs entry for * HTT stats * @pdev: dp pdev handle * * Return: none */ static inline void dp_pdev_htt_stats_dbgfs_deinit(struct dp_pdev *pdev) { } #endif /* HTT_STATS_DEBUGFS_SUPPORT */ #ifndef WLAN_DP_FEATURE_SW_LATENCY_MGR /** * dp_soc_swlm_attach() - attach the software latency manager resources * @soc: Datapath global soc handle * * Return: QDF_STATUS */ static inline QDF_STATUS dp_soc_swlm_attach(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } /** * dp_soc_swlm_detach() - detach the software latency manager resources * @soc: Datapath global soc handle * * Return: QDF_STATUS */ static inline QDF_STATUS dp_soc_swlm_detach(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } #endif /* !WLAN_DP_FEATURE_SW_LATENCY_MGR */ #ifndef WLAN_DP_PROFILE_SUPPORT static inline void wlan_dp_soc_cfg_sync_profile(struct cdp_soc_t *cdp_soc) {} static inline void wlan_dp_pdev_cfg_sync_profile(struct cdp_soc_t *cdp_soc, uint8_t pdev_id) {} #endif /** * dp_get_peer_id(): function to get peer id by mac * @soc: Datapath soc handle * @vdev_id: vdev id * @mac: Peer mac address * * Return: valid peer id on success * HTT_INVALID_PEER on failure */ uint16_t dp_get_peer_id(ol_txrx_soc_handle soc, uint8_t vdev_id, uint8_t *mac); #ifdef QCA_SUPPORT_WDS_EXTENDED /** * dp_wds_ext_set_peer_rx(): function to set peer rx handler * @soc: Datapath soc handle * @vdev_id: vdev id * @mac: Peer mac address * @rx: rx function pointer * @osif_peer: OSIF peer handle * * Return: QDF_STATUS_SUCCESS on success * QDF_STATUS_E_INVAL if peer is not found * QDF_STATUS_E_ALREADY if rx is already set/unset */ 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); /** * dp_wds_ext_get_peer_osif_handle(): function to get peer osif handle * @soc: Datapath soc handle * @vdev_id: vdev id * @mac: Peer mac address * @osif_peer: OSIF peer handle * * Return: QDF_STATUS_SUCCESS on success * QDF_STATUS_E_INVAL if peer is not found */ 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); /** * dp_wds_ext_set_peer_bit(): function to set wds-ext peer bit * @soc: Datapath soc handle * @mac: Peer mac address * * Return: QDF_STATUS_SUCCESS on success * QDF_STATUS_E_INVAL if peer is not found */ QDF_STATUS dp_wds_ext_set_peer_bit(ol_txrx_soc_handle soc, uint8_t *mac); #endif /* QCA_SUPPORT_WDS_EXTENDED */ #ifdef DP_MEM_PRE_ALLOC /** * dp_context_alloc_mem() - allocate memory for DP context * @soc: datapath soc handle * @ctxt_type: DP context type * @ctxt_size: DP context size * * Return: DP context address */ void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, size_t ctxt_size); /** * dp_context_free_mem() - Free memory of DP context * @soc: datapath soc handle * @ctxt_type: DP context type * @vaddr: Address of context memory * * Return: None */ void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, void *vaddr); /** * dp_desc_multi_pages_mem_alloc() - alloc memory over multiple pages * @soc: datapath soc handle * @desc_type: memory request source type * @pages: multi page information storage * @element_size: each element size * @element_num: total number of elements should be allocated * @memctxt: memory context * @cacheable: coherent memory or cacheable memory * * This function is a wrapper for memory allocation over multiple * pages, if dp prealloc method is registered, then will try prealloc * firstly. if prealloc failed, fall back to regular way over * qdf_mem_multi_pages_alloc(). * * Return: None */ 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); /** * dp_desc_multi_pages_mem_free() - free multiple pages memory * @soc: datapath soc handle * @desc_type: memory request source type * @pages: multi page information storage * @memctxt: memory context * @cacheable: coherent memory or cacheable memory * * This function is a wrapper for multiple pages memory free, * if memory is got from prealloc pool, put it back to pool. * otherwise free by qdf_mem_multi_pages_free(). * * Return: None */ 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); #else static inline void *dp_context_alloc_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, size_t ctxt_size) { return qdf_mem_malloc(ctxt_size); } static inline void dp_context_free_mem(struct dp_soc *soc, enum dp_ctxt_type ctxt_type, void *vaddr) { qdf_mem_free(vaddr); } static inline 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) { qdf_mem_multi_pages_alloc(soc->osdev, pages, element_size, element_num, memctxt, cacheable); } static inline 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) { qdf_mem_multi_pages_free(soc->osdev, pages, memctxt, cacheable); } #endif /** * struct dp_frag_history_opaque_atomic - Opaque struct for adding a fragmented * history. * @index: atomic index * @num_entries_per_slot: Number of entries per slot * @allocated: is allocated or not * @entry: pointers to array of records */ struct dp_frag_history_opaque_atomic { qdf_atomic_t index; uint16_t num_entries_per_slot; uint16_t allocated; void *entry[]; }; static inline QDF_STATUS dp_soc_frag_history_attach(struct dp_soc *soc, void *history_hdl, uint32_t max_slots, uint32_t max_entries_per_slot, uint32_t entry_size, bool attempt_prealloc, enum dp_ctxt_type ctxt_type) { struct dp_frag_history_opaque_atomic *history = (struct dp_frag_history_opaque_atomic *)history_hdl; size_t alloc_size = max_entries_per_slot * entry_size; int i; for (i = 0; i < max_slots; i++) { if (attempt_prealloc) history->entry[i] = dp_context_alloc_mem(soc, ctxt_type, alloc_size); else history->entry[i] = qdf_mem_malloc(alloc_size); if (!history->entry[i]) goto exit; } qdf_atomic_init(&history->index); history->allocated = 1; history->num_entries_per_slot = max_entries_per_slot; return QDF_STATUS_SUCCESS; exit: for (i = i - 1; i >= 0; i--) { if (attempt_prealloc) dp_context_free_mem(soc, ctxt_type, history->entry[i]); else qdf_mem_free(history->entry[i]); } return QDF_STATUS_E_NOMEM; } static inline void dp_soc_frag_history_detach(struct dp_soc *soc, void *history_hdl, uint32_t max_slots, bool attempt_prealloc, enum dp_ctxt_type ctxt_type) { struct dp_frag_history_opaque_atomic *history = (struct dp_frag_history_opaque_atomic *)history_hdl; int i; for (i = 0; i < max_slots; i++) { if (attempt_prealloc) dp_context_free_mem(soc, ctxt_type, history->entry[i]); else qdf_mem_free(history->entry[i]); } history->allocated = 0; } /** * dp_get_frag_hist_next_atomic_idx() - get the next entry index to record an * entry in a fragmented history with * index being atomic. * @curr_idx: address of the current index where the last entry was written * @next_idx: pointer to update the next index * @slot: pointer to update the history slot to be selected * @slot_shift: BITwise shift mask for slot (in index) * @max_entries_per_slot: Max number of entries in a slot of history * @max_entries: Total number of entries in the history (sum of all slots) * * This function assumes that the "max_entries_per_slot" and "max_entries" * are a power-of-2. * * Return: None */ static inline void dp_get_frag_hist_next_atomic_idx(qdf_atomic_t *curr_idx, uint32_t *next_idx, uint16_t *slot, uint32_t slot_shift, uint32_t max_entries_per_slot, uint32_t max_entries) { uint32_t idx; idx = qdf_do_div_rem(qdf_atomic_inc_return(curr_idx), max_entries); *slot = idx >> slot_shift; *next_idx = idx & (max_entries_per_slot - 1); } #ifdef FEATURE_RUNTIME_PM /** * dp_runtime_get() - Get dp runtime refcount * @soc: Datapath soc handle * * Get dp runtime refcount by increment of an atomic variable, which can block * dp runtime resume to wait to flush pending tx by runtime suspend. * * Return: Current refcount */ static inline int32_t dp_runtime_get(struct dp_soc *soc) { return qdf_atomic_inc_return(&soc->dp_runtime_refcount); } /** * dp_runtime_put() - Return dp runtime refcount * @soc: Datapath soc handle * * Return dp runtime refcount by decrement of an atomic variable, allow dp * runtime resume finish. * * Return: Current refcount */ static inline int32_t dp_runtime_put(struct dp_soc *soc) { return qdf_atomic_dec_return(&soc->dp_runtime_refcount); } /** * dp_runtime_get_refcount() - Get dp runtime refcount * @soc: Datapath soc handle * * Get dp runtime refcount by returning an atomic variable * * Return: Current refcount */ static inline int32_t dp_runtime_get_refcount(struct dp_soc *soc) { return qdf_atomic_read(&soc->dp_runtime_refcount); } /** * dp_runtime_init() - Init DP related runtime PM clients and runtime refcount * @soc: Datapath soc handle * * Return: QDF_STATUS */ static inline void dp_runtime_init(struct dp_soc *soc) { hif_rtpm_register(HIF_RTPM_ID_DP, NULL); hif_rtpm_register(HIF_RTPM_ID_DP_RING_STATS, NULL); qdf_atomic_init(&soc->dp_runtime_refcount); } /** * dp_runtime_deinit() - Deinit DP related runtime PM clients * * Return: None */ static inline void dp_runtime_deinit(void) { hif_rtpm_deregister(HIF_RTPM_ID_DP); hif_rtpm_deregister(HIF_RTPM_ID_DP_RING_STATS); } /** * dp_runtime_pm_mark_last_busy() - Mark last busy when rx path in use * @soc: Datapath soc handle * * Return: None */ static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) { soc->rx_last_busy = qdf_get_log_timestamp_usecs(); hif_rtpm_mark_last_busy(HIF_RTPM_ID_DP); } #else static inline int32_t dp_runtime_get(struct dp_soc *soc) { return 0; } static inline int32_t dp_runtime_put(struct dp_soc *soc) { return 0; } static inline QDF_STATUS dp_runtime_init(struct dp_soc *soc) { return QDF_STATUS_SUCCESS; } static inline void dp_runtime_deinit(void) { } static inline void dp_runtime_pm_mark_last_busy(struct dp_soc *soc) { } #endif static inline enum QDF_GLOBAL_MODE dp_soc_get_con_mode(struct dp_soc *soc) { if (soc->cdp_soc.ol_ops->get_con_mode) return soc->cdp_soc.ol_ops->get_con_mode(); return QDF_GLOBAL_MAX_MODE; } /** * dp_pdev_bkp_stats_detach() - detach resources for back pressure stats * processing * @pdev: Datapath PDEV handle * */ void dp_pdev_bkp_stats_detach(struct dp_pdev *pdev); /** * dp_pdev_bkp_stats_attach() - attach resources for back pressure stats * processing * @pdev: Datapath PDEV handle * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_NOMEM: Error */ QDF_STATUS dp_pdev_bkp_stats_attach(struct dp_pdev *pdev); /** * dp_peer_flush_frags() - Flush all fragments for a particular * peer * @soc_hdl: data path soc handle * @vdev_id: vdev id * @peer_mac: peer mac address * * Return: None */ void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac); /** * dp_soc_reset_mon_intr_mask() - reset mon intr mask * @soc: pointer to dp_soc handle * * Return: */ void dp_soc_reset_mon_intr_mask(struct dp_soc *soc); /** * dp_txrx_get_soc_stats() - will return cdp_soc_stats * @soc_hdl: soc handle * @soc_stats: buffer to hold the values * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_txrx_get_soc_stats(struct cdp_soc_t *soc_hdl, struct cdp_soc_stats *soc_stats); /** * dp_txrx_get_peer_delay_stats() - to get peer delay stats per TIDs * @soc_hdl: soc handle * @vdev_id: id of vdev handle * @peer_mac: mac of DP_PEER handle * @delay_stats: pointer to delay stats array * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_txrx_get_peer_delay_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_delay_tid_stats *delay_stats); /** * dp_txrx_get_peer_jitter_stats() - to get peer jitter stats per TIDs * @soc_hdl: soc handle * @pdev_id: id of pdev handle * @vdev_id: id of vdev handle * @peer_mac: mac of DP_PEER handle * @tid_stats: pointer to jitter stats array * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_txrx_get_peer_jitter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_tid_stats *tid_stats); /** * dp_peer_get_tx_capture_stats() - to get peer Tx Capture stats * @soc_hdl: soc handle * @vdev_id: id of vdev handle * @peer_mac: mac of DP_PEER handle * @stats: pointer to peer tx capture stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_peer_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *peer_mac, struct cdp_peer_tx_capture_stats *stats); /** * dp_pdev_get_tx_capture_stats() - to get pdev Tx Capture stats * @soc_hdl: soc handle * @pdev_id: id of pdev handle * @stats: pointer to pdev tx capture stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_pdev_get_tx_capture_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_pdev_tx_capture_stats *stats); #ifdef HW_TX_DELAY_STATS_ENABLE /** * dp_is_vdev_tx_delay_stats_enabled(): Check if tx delay stats * is enabled for vdev * @vdev: dp vdev * * Return: true if tx delay stats is enabled for vdev else false */ static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) { return vdev->hw_tx_delay_stats_enabled; } /** * dp_pdev_print_tx_delay_stats(): Print vdev tx delay stats * for pdev * @soc: dp soc * * Return: None */ void dp_pdev_print_tx_delay_stats(struct dp_soc *soc); /** * dp_pdev_clear_tx_delay_stats() - clear tx delay stats * @soc: soc handle * * Return: None */ void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc); #else static inline uint8_t dp_is_vdev_tx_delay_stats_enabled(struct dp_vdev *vdev) { return 0; } static inline void dp_pdev_print_tx_delay_stats(struct dp_soc *soc) { } static inline void dp_pdev_clear_tx_delay_stats(struct dp_soc *soc) { } #endif static inline void dp_get_rx_hash_key_bytes(struct cdp_lro_hash_config *lro_hash) { qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv4, (sizeof(lro_hash->toeplitz_hash_ipv4[0]) * LRO_IPV4_SEED_ARR_SZ)); qdf_get_random_bytes(lro_hash->toeplitz_hash_ipv6, (sizeof(lro_hash->toeplitz_hash_ipv6[0]) * LRO_IPV6_SEED_ARR_SZ)); } #ifdef WLAN_CONFIG_TELEMETRY_AGENT /** * dp_get_pdev_telemetry_stats- API to get pdev telemetry stats * @soc_hdl: soc handle * @pdev_id: id of pdev handle * @stats: pointer to pdev telemetry stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_get_pdev_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_pdev_telemetry_stats *stats); /** * dp_get_peer_telemetry_stats() - API to get peer telemetry stats * @soc_hdl: soc handle * @addr: peer mac * @stats: pointer to peer telemetry stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_get_peer_telemetry_stats(struct cdp_soc_t *soc_hdl, uint8_t *addr, struct cdp_peer_telemetry_stats *stats); /** * dp_get_peer_deter_stats() - API to get peer deterministic stats * @soc_hdl: soc handle * @vdev_id: id of vdev handle * @addr: peer mac * @stats: pointer to peer deterministic stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_get_peer_deter_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, uint8_t *addr, struct cdp_peer_deter_stats *stats); /** * dp_get_pdev_deter_stats() - API to get pdev deterministic stats * @soc_hdl: soc handle * @pdev_id: id of pdev handle * @stats: pointer to pdev deterministic stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_get_pdev_deter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_pdev_deter_stats *stats); /** * dp_update_pdev_chan_util_stats() - API to update channel utilization stats * @soc_hdl: soc handle * @pdev_id: id of pdev handle * @ch_util: Pointer to channel util stats * * Return: QDF_STATUS_SUCCESS: Success * QDF_STATUS_E_FAILURE: Error */ QDF_STATUS dp_update_pdev_chan_util_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, struct cdp_pdev_chan_util_stats *ch_util); #endif /* WLAN_CONFIG_TELEMETRY_AGENT */ #ifdef CONNECTIVITY_PKTLOG /** * dp_tx_send_pktlog() - send tx packet log * @soc: soc handle * @pdev: pdev handle * @tx_desc: TX software descriptor * @nbuf: nbuf * @status: status of tx packet * * This function is used to send tx packet for logging * * Return: None * */ static inline void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, struct dp_tx_desc_s *tx_desc, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) { ol_txrx_pktdump_cb packetdump_cb = pdev->dp_tx_packetdump_cb; if (qdf_unlikely(packetdump_cb) && dp_tx_frm_std == tx_desc->frm_type) { packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, tx_desc->vdev_id, nbuf, status, QDF_TX_DATA_PKT); } } /** * dp_rx_send_pktlog() - send rx packet log * @soc: soc handle * @pdev: pdev handle * @nbuf: nbuf * @status: status of rx packet * * This function is used to send rx packet for logging * * Return: None * */ static inline void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) { ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; if (qdf_unlikely(packetdump_cb)) { packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, QDF_NBUF_CB_RX_VDEV_ID(nbuf), nbuf, status, QDF_RX_DATA_PKT); } } /** * dp_rx_err_send_pktlog() - send rx error packet log * @soc: soc handle * @pdev: pdev handle * @mpdu_desc_info: MPDU descriptor info * @nbuf: nbuf * @status: status of rx packet * @set_pktlen: weither to set packet length * * This API should only be called when we have not removed * Rx TLV from head, and head is pointing to rx_tlv * * This function is used to send rx packet from error path * for logging for which rx packet tlv is not removed. * * Return: None * */ static inline void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, struct hal_rx_mpdu_desc_info *mpdu_desc_info, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, bool set_pktlen) { ol_txrx_pktdump_cb packetdump_cb = pdev->dp_rx_packetdump_cb; qdf_size_t skip_size; uint16_t msdu_len, nbuf_len; uint8_t *rx_tlv_hdr; struct hal_rx_msdu_metadata msdu_metadata; uint16_t buf_size; buf_size = wlan_cfg_rx_buffer_size(soc->wlan_cfg_ctx); if (qdf_unlikely(packetdump_cb)) { rx_tlv_hdr = qdf_nbuf_data(nbuf); nbuf_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc, rx_tlv_hdr); hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, &msdu_metadata); if (mpdu_desc_info->bar_frame || (mpdu_desc_info->mpdu_flags & HAL_MPDU_F_FRAGMENT)) skip_size = soc->rx_pkt_tlv_size; else skip_size = soc->rx_pkt_tlv_size + msdu_metadata.l3_hdr_pad; if (set_pktlen) { msdu_len = nbuf_len + skip_size; qdf_nbuf_set_pktlen(nbuf, qdf_min(msdu_len, buf_size)); } qdf_nbuf_pull_head(nbuf, skip_size); packetdump_cb((ol_txrx_soc_handle)soc, pdev->pdev_id, QDF_NBUF_CB_RX_VDEV_ID(nbuf), nbuf, status, QDF_RX_DATA_PKT); qdf_nbuf_push_head(nbuf, skip_size); } } #else static inline void dp_tx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, struct dp_tx_desc_s *tx_desc, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) { } static inline void dp_rx_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status) { } static inline void dp_rx_err_send_pktlog(struct dp_soc *soc, struct dp_pdev *pdev, struct hal_rx_mpdu_desc_info *mpdu_desc_info, qdf_nbuf_t nbuf, enum qdf_dp_tx_rx_status status, bool set_pktlen) { } #endif /** * dp_pdev_update_fast_rx_flag() - Update Fast rx flag for a PDEV * @soc : Data path soc handle * @pdev : PDEV handle * * Return: None */ void dp_pdev_update_fast_rx_flag(struct dp_soc *soc, struct dp_pdev *pdev); #ifdef FEATURE_DIRECT_LINK /** * dp_setup_direct_link_refill_ring(): Setup direct link refill ring for pdev * @soc_hdl: DP SOC handle * @pdev_id: pdev id * * Return: Handle to SRNG */ struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); /** * dp_destroy_direct_link_refill_ring(): Destroy direct link refill ring for * pdev * @soc_hdl: DP SOC handle * @pdev_id: pdev id * * Return: None */ void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id); #else static inline struct dp_srng *dp_setup_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { return NULL; } static inline void dp_destroy_direct_link_refill_ring(struct cdp_soc_t *soc_hdl, uint8_t pdev_id) { } #endif #ifdef WLAN_FEATURE_DP_CFG_EVENT_HISTORY static inline void dp_cfg_event_record(struct dp_soc *soc, enum dp_cfg_event_type event, union dp_cfg_event_desc *cfg_event_desc) { struct dp_cfg_event_history *cfg_event_history = &soc->cfg_event_history; struct dp_cfg_event *entry; uint32_t idx; uint16_t slot; dp_get_frag_hist_next_atomic_idx(&cfg_event_history->index, &idx, &slot, DP_CFG_EVT_HIST_SLOT_SHIFT, DP_CFG_EVT_HIST_PER_SLOT_MAX, DP_CFG_EVT_HISTORY_SIZE); entry = &cfg_event_history->entry[slot][idx]; entry->timestamp = qdf_get_log_timestamp(); entry->type = event; qdf_mem_copy(&entry->event_desc, cfg_event_desc, sizeof(entry->event_desc)); } static inline void dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_vdev *vdev) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_vdev_attach_detach_desc *vdev_evt = &cfg_evt_desc.vdev_evt; if (qdf_unlikely(event != DP_CFG_EVENT_VDEV_ATTACH && event != DP_CFG_EVENT_VDEV_UNREF_DEL && event != DP_CFG_EVENT_VDEV_DETACH)) { qdf_assert_always(0); return; } vdev_evt->vdev = vdev; vdev_evt->vdev_id = vdev->vdev_id; vdev_evt->ref_count = qdf_atomic_read(&vdev->ref_cnt); vdev_evt->mac_addr = vdev->mac_addr; dp_cfg_event_record(soc, event, &cfg_evt_desc); } static inline void dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, struct dp_vdev *vdev, uint8_t is_reuse) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_peer_cmn_ops_desc *peer_evt = &cfg_evt_desc.peer_cmn_evt; if (qdf_unlikely(event != DP_CFG_EVENT_PEER_CREATE && event != DP_CFG_EVENT_PEER_DELETE && event != DP_CFG_EVENT_PEER_UNREF_DEL)) { qdf_assert_always(0); return; } peer_evt->peer = peer; peer_evt->vdev = vdev; peer_evt->vdev_id = vdev->vdev_id; peer_evt->is_reuse = is_reuse; peer_evt->peer_ref_count = qdf_atomic_read(&peer->ref_cnt); peer_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt); peer_evt->mac_addr = peer->mac_addr; peer_evt->vdev_mac_addr = vdev->mac_addr; dp_cfg_event_record(soc, event, &cfg_evt_desc); } static inline void dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *mld_peer, struct dp_peer *link_peer, uint8_t idx, uint8_t result) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_mlo_add_del_link_desc *mlo_link_delink_evt = &cfg_evt_desc.mlo_link_delink_evt; if (qdf_unlikely(event != DP_CFG_EVENT_MLO_ADD_LINK && event != DP_CFG_EVENT_MLO_DEL_LINK)) { qdf_assert_always(0); return; } mlo_link_delink_evt->link_peer = link_peer; mlo_link_delink_evt->mld_peer = mld_peer; mlo_link_delink_evt->link_mac_addr = link_peer->mac_addr; mlo_link_delink_evt->mld_mac_addr = mld_peer->mac_addr; mlo_link_delink_evt->num_links = mld_peer->num_links; mlo_link_delink_evt->action_result = result; mlo_link_delink_evt->idx = idx; dp_cfg_event_record(soc, event, &cfg_evt_desc); } static inline void dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc, struct dp_peer *mld_peer, struct dp_vdev *prev_vdev, struct dp_vdev *new_vdev) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_mlo_setup_vdev_update_desc *vdev_update_evt = &cfg_evt_desc.mlo_setup_vdev_update; vdev_update_evt->mld_peer = mld_peer; vdev_update_evt->prev_vdev = prev_vdev; vdev_update_evt->new_vdev = new_vdev; dp_cfg_event_record(soc, DP_CFG_EVENT_MLO_SETUP_VDEV_UPDATE, &cfg_evt_desc); } static inline void dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, uint8_t *mac_addr, uint8_t is_ml_peer, uint16_t peer_id, uint16_t ml_peer_id, uint16_t hw_peer_id, uint8_t vdev_id) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_rx_peer_map_unmap_desc *peer_map_unmap_evt = &cfg_evt_desc.peer_map_unmap_evt; if (qdf_unlikely(event != DP_CFG_EVENT_PEER_MAP && event != DP_CFG_EVENT_PEER_UNMAP && event != DP_CFG_EVENT_MLO_PEER_MAP && event != DP_CFG_EVENT_MLO_PEER_UNMAP)) { qdf_assert_always(0); return; } peer_map_unmap_evt->peer_id = peer_id; peer_map_unmap_evt->ml_peer_id = ml_peer_id; peer_map_unmap_evt->hw_peer_id = hw_peer_id; peer_map_unmap_evt->vdev_id = vdev_id; /* Peer may be NULL at times, but its not an issue. */ peer_map_unmap_evt->peer = peer; peer_map_unmap_evt->is_ml_peer = is_ml_peer; qdf_mem_copy(&peer_map_unmap_evt->mac_addr.raw, mac_addr, QDF_MAC_ADDR_SIZE); dp_cfg_event_record(soc, event, &cfg_evt_desc); } static inline void dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, struct dp_vdev *vdev, uint8_t vdev_id, struct cdp_peer_setup_info *peer_setup_info) { union dp_cfg_event_desc cfg_evt_desc = {0}; struct dp_peer_setup_desc *peer_setup_evt = &cfg_evt_desc.peer_setup_evt; if (qdf_unlikely(event != DP_CFG_EVENT_PEER_SETUP && event != DP_CFG_EVENT_MLO_SETUP)) { qdf_assert_always(0); return; } peer_setup_evt->peer = peer; peer_setup_evt->vdev = vdev; if (vdev) peer_setup_evt->vdev_ref_count = qdf_atomic_read(&vdev->ref_cnt); peer_setup_evt->mac_addr = peer->mac_addr; peer_setup_evt->vdev_id = vdev_id; if (peer_setup_info) { peer_setup_evt->is_first_link = peer_setup_info->is_first_link; peer_setup_evt->is_primary_link = peer_setup_info->is_primary_link; qdf_mem_copy(peer_setup_evt->mld_mac_addr.raw, peer_setup_info->mld_peer_mac, QDF_MAC_ADDR_SIZE); } dp_cfg_event_record(soc, event, &cfg_evt_desc); } #else static inline void dp_cfg_event_record_vdev_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_vdev *vdev) { } static inline void dp_cfg_event_record_peer_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, struct dp_vdev *vdev, uint8_t is_reuse) { } static inline void dp_cfg_event_record_mlo_link_delink_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *mld_peer, struct dp_peer *link_peer, uint8_t idx, uint8_t result) { } static inline void dp_cfg_event_record_mlo_setup_vdev_update_evt(struct dp_soc *soc, struct dp_peer *mld_peer, struct dp_vdev *prev_vdev, struct dp_vdev *new_vdev) { } static inline void dp_cfg_event_record_peer_map_unmap_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, uint8_t *mac_addr, uint8_t is_ml_peer, uint16_t peer_id, uint16_t ml_peer_id, uint16_t hw_peer_id, uint8_t vdev_id) { } static inline void dp_cfg_event_record_peer_setup_evt(struct dp_soc *soc, enum dp_cfg_event_type event, struct dp_peer *peer, struct dp_vdev *vdev, uint8_t vdev_id, struct cdp_peer_setup_info *peer_setup_info) { } #endif #ifndef WLAN_SOFTUMAC_SUPPORT /** * dp_soc_interrupt_detach() - Deregister any allocations done for interrupts * @txrx_soc: DP SOC handle * * Return: none */ void dp_soc_interrupt_detach(struct cdp_soc_t *txrx_soc); #endif /** * dp_get_peer_stats()- Get peer stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * * Return: none */ void dp_get_peer_stats(struct dp_peer *peer, struct cdp_peer_stats *peer_stats); /** * dp_get_per_link_peer_stats()- Get per link peer stats * @peer: Datapath peer * @peer_stats: buffer for peer stats * @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); /** * dp_get_peer_hw_link_id() - get peer hardware link id * @soc: soc handle * @pdev: data path pdev * * Return: link_id */ static inline int dp_get_peer_hw_link_id(struct dp_soc *soc, struct dp_pdev *pdev) { if (wlan_cfg_is_peer_link_stats_enabled(soc->wlan_cfg_ctx)) return ((soc->arch_ops.get_hw_link_id(pdev)) + 1); return 0; } #ifdef QCA_MULTIPASS_SUPPORT /** * dp_tx_remove_vlan_tag() - Remove 4 bytes of vlan tag * @vdev: DP vdev handle * @nbuf: network buffer * * Return: void */ void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf); #endif /** * dp_print_per_link_stats() - Print per link peer stats. * @soc_hdl: soc handle. * @vdev_id: vdev_id. * * Return: None. */ void dp_print_per_link_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id); /** * dp_get_ring_stats_from_hal(): get hal level ring pointer values * @soc: DP_SOC handle * @srng: DP_SRNG handle * @ring_type: srng src/dst ring * @_tailp: pointer to tail of ring * @_headp: pointer to head of ring * @_hw_headp: pointer to head of ring in HW * @_hw_tailp: pointer to tail of ring in HW * * Return: void */ static inline void dp_get_ring_stats_from_hal(struct dp_soc *soc, struct dp_srng *srng, enum hal_ring_type ring_type, uint32_t *_tailp, uint32_t *_headp, int32_t *_hw_headp, int32_t *_hw_tailp) { uint32_t tailp; uint32_t headp; int32_t hw_headp = -1; int32_t hw_tailp = -1; struct hal_soc *hal_soc; if (soc && srng && srng->hal_srng) { hal_soc = (struct hal_soc *)soc->hal_soc; hal_get_sw_hptp(soc->hal_soc, srng->hal_srng, &tailp, &headp); *_headp = headp; *_tailp = tailp; hal_get_hw_hptp(soc->hal_soc, srng->hal_srng, &hw_headp, &hw_tailp, ring_type); *_hw_headp = hw_headp; *_hw_tailp = hw_tailp; } } /** * dp_update_vdev_be_basic_stats() - Update vdev basic stats * @txrx_peer: DP txrx_peer handle * @tgtobj: Pointer to buffer for be vdev stats * * Return: None */ void dp_update_vdev_be_basic_stats(struct dp_txrx_peer *txrx_peer, struct dp_vdev_stats *tgtobj); /** * dp_update_vdev_basic_stats() - Update vdev basic stats * @txrx_peer: DP txrx_peer handle * @tgtobj: Pointer to buffer for vdev stats * * Return: None */ void dp_update_vdev_basic_stats(struct dp_txrx_peer *txrx_peer, struct cdp_vdev_stats *tgtobj); /** * dp_get_vdev_stats_for_unmap_peer_legacy() - Update vdev basic stats * @vdev: vdev associated with the peer * @peer: unmapped peer * * Return: None */ void dp_get_vdev_stats_for_unmap_peer_legacy(struct dp_vdev *vdev, struct dp_peer *peer); #ifdef WLAN_FEATURE_TX_LATENCY_STATS /** * dp_h2t_tx_latency_stats_cfg_msg_send(): send HTT message for tx latency * stats config to FW * @dp_soc: DP SOC handle * @vdev_id: vdev id * @enable: indicates enablement of the feature * @period: statistical period for transmit latency in terms of ms * @granularity: granularity for tx latency distribution * * return: QDF STATUS */ QDF_STATUS dp_h2t_tx_latency_stats_cfg_msg_send(struct dp_soc *dp_soc, uint16_t vdev_id, bool enable, uint32_t period, uint32_t granularity); /** * dp_tx_latency_stats_update_cca() - update transmit latency statistics for * CCA * @soc: dp soc handle * @peer_id: peer id * @granularity: granularity of distribution * @distribution: distribution of transmit latency statistics * @avg: average of CCA latency(in microseconds) within a cycle * * Return: None */ void dp_tx_latency_stats_update_cca(struct dp_soc *soc, uint16_t peer_id, uint32_t granularity, uint32_t *distribution, uint32_t avg); /** * dp_tx_latency_stats_report() - report transmit latency statistics for each * vdev of specified pdev * @soc: dp soc handle * @pdev: dp pdev Handle * * Return: None */ void dp_tx_latency_stats_report(struct dp_soc *soc, struct dp_pdev *pdev); #endif #ifdef WLAN_FEATURE_SSR_DRIVER_DUMP /** * dp_ssr_dump_srng_register() - Register DP ring with SSR dump. * @region_name: ring name to register. * @srng: dp srng handler. * @num: Ring number * * num = -1. If there is only single ring * num = ring number. If there are multiple rings pass ring number. * e.g. in case of REO pass reo number (0..n). * * Return: None. */ void dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num); /** * dp_ssr_dump_srng_unregister() - Unegister DP ring with SSR dump. * @region_name: ring name to unregister. * @num: Ring number * * num = -1. If there is only single ring * num = ring number. If there are multiple rings pass ring number. * e.g. in case of REO pass reo number (0..n). * * Return: None. */ void dp_ssr_dump_srng_unregister(char *region_name, int num); /** * dp_ssr_dump_pdev_register() - Register DP Pdev with SSR dump. * @pdev: Pdev handle to register. * @pdev_id: Pdev ID. * * Return: None. */ void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id); /** * dp_ssr_dump_pdev_unregister() - Unregister DP Pdev with SSR dump. * @pdev_id: Pdev ID. * * Return: None. */ void dp_ssr_dump_pdev_unregister(uint8_t pdev_id); #else static inline void dp_ssr_dump_srng_register(char *region_name, struct dp_srng *srng, int num) { } static inline void dp_ssr_dump_srng_unregister(char *region_name, int num) { } static inline void dp_ssr_dump_pdev_register(struct dp_pdev *pdev, uint8_t pdev_id) { } static inline void dp_ssr_dump_pdev_unregister(uint8_t pdev_id) { } #endif /** * dp_get_peer_vdev_roaming_in_progress() - Check if peer's vdev is in roaming * state. * @peer: DP peer handle * * Return: true if the peer's vdev is in roaming state * else false. */ bool dp_get_peer_vdev_roaming_in_progress(struct dp_peer *peer); #endif /* #ifndef _DP_INTERNAL_H_ */