android_kernel_samsung_sm8650-modules/dp/inc/cdp_txrx_cmn_struct.h

/*
 * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved.
 * Copyright (c) 2021-2023 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.
 */

 /**
  * DOC: cdp_txrx_cmn_struct.h
  * Define the host data path converged API functions
  * called by the host control SW and the OS interface module
  */
#ifndef _CDP_TXRX_CMN_STRUCT_H_
#define _CDP_TXRX_CMN_STRUCT_H_

/*
 * For WIN legacy header compilation
 * Temporary add dummy definitions
 * should be removed properly WIN legacy code handle
 */

#include "htc_api.h"
#include "qdf_types.h"
#include "qdf_nbuf.h"
#include "qdf_atomic.h"
#ifdef DP_MOB_DEFS
#include <cdp_txrx_mob_def.h>
#endif
#include <cdp_txrx_handle.h>
#include <cdp_txrx_stats_struct.h>
#ifdef WLAN_RX_PKT_CAPTURE_ENH
#include "cdp_txrx_extd_struct.h"
#endif

#ifdef WLAN_MAX_CLIENTS_ALLOWED
#define OL_TXRX_NUM_LOCAL_PEER_IDS (WLAN_MAX_CLIENTS_ALLOWED + 1 + 1 + 1)
#endif

#ifndef OL_TXRX_NUM_LOCAL_PEER_IDS
/*
 * Each AP will occupy one ID, so it will occupy two IDs for AP-AP mode.
 * Clients will be assigned max 32 IDs.
 * STA(associated)/P2P DEV(self-PEER) will get one ID.
 */
#define OL_TXRX_NUM_LOCAL_PEER_IDS (32 + 1 + 1 + 1)
#endif

#define CDP_BA_256_BIT_MAP_SIZE_DWORDS 8
#define CDP_BA_64_BIT_MAP_SIZE_DWORDS 2
#define CDP_RSSI_CHAIN_LEN 8

#define OL_TXRX_INVALID_PDEV_ID 0xff
#define OL_TXRX_INVALID_LOCAL_PEER_ID 0xffff
#define CDP_INVALID_VDEV_ID 0xff

/* Max vdev_stats_id(48) is as per the max vdevs supported by HW */
#define CDP_MAX_VDEV_STATS_ID     0x30
/* Invalid vdev_stats_id */
#define CDP_INVALID_VDEV_STATS_ID 0xFF

/* Options for Dump Statistics */
#define CDP_HDD_STATS               0
#define CDP_TXRX_PATH_STATS         1
#define CDP_TXRX_HIST_STATS         2
#define CDP_TXRX_TSO_STATS          3
#define CDP_HDD_NETIF_OPER_HISTORY  4
#define CDP_DUMP_TX_FLOW_POOL_INFO  5
#define CDP_TXRX_DESC_STATS         6
#define CDP_HIF_STATS               7
#define CDP_LRO_STATS               8
#define CDP_NAPI_STATS              9
#define CDP_WLAN_RX_BUF_DEBUG_STATS 10
#define CDP_RX_RING_STATS          11
#define CDP_DP_NAPI_STATS          12
#define CDP_DP_RX_THREAD_STATS     13
#define CDP_SCHEDULER_STATS        21
#define CDP_TX_QUEUE_STATS         22
#define CDP_BUNDLE_STATS           23
#define CDP_CREDIT_STATS           24
#define CDP_DISCONNECT_STATS       25
#define CDP_DP_RX_FISA_STATS	   26
#define CDP_DP_SWLM_STATS	   27
#define CDP_DP_TX_HW_LATENCY_STATS 28

#define WME_AC_TO_TID(_ac) (       \
		((_ac) == WME_AC_VO) ? 6 : \
		((_ac) == WME_AC_VI) ? 5 : \
		((_ac) == WME_AC_BK) ? 1 : \
		0)

#define TID_TO_WME_AC(_tid) (      \
		(((_tid) == 0) || ((_tid) == 3)) ? WME_AC_BE : \
		(((_tid) == 1) || ((_tid) == 2)) ? WME_AC_BK : \
		(((_tid) == 4) || ((_tid) == 5)) ? WME_AC_VI : \
		WME_AC_VO)

#define CDP_MU_MAX_USERS 37
#define CDP_MU_MAX_USER_INDEX (CDP_MU_MAX_USERS - 1)
#define CDP_INVALID_PEER 0xffff
#define CDP_INVALID_TID	 31
#define CDP_INVALID_TX_ENCAP_TYPE	 6
#define CDP_INVALID_SEC_TYPE		12

#define CDP_DATA_TID_MAX 8
#define CDP_DATA_NON_QOS_TID 16

#define CDP_NUM_SA_BW 4
#define CDP_PERCENT_MACRO 100
#define CDP_NUM_KB_IN_MB 1000
/*
 * advance rx monitor filter
 */
#define MON_FILTER_PASS			0x0001
#define MON_FILTER_OTHER		0x0002
#define MON_FILTER_ALL			0x0003

#define FILTER_MGMT_ALL			0xFFFF
#define FILTER_MGMT_ASSOC_REQ		0x0001
#define FILTER_MGMT_ASSOC_RES		0x0002
#define FILTER_MGMT_REASSOC_REQ		0x0004
#define FILTER_MGMT_REASSOC_RES		0x0008
#define FILTER_MGMT_PROBE_REQ		0x0010
#define FILTER_MGMT_PROBE_RES		0x0020
#define FILTER_MGMT_TIM_ADVT		0x0040
#define FILTER_MGMT_RESERVED_7		0x0080
#define FILTER_MGMT_BEACON		0x0100
#define FILTER_MGMT_ATIM		0x0200
#define FILTER_MGMT_DISASSOC		0x0400
#define FILTER_MGMT_AUTH		0x0800
#define FILTER_MGMT_DEAUTH		0x1000
#define FILTER_MGMT_ACTION		0x2000
#define FILTER_MGMT_ACT_NO_ACK		0x4000
#define FILTER_MGMT_RESERVED_15		0x8000

#define FILTER_CTRL_ALL			0xFFFF
#define FILTER_CTRL_RESERVED_1		0x0001
#define FILTER_CTRL_RESERVED_2		0x0002
#define FILTER_CTRL_TRIGGER		0x0004
#define FILTER_CTRL_RESERVED_4		0x0008
#define FILTER_CTRL_BF_REP_POLL		0x0010
#define FILTER_CTRL_VHT_NDP		0x0020
#define FILTER_CTRL_FRAME_EXT		0x0040
#define FILTER_CTRL_CTRLWRAP		0x0080
#define FILTER_CTRL_BA_REQ		0x0100
#define FILTER_CTRL_BA			0x0200
#define FILTER_CTRL_PSPOLL		0x0400
#define FILTER_CTRL_RTS			0x0800
#define FILTER_CTRL_CTS			0x1000
#define FILTER_CTRL_ACK			0x2000
#define FILTER_CTRL_CFEND		0x4000
#define FILTER_CTRL_CFEND_CFACK		0x8000

#define FILTER_DATA_ALL			0xFFFF
#define FILTER_DATA_MCAST		0x4000
#define FILTER_DATA_UCAST		0x8000
#define FILTER_DATA_DATA		0x0001
#define FILTER_DATA_NULL		0x0008

/*
 * Multiply rate by 2 to avoid float point
 * and get rate in units of 500kbps
 */
#define CDP_11B_RATE_0MCS (11 * 2)
#define CDP_11B_RATE_1MCS (5.5 * 2)
#define CDP_11B_RATE_2MCS (2 * 2)
#define CDP_11B_RATE_3MCS (1 * 2)
#define CDP_11B_RATE_4MCS (11 * 2)
#define CDP_11B_RATE_5MCS (5.5 * 2)
#define CDP_11B_RATE_6MCS (2 * 2)

#define CDP_11A_RATE_0MCS (48 * 2)
#define CDP_11A_RATE_1MCS (24 * 2)
#define CDP_11A_RATE_2MCS (12 * 2)
#define CDP_11A_RATE_3MCS (6 * 2)
#define CDP_11A_RATE_4MCS (54 * 2)
#define CDP_11A_RATE_5MCS (36 * 2)
#define CDP_11A_RATE_6MCS (18 * 2)
#define CDP_11A_RATE_7MCS (9 * 2)

#define CDP_LEGACY_MCS0  0
#define CDP_LEGACY_MCS1  1
#define CDP_LEGACY_MCS2  2
#define CDP_LEGACY_MCS3  3
#define CDP_LEGACY_MCS4  4
#define CDP_LEGACY_MCS5  5
#define CDP_LEGACY_MCS6  6
#define CDP_LEGACY_MCS7  7

QDF_DECLARE_EWMA(tx_lag, 1024, 8)
struct cdp_stats_cookie;

/**
 * enum cdp_cfg_param_type - DP configuration parameters
 * @CDP_CFG_MAX_PEER_ID: Maximum peer id
 * @CDP_CFG_CCE_DISABLE: CCE disable
 * @CDP_CFG_NUM_PARAMS: Total number of params
 */
enum cdp_cfg_param_type {
	CDP_CFG_MAX_PEER_ID,
	CDP_CFG_CCE_DISABLE,
	CDP_CFG_NUM_PARAMS
};

/**
 * enum CDP_PPDU_STATS_PPDU_TYPE - PPDU TYPE from FW
 * @CDP_PPDU_STATS_PPDU_TYPE_SU: single user type
 * @CDP_PPDU_STATS_PPDU_TYPE_MU_MIMO: multi user mu-mimo
 * @CDP_PPDU_STATS_PPDU_TYPE_MU_OFDMA: multi user ofdma
 * @CDP_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA: multi user mu-mimo ofdma
 * @CDP_PPDU_STATS_PPDU_TYPE_UL_TRIG: ul trigger ppdu
 * @CDP_PPDU_STATS_PPDU_TYPE_BURST_BCN: burst beacon
 * @CDP_PPDU_STATS_PPDU_TYPE_UL_BSR_RESP: bsr respond
 * @CDP_PPDU_STATS_PPDU_TYPE_UL_BSR_TRIG: bsr trigger
 * @CDP_PPDU_STATS_PPDU_TYPE_UL_RESP: ul response
 * @CDP_PPDU_STATS_PPDU_TYPE_UNKNOWN: unknown
 */
enum CDP_PPDU_STATS_PPDU_TYPE {
	CDP_PPDU_STATS_PPDU_TYPE_SU = 0,
	CDP_PPDU_STATS_PPDU_TYPE_MU_MIMO = 1,
	CDP_PPDU_STATS_PPDU_TYPE_MU_OFDMA = 2,
	CDP_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA = 4,
	CDP_PPDU_STATS_PPDU_TYPE_UL_TRIG = 5,
	CDP_PPDU_STATS_PPDU_TYPE_BURST_BCN = 6,
	CDP_PPDU_STATS_PPDU_TYPE_UL_BSR_RESP = 7,
	CDP_PPDU_STATS_PPDU_TYPE_UL_BSR_TRIG = 8,
	CDP_PPDU_STATS_PPDU_TYPE_UL_RESP = 9,
	CDP_PPDU_STATS_PPDU_TYPE_UNKNOWN = 0x1F,
};

/**
 * enum htt_cmn_dbg_stats_type -
 * bit positions for each stats type within a stats type bitmask
 * The bitmask contains 24 bits.
 * @HTT_DBG_CMN_STATS_WAL_PDEV_TXRX:
 * @HTT_DBG_CMN_STATS_RX_REORDER:
 * @HTT_DBG_CMN_STATS_RX_RATE_INFO:
 * @HTT_DBG_CMN_STATS_TX_PPDU_LOG:
 * @HTT_DBG_CMN_STATS_TX_RATE_INFO:
 * @HTT_DBG_CMN_STATS_TIDQ:
 * @HTT_DBG_CMN_STATS_TXBF_INFO:
 * @HTT_DBG_CMN_STATS_SND_INFO:
 * @HTT_DBG_CMN_STATS_ERROR_INFO:
 * @HTT_DBG_CMN_STATS_TX_SELFGEN_INFO:
 * @HTT_DBG_CMN_STATS_TX_MU_INFO:
 * @HTT_DBG_CMN_STATS_SIFS_RESP_INFO:
 * @HTT_DBG_CMN_STATS_RESET_INFO:
 * @HTT_DBG_CMN_STATS_MAC_WDOG_INFO:
 * @HTT_DBG_CMN_STATS_TX_DESC_INFO:
 * @HTT_DBG_CMN_STATS_TX_FETCH_MGR_INFO:
 * @HTT_DBG_CMN_STATS_TX_PFSCHED_INFO:
 * @HTT_DBG_CMN_STATS_TX_PATH_STATS_INFO:
 * @HTT_DBG_CMN_NUM_STATS:
 * @HTT_DBG_CMN_NUM_STATS_INVALID:
 */
enum htt_cmn_dbg_stats_type {
	HTT_DBG_CMN_STATS_WAL_PDEV_TXRX      = 0,  /* bit 0 -> 0x1 */
	HTT_DBG_CMN_STATS_RX_REORDER         = 1,  /* bit 1 -> 0x2 */
	HTT_DBG_CMN_STATS_RX_RATE_INFO       = 2,  /* bit 2 -> 0x4 */
	HTT_DBG_CMN_STATS_TX_PPDU_LOG        = 3,  /* bit 3 -> 0x8 */
	HTT_DBG_CMN_STATS_TX_RATE_INFO       = 4,  /* bit 4 -> 0x10 */
	HTT_DBG_CMN_STATS_TIDQ               = 5,  /* bit 5 -> 0x20 */
	HTT_DBG_CMN_STATS_TXBF_INFO          = 6,  /* bit 6 -> 0x40 */
	HTT_DBG_CMN_STATS_SND_INFO           = 7,  /* bit 7 -> 0x80 */
	HTT_DBG_CMN_STATS_ERROR_INFO         = 8,  /* bit 8  -> 0x100 */
	HTT_DBG_CMN_STATS_TX_SELFGEN_INFO    = 9,  /* bit 9  -> 0x200 */
	HTT_DBG_CMN_STATS_TX_MU_INFO         = 10, /* bit 10 -> 0x400 */
	HTT_DBG_CMN_STATS_SIFS_RESP_INFO     = 11, /* bit 11 -> 0x800 */
	HTT_DBG_CMN_STATS_RESET_INFO         = 12, /* bit 12 -> 0x1000 */
	HTT_DBG_CMN_STATS_MAC_WDOG_INFO      = 13, /* bit 13 -> 0x2000 */
	HTT_DBG_CMN_STATS_TX_DESC_INFO       = 14, /* bit 14 -> 0x4000 */
	HTT_DBG_CMN_STATS_TX_FETCH_MGR_INFO  = 15, /* bit 15 -> 0x8000 */
	HTT_DBG_CMN_STATS_TX_PFSCHED_INFO    = 16, /* bit 16 -> 0x10000 */
	HTT_DBG_CMN_STATS_TX_PATH_STATS_INFO = 17, /* bit 17 -> 0x20000 */
	/* bits 18-23 currently reserved */

	/* keep this last */
	HTT_DBG_CMN_NUM_STATS,
	HTT_DBG_CMN_NUM_STATS_INVALID        = 31, /* bit 31 -> 0x80000000 */
};

/**
 * enum cdp_host_txrx_stats - Different types of host stats
 * @TXRX_HOST_STATS_INVALID: Invalid option
 * @TXRX_CLEAR_STATS: clear all host stats
 * @TXRX_RX_RATE_STATS: Rx rate info
 * @TXRX_TX_RATE_STATS: Tx rate info
 * @TXRX_TX_HOST_STATS: Print Tx stats
 * @TXRX_RX_HOST_STATS: Print host Rx stats
 * @TXRX_AST_STATS:
 * @TXRX_SRNG_PTR_STATS: Print SRNG pointer stats
 * @TXRX_RX_MON_STATS: Print monitor mode stats
 * @TXRX_REO_QUEUE_STATS: Print Per peer REO Queue Stats
 * @TXRX_SOC_CFG_PARAMS: Print soc cfg params info
 * @TXRX_PDEV_CFG_PARAMS: Print pdev cfg params info
 * @TXRX_NAPI_STATS: Print NAPI scheduling statistics
 * @TXRX_SOC_INTERRUPT_STATS: Print soc interrupt stats
 * @TXRX_SOC_FSE_STATS:
 * @TXRX_HAL_REG_WRITE_STATS: Hal Reg Write stats
 * @TXRX_SOC_REO_HW_DESC_DUMP: HW REO queue desc dump
 * @TXRX_SOC_WBM_IDLE_HPTP_DUMP: WBM idle link desc SRNG HP/TP dump
 * @TXRX_SRNG_USAGE_WM_STATS: SRNG usage watermark stats
 * @TXRX_HOST_STATS_MAX:
 */
enum cdp_host_txrx_stats {
	TXRX_HOST_STATS_INVALID  = -1,
	TXRX_CLEAR_STATS     = 0,
	TXRX_RX_RATE_STATS   = 1,
	TXRX_TX_RATE_STATS   = 2,
	TXRX_TX_HOST_STATS   = 3,
	TXRX_RX_HOST_STATS   = 4,
	TXRX_AST_STATS       = 5,
	TXRX_SRNG_PTR_STATS  = 6,
	TXRX_RX_MON_STATS    = 7,
	TXRX_REO_QUEUE_STATS = 8,
	TXRX_SOC_CFG_PARAMS   = 9,
	TXRX_PDEV_CFG_PARAMS  = 10,
	TXRX_NAPI_STATS       = 11,
	TXRX_SOC_INTERRUPT_STATS = 12,
	TXRX_SOC_FSE_STATS = 13,
	TXRX_HAL_REG_WRITE_STATS = 14,
	TXRX_SOC_REO_HW_DESC_DUMP = 15,
	TXRX_SOC_WBM_IDLE_HPTP_DUMP = 16,
	TXRX_SRNG_USAGE_WM_STATS = 17,
	TXRX_HOST_STATS_MAX,
};

/**
 * enum cdp_ppdu_ftype - PPDU Frame Type
 * @CDP_PPDU_FTYPE_DATA: SU or MU Data Frame
 * @CDP_PPDU_FTYPE_CTRL: Control/Management Frames
 * @CDP_PPDU_FTYPE_BAR: SU or MU BAR frames
 * @CDP_PPDU_FTYPE_MAX: Max value
 */
enum cdp_ppdu_ftype {
	CDP_PPDU_FTYPE_CTRL,
	CDP_PPDU_FTYPE_DATA,
	CDP_PPDU_FTYPE_BAR,
	CDP_PPDU_FTYPE_MAX
};


/**
 * enum htt_cmn_pkt_type - General specification of the tx frame contents
 * @htt_cmn_pkt_type_raw: raw
 * @htt_cmn_pkt_type_native_wifi: native wifi
 * @htt_cmn_pkt_type_ethernet: ethernet
 * @htt_cmn_pkt_type_mgmt: management
 * @htt_cmn_pkt_type_eth2: ethernet2
 * @htt_cmn_pkt_num_types: number of packet types
 *
 * for efficiency, the HTT packet type values correspond
 * to the bit positions of the WAL packet type values, so the
 * translation is a simple shift operation.
 */
enum htt_cmn_pkt_type {
	htt_cmn_pkt_type_raw = 0,
	htt_cmn_pkt_type_native_wifi = 1,
	htt_cmn_pkt_type_ethernet = 2,
	htt_cmn_pkt_type_mgmt = 3,
	htt_cmn_pkt_type_eth2 = 4,

	/* keep this last */
	htt_cmn_pkt_num_types
};

/**
 * enum htt_cmn_rx_status - description of HTT received packets status
 * @htt_cmn_rx_status_unknown:
 * @htt_cmn_rx_status_ok:
 * @htt_cmn_rx_status_err_fcs:
 * @htt_cmn_rx_status_err_dup:
 * @htt_cmn_rx_status_err_replay:
 * @htt_cmn_rx_status_inv_peer:
 * @htt_cmn_rx_status_ctrl_mgmt_null:
 * @htt_cmn_rx_status_tkip_mic_err:
 * @htt_cmn_rx_status_decrypt_err:
 * @htt_cmn_rx_status_mpdu_length_err:
 * @htt_cmn_rx_status_err_misc:
 *
 * It is similar to htt_rx_status enum
 * but is added as a cdp enum can be freely used in OL_IF layer
 */
enum htt_cmn_rx_status {
	htt_cmn_rx_status_unknown = 0x0,
	htt_cmn_rx_status_ok,
	htt_cmn_rx_status_err_fcs,
	htt_cmn_rx_status_err_dup,
	htt_cmn_rx_status_err_replay,
	htt_cmn_rx_status_inv_peer,
	htt_cmn_rx_status_ctrl_mgmt_null = 0x08,
	htt_cmn_rx_status_tkip_mic_err = 0x09,
	htt_cmn_rx_status_decrypt_err = 0x0A,
	htt_cmn_rx_status_mpdu_length_err = 0x0B,
	htt_cmn_rx_status_err_misc = 0xFF
};


enum cdp_host_reo_dest_ring {
    cdp_host_reo_dest_ring_unknown = 0,
    cdp_host_reo_dest_ring_1 = 1,
    cdp_host_reo_dest_ring_2 = 2,
    cdp_host_reo_dest_ring_3 = 3,
    cdp_host_reo_dest_ring_4 = 4,
};

enum htt_cmn_t2h_en_stats_type {
    /* keep this always first */
    HTT_CMN_T2H_EN_STATS_TYPE_START     = 0,

    /** ppdu_common_stats is the payload */
    HTT_CMN_T2H_EN_STATS_TYPE_COMMON    = 1,
    /** ppdu_sant_stats is the payload */
    HTT_CMN_T2H_EN_STATS_TYPE_SANT      = 2,
    /** ppdu_common_stats_v2 is the payload */
    HTT_CMN_T2H_EN_STATS_TYPE_COMMON_V2 = 3,

    /* Keep this last */
    HTT_CMN_T2H_EN_STATS_TYPE_END       = 0x1f,
};

enum htt_cmn_t2h_en_stats_status {
    /* Keep this first always */
    HTT_CMN_T2H_EN_STATS_STATUS_PARTIAL     = 0,
    HTT_CMN_T2H_EN_STATS_STATUS_PRESENT     = 1,
    HTT_CMN_T2H_EN_STATS_STATUS_ERROR       = 2,
    HTT_CMN_T2H_EN_STATS_STATUS_INVALID     = 3,


    /* keep this always last */
    HTT_CMN_T2H_EN_STATS_STATUS_SERIES_DONE         = 7,
};

/**
 * enum cdp_peer_type - Peer type
 * @CDP_INVALID_PEER_TYPE: invalid peer type
 * @CDP_LINK_PEER_TYPE: legacy peer or link peer for MLO connection
 * @CDP_MLD_PEER_TYPE: MLD peer for MLO connection
 * @CDP_WILD_PEER_TYPE: used to set peer type for same mld/link mac addr
 */
enum cdp_peer_type {
	CDP_INVALID_PEER_TYPE,
	CDP_LINK_PEER_TYPE,
	CDP_MLD_PEER_TYPE,
	CDP_WILD_PEER_TYPE,
};

/**
 * struct cdp_peer_setup_info - MLO connection info for cdp_peer_setup()
 * @mld_peer_mac: mld peer mac address pointer
 * @is_first_link: set true for first MLO link peer
 * @is_primary_link: set true for MLO primary link peer
 * @primary_umac_id: primary umac_id
 * @num_links: number of links in MLO
 */
struct cdp_peer_setup_info {
	uint8_t *mld_peer_mac;
	uint8_t is_first_link:1,
		is_primary_link:1;
	uint8_t primary_umac_id;
	uint8_t num_links;
};

/**
 * struct cdp_peer_info - peer info for dp hash find
 * @vdev_id: Vdev ID
 * @mac_addr: peer mac address to search
 * @mac_addr_is_aligned: true only if mac_addr type is
 *			"union dp_align_mac_addr", otherwise set false always.
 * @peer_type: link or MLD peer type
 */
struct cdp_peer_info {
	uint8_t vdev_id;
	uint8_t *mac_addr;
	bool mac_addr_is_aligned;
	enum cdp_peer_type peer_type;
};

/**
 * enum ol_txrx_peer_state - Peer state information
 * @OL_TXRX_PEER_STATE_INVALID: Invalid
 * @OL_TXRX_PEER_STATE_DISC: disconnected (initial state)
 * @OL_TXRX_PEER_STATE_CONN: authentication in progress
 * @OL_TXRX_PEER_STATE_AUTH: authentication successful
 */
enum ol_txrx_peer_state {
	OL_TXRX_PEER_STATE_INVALID,
	OL_TXRX_PEER_STATE_DISC,
	OL_TXRX_PEER_STATE_CONN,
	OL_TXRX_PEER_STATE_AUTH,
};

/**
 * enum cdp_txrx_ast_entry_type - AST entry type information
 * @CDP_TXRX_AST_TYPE_NONE: static ast entry for connected peer
 * @CDP_TXRX_AST_TYPE_STATIC: static ast entry for connected peer
 * @CDP_TXRX_AST_TYPE_SELF: static ast entry for self peer (STA mode)
 * @CDP_TXRX_AST_TYPE_WDS: WDS peer ast entry type
 * @CDP_TXRX_AST_TYPE_WDS_HM: HM WDS entry
 * @CDP_TXRX_AST_TYPE_STA_BSS: BSS entry(STA mode)
 * @CDP_TXRX_AST_TYPE_DA:	AST entry based on Destination address
 * @CDP_TXRX_AST_TYPE_WDS_HM_SEC: HM WDS entry for secondary radio
 * @CDP_TXRX_AST_TYPE_MLD: AST entry type for MLD peer
 * @CDP_TXRX_AST_TYPE_MAX:
 */
enum cdp_txrx_ast_entry_type {
	CDP_TXRX_AST_TYPE_NONE,
	CDP_TXRX_AST_TYPE_STATIC,
	CDP_TXRX_AST_TYPE_SELF,
	CDP_TXRX_AST_TYPE_WDS,
	CDP_TXRX_AST_TYPE_WDS_HM,
	CDP_TXRX_AST_TYPE_STA_BSS,
	CDP_TXRX_AST_TYPE_DA,
	CDP_TXRX_AST_TYPE_WDS_HM_SEC,
	CDP_TXRX_AST_TYPE_MLD,
	CDP_TXRX_AST_TYPE_MAX
};

/**
 * enum cdp_ast_free_status - status passed to callback function before
 *                            freeing ast
 * @CDP_TXRX_AST_DELETED: AST is deleted from FW and delete response received
 * @CDP_TXRX_AST_DELETE_IN_PROGRESS: AST delete command sent to FW and host
 *                                    is waiting for FW response
 */
enum cdp_ast_free_status {
	CDP_TXRX_AST_DELETED,
	CDP_TXRX_AST_DELETE_IN_PROGRESS,
};

/**
 * typedef txrx_ast_free_cb() - callback registered for ast free
 * @ctrl_soc: control path soc context
 * @cdp_soc: DP soc context
 * @cookie: cookie
 * @cdp_ast_free_status: ast free status
 */
typedef void (*txrx_ast_free_cb)(struct cdp_ctrl_objmgr_psoc *ctrl_soc,
				 struct cdp_soc *cdp_soc,
				 void *cookie,
				 enum cdp_ast_free_status);

/**
 *  struct cdp_ast_entry_info - AST entry information
 *  @peer_mac_addr: mac address of peer on which AST entry is added
 *  @type: ast entry type
 *  @vdev_id: vdev_id
 *  @pdev_id: pdev_id
 *  @peer_id: peer_id
 *
 *  This structure holds the ast entry information
 *
 */
struct cdp_ast_entry_info {
	uint8_t peer_mac_addr[QDF_MAC_ADDR_SIZE];
	enum cdp_txrx_ast_entry_type type;
	uint8_t vdev_id;
	uint8_t pdev_id;
	uint16_t peer_id;
};

#define MIC_SEQ_CTR_SIZE 6

enum cdp_rx_frame_type {
	cdp_rx_frame_type_802_11,
	cdp_rx_frame_type_802_3,
};

/**
 *  struct cdp_rx_mic_err_info - rx mic error information
 *  @frame_type: frame type - 0 - 802.11 frame
 *                          - 1 - 802.3 frame
 *  @data: 802.11 frame
 *  @ta_mac_addr: transmitter mac address
 *  @da_mac_addr: destination mac address
 *  @tsc: sequence number
 *  @key_id: Key ID
 *  @multicast: flag for multicast
 *  @vdev_id: vdev ID
 *
 *  This structure holds rx mic error information
 *
 */
struct cdp_rx_mic_err_info {
	uint8_t frame_type;
	uint8_t *data;
	struct qdf_mac_addr ta_mac_addr;
	struct qdf_mac_addr da_mac_addr;
	uint8_t tsc[MIC_SEQ_CTR_SIZE];
	uint8_t key_id;
	bool multicast;
	uint16_t vdev_id;
};

#ifdef WLAN_SUPPORT_MSCS
/**
 * struct cdp_mscs_params - MSCS parameters obtained
 * from handshake
 * @user_pri_bitmap: User priority bitmap
 * @user_pri_limit: User priority limit
 * @classifier_type: TCLAS Classifier type
 * @classifier_mask: TCLAS Classifier mask
 */
struct cdp_mscs_params {
	uint8_t user_pri_bitmap;
	uint8_t user_pri_limit;
	uint8_t classifier_type;
	uint8_t classifier_mask;
};
#endif

/**
 * enum cdp_sec_type - security type information
 * @cdp_sec_type_none:
 * @cdp_sec_type_wep128:
 * @cdp_sec_type_wep104:
 * @cdp_sec_type_wep40:
 * @cdp_sec_type_tkip:
 * @cdp_sec_type_tkip_nomic:
 * @cdp_sec_type_aes_ccmp:
 * @cdp_sec_type_wapi:
 * @cdp_sec_type_aes_ccmp_256:
 * @cdp_sec_type_aes_gcmp:
 * @cdp_sec_type_aes_gcmp_256:
 * @cdp_num_sec_types:
 */
enum cdp_sec_type {
    cdp_sec_type_none,
    cdp_sec_type_wep128,
    cdp_sec_type_wep104,
    cdp_sec_type_wep40,
    cdp_sec_type_tkip,
    cdp_sec_type_tkip_nomic,
    cdp_sec_type_aes_ccmp,
    cdp_sec_type_wapi,
    cdp_sec_type_aes_ccmp_256,
    cdp_sec_type_aes_gcmp,
    cdp_sec_type_aes_gcmp_256,

    /* keep this last! */
    cdp_num_sec_types
};

/**
 * struct cdp_tx_exception_metadata - Exception path parameters
 * @peer_id: Peer id of the peer
 * @tid: Transmit Identifier
 * @tx_encap_type: Transmit encap type (i.e. Raw, Native Wi-Fi, Ethernet)
 * @sec_type: sec_type to be passed to HAL
 * @is_tx_sniffer: Indicates if the packet has to be sniffed
 * @is_intrabss_fwd:
 * @ppdu_cookie: 16-bit ppdu cookie that has to be replayed back in completions
 * @is_wds_extended:
 *
 * This structure holds the parameters needed in the exception path of tx
 *
 */
struct cdp_tx_exception_metadata {
	uint16_t peer_id;
	uint8_t tid;
	uint16_t tx_encap_type;
	enum cdp_sec_type sec_type;
	uint8_t is_tx_sniffer :1,
		is_intrabss_fwd :1;
	uint16_t ppdu_cookie;
#ifdef QCA_SUPPORT_WDS_EXTENDED
	uint8_t is_wds_extended;
#endif
};

/**
 * enum wlan_op_mode - Virtual device operation mode
 * @wlan_op_mode_unknown: Unknown mode
 * @wlan_op_mode_ap: AP mode
 * @wlan_op_mode_ibss: IBSS mode
 * @wlan_op_mode_sta: STA (client) mode
 * @wlan_op_mode_monitor: Monitor mode
 * @wlan_op_mode_ocb: OCB mode
 * @wlan_op_mode_ndi: NDI mode
 */
enum wlan_op_mode {
	wlan_op_mode_unknown,
	wlan_op_mode_ap,
	wlan_op_mode_ibss,
	wlan_op_mode_sta,
	wlan_op_mode_monitor,
	wlan_op_mode_ocb,
	wlan_op_mode_ndi,
};

/**
 * enum wlan_op_subtype - Virtual device subtype
 * @wlan_op_subtype_none: Subtype not applicable
 * @wlan_op_subtype_p2p_device: P2P device
 * @wlan_op_subtype_p2p_cli: P2P Client
 * @wlan_op_subtype_p2p_go: P2P GO
 *
 * This enum lists the subtypes of a particular virtual
 * device.
 */
enum wlan_op_subtype {
	wlan_op_subtype_none,
	wlan_op_subtype_p2p_device,
	wlan_op_subtype_p2p_cli,
	wlan_op_subtype_p2p_go,
};

/**
 * struct cdp_vdev_info - Vdev information
 * @vdev_mac_addr: mac address of the vdev
 * @vdev_id: ID of the vdev
 * @vdev_stats_id: Stats ID of the vdev
 * @op_mode: Operation mode of the vdev
 * @subtype: subtype of the vdev
 * @mld_mac_addr: MLD mac addr of the current vdev.
 */
struct cdp_vdev_info {
	uint8_t *vdev_mac_addr;
	uint8_t vdev_id;
	uint8_t vdev_stats_id;
	enum wlan_op_mode op_mode;
	enum wlan_op_subtype subtype;
#ifdef WLAN_FEATURE_11BE_MLO
	uint8_t *mld_mac_addr;
#endif
};

typedef struct cdp_soc_t *ol_txrx_soc_handle;

/**
 * typedef ol_txrx_vdev_delete_cb ()- callback registered during vdev detach
 * @context:
 */
typedef void (*ol_txrx_vdev_delete_cb)(void *context);

/**
 * typedef ol_txrx_peer_unmap_sync_cb() - callback registered during peer
 *                                        detach sync
 * @vdev_id:
 * @peer_id_cnt:
 * @peer_id_list:
 */
typedef QDF_STATUS(*ol_txrx_peer_unmap_sync_cb)(uint8_t vdev_id,
						 uint32_t peer_id_cnt,
						 uint16_t *peer_id_list);

/**
 * enum txrx_direction - Packet Direction
 * @rx_direction: rx path packet
 * @tx_direction: tx path packet
 */
enum txrx_direction {
	rx_direction = 1,
	tx_direction = 0,
};

/**
 * enum cdp_capabilities- DP capabilities
 * @CDP_CFG_DP_TSO: TSO capability
 * @CDP_CFG_DP_LRO: LRO capability
 * @CDP_CFG_DP_SG: Scatter Gather capability
 * @CDP_CFG_DP_GRO: GRO capability
 * @CDP_CFG_DP_OL_TX_CSUM: Hardware based TX checksum capability
 * @CDP_CFG_DP_OL_RX_CSUM: Hardware based RX checksum capability
 * @CDP_CFG_DP_RAWMODE: RAW mode capability
 * @CDP_CFG_DP_PEER_FLOW_CTRL: Peer flow-control capability
 * @CDP_CFG_DP_MARK_NOTIFY_FRAME_SUPPORT: mark notify frames capability
 */
enum cdp_capabilities {
	CDP_CFG_DP_TSO,
	CDP_CFG_DP_LRO,
	CDP_CFG_DP_SG,
	CDP_CFG_DP_GRO,
	CDP_CFG_DP_OL_TX_CSUM,
	CDP_CFG_DP_OL_RX_CSUM,
	CDP_CFG_DP_RAWMODE,
	CDP_CFG_DP_PEER_FLOW_CTRL,
	CDP_CFG_DP_MARK_NOTIFY_FRAME_SUPPORT,
};

/**
 * struct ol_txrx_nbuf_classify - Packet classification object
 * @peer_id: unique peer identifier from fw
 * @tid: traffic identifier(could be overridden)
 * @pkt_tid: traffic identifier(cannot be overridden)
 * @pkt_tos: ip header tos value
 * @pkt_dscp: ip header dscp value
 * @tos: index value in map
 * @dscp: DSCP_TID map index
 * @is_mcast: multicast pkt check
 * @is_eap: eapol pkt check
 * @is_arp: arp pkt check
 * @is_tcp: tcp pkt check
 * @is_dhcp: dhcp pkt check
 * @is_igmp: igmp pkt check
 * @is_ipv4: ip version 4 pkt check
 * @is_ipv6: ip version 6 pkt check
 */
struct ol_txrx_nbuf_classify {
	uint16_t peer_id;
	uint8_t tid;
	uint8_t pkt_tid;
	uint8_t pkt_tos;
	uint8_t pkt_dscp;
	uint8_t tos;
	uint8_t dscp;
	uint8_t is_mcast;
	uint8_t is_eap;
	uint8_t is_arp;
	uint8_t is_tcp;
	uint8_t is_dhcp;
	uint8_t is_igmp;
	uint8_t is_ipv4;
	uint8_t is_ipv6;
};

/*
 * typedef ol_osif_vdev_handle - opaque handle for OS shim virtual
 *                               device object
 */
struct ol_osif_vdev_t;
typedef struct ol_osif_vdev_t *ol_osif_vdev_handle;

#ifdef QCA_SUPPORT_WDS_EXTENDED
struct ol_osif_peer_t;
typedef struct ol_osif_peer_t *ol_osif_peer_handle;
#endif

/**
 * enum connectivity_stats_pkt_status - data pkt type
 * @PKT_TYPE_REQ: Request packet
 * @PKT_TYPE_RSP: Response packet
 * @PKT_TYPE_TX_DROPPED: TX packet dropped
 * @PKT_TYPE_RX_DROPPED: RX packet dropped
 * @PKT_TYPE_RX_DELIVERED: RX packet delivered
 * @PKT_TYPE_RX_REFUSED: RX packet refused
 * @PKT_TYPE_TX_HOST_FW_SENT: TX packet FW sent
 * @PKT_TYPE_TX_ACK_CNT:TC packet acked
 * @PKT_TYPE_NONE: Invalid packet
 */
enum connectivity_stats_pkt_status {
	PKT_TYPE_REQ,
	PKT_TYPE_RSP,
	PKT_TYPE_TX_DROPPED,
	PKT_TYPE_RX_DROPPED,
	PKT_TYPE_RX_DELIVERED,
	PKT_TYPE_RX_REFUSED,
	PKT_TYPE_TX_HOST_FW_SENT,
	PKT_TYPE_TX_ACK_CNT,
	PKT_TYPE_NONE,
};

/**
 * typedef ol_txrx_mgmt_tx_cb() - tx management delivery notification
 * callback function
 * @ctxt:
 * @tx_mgmt_frm:
 * @had_error:
 */
typedef void
(*ol_txrx_mgmt_tx_cb)(void *ctxt, qdf_nbuf_t tx_mgmt_frm, int had_error);

/**
 * typedef ol_txrx_data_tx_cb() - Function registered with the data path
 * that is called when tx frames marked as "no free" are
 * done being transmitted
 * @ctxt:
 * @tx_frm:
 * @had_error:
 */
typedef void
(*ol_txrx_data_tx_cb)(void *ctxt, qdf_nbuf_t tx_frm, int had_error);

/**
 * typedef ol_txrx_tx_fp() - top-level transmit function
 * @soc: dp soc handle
 * @vdev_id: handle to the virtual device object
 * @msdu_list: list of network buffers
 */
typedef qdf_nbuf_t (*ol_txrx_tx_fp)(struct cdp_soc_t *soc, uint8_t vdev_id,
				    qdf_nbuf_t msdu_list);

/**
 * typedef ol_txrx_tx_fast_fp() - top-level fast transmit function
 * @soc: dp soc handle
 * @vdev_id: handle to the virtual device object
 * @msdu_list: list of network buffers
 */
typedef qdf_nbuf_t (*ol_txrx_tx_fast_fp)(struct cdp_soc_t *soc, uint8_t vdev_id,
					 qdf_nbuf_t msdu_list);

/**
 * typedef ol_txrx_tx_exc_fp() - top-level transmit function on exception path
 * @soc: dp soc handle
 * @vdev_id: handle to the virtual device object
 * @msdu_list: list of network buffers
 * @tx_exc_metadata: structure that holds parameters to exception path
 */
typedef qdf_nbuf_t (*ol_txrx_tx_exc_fp)(struct cdp_soc_t *soc, uint8_t vdev_id,
					qdf_nbuf_t msdu_list,
					struct cdp_tx_exception_metadata
						*tx_exc_metadata);

/**
 * typedef ol_txrx_completion_fp() - top-level transmit function
 *                                   for tx completion
 * @skb: skb data
 * @osif_dev: the virtual device's OS shim object
 * @flag: flag
 */
typedef void (*ol_txrx_completion_fp)(qdf_nbuf_t skb,
				      void *osif_dev, uint16_t flag);

/**
 * typedef ol_txrx_classify_critical_pkt_fp() - classification cb for critical
 *                                              frames
 * @osif_dev: the virtual device's OS shim object
 * @skb: skb data
 */
typedef void (*ol_txrx_classify_critical_pkt_fp)(void *osif_dev,
						 qdf_nbuf_t skb);
/**
 * typedef ol_txrx_tx_flow_control_fp() - tx flow control notification
 *                                        function from txrx to OS shim
 * @osif_dev: the virtual device's OS shim object
 * @tx_resume: tx os q should be resumed or not
 */
typedef void (*ol_txrx_tx_flow_control_fp)(void *osif_dev,
					    bool tx_resume);

/**
 * typedef ol_txrx_tx_flow_control_is_pause_fp() - is tx paused by flow control
 *                                                 function from txrx to OS shim
 * @osif_dev: the virtual device's OS shim object
 *
 * Return: true if tx is paused by flow control
 */
typedef bool (*ol_txrx_tx_flow_control_is_pause_fp)(void *osif_dev);

/**
 * typedef ol_txrx_rx_fp() - receive function to hand batches of data
 *                           frames from txrx to OS shim
 * @osif_dev: handle to the OSIF virtual device object
 * @msdu_list: list of network buffers
 */
typedef QDF_STATUS(*ol_txrx_rx_fp)(void *osif_dev, qdf_nbuf_t msdu_list);

typedef QDF_STATUS(*ol_txrx_fisa_rx_fp)(void *soc,
					void *dp_vdev,
					qdf_nbuf_t msdu_list);

typedef QDF_STATUS(*ol_txrx_fisa_flush_fp)(void *soc, int ring_num);

/**
 * typedef ol_txrx_rx_flush_fp() - receive function to hand batches of
 *                                 data frames from txrx to OS shim
 * @osif_dev: handle to the OSIF virtual device object
 * @vdev_id: vdev_if of the packets to be flushed
 */
typedef QDF_STATUS(*ol_txrx_rx_flush_fp)(void *osif_dev, uint8_t vdev_id);

/**
 * typedef ol_txrx_rx_gro_flush_ind_fp() - function to send GRO flush
 *                                         indication to stack for a given
 *                                         RX Context Id.
 * @osif_dev: handle to the OSIF virtual device object
 * @rx_ctx_id: Rx context Id for which gro flush should happen
 */
typedef QDF_STATUS(*ol_txrx_rx_gro_flush_ind_fp)(void *osif_dev,
						 int rx_ctx_id);

/**
 * typedef ol_txrx_stats_rx_fp() - receive function to hand batches of
 *                                 data frames from txrx to OS shim
 * @skb: skb data
 * @osif_dev: the virtual device's OS shim object
 * @action: data packet type
 * @pkt_type: packet data type
 */
typedef void (*ol_txrx_stats_rx_fp)(struct sk_buff *skb,
		void *osif_dev, enum connectivity_stats_pkt_status action,
		uint8_t *pkt_type);

/**
 * typedef ol_txrx_get_key_fp() - function to gey key based on keyix
 *                                and peer mac address
 * @osif_dev: the virtual device's OS shim object
 * @key_buf: pointer to store key
 * @mac_addr: pointer to mac address
 * @keyix: key id
 */
typedef QDF_STATUS(*ol_txrx_get_key_fp)(void *osif_dev, uint8_t *key_buf,
					uint8_t *mac_addr, uint8_t keyix);

/**
 * typedef ol_txrx_rsim_rx_decap_fp() - raw mode simulation function
 *                                      to decap the packets in
 *                                      receive path.
 * @osif_dev: the virtual device's OS shim object
 * @list_head: pointer to head of receive packet queue to decap
 * @list_tail: pointer to tail of receive packet queue to decap
 * @peer_mac: mac address of peer handler
 */
typedef QDF_STATUS(*ol_txrx_rsim_rx_decap_fp)(void *osif_dev,
					      qdf_nbuf_t *list_head,
					      qdf_nbuf_t *list_tail);

/**
 * typedef ol_txrx_tx_free_ext_fp() - external tx free function to
 *                                    read per packet stats and free
 *                                    tx buffer externally
 * @netbuf: tx network buffer
 */
typedef void (*ol_txrx_tx_free_ext_fp)(qdf_nbuf_t netbuf);

/**
 * typedef ol_txrx_rx_check_wai_fp() - OSIF WAPI receive function
 * @vdev:
 * @mpdu_head:
 * @mpdu_tail:
 */
typedef bool (*ol_txrx_rx_check_wai_fp)(ol_osif_vdev_handle vdev,
					qdf_nbuf_t mpdu_head,
					qdf_nbuf_t mpdu_tail);
/**
 * typedef ol_txrx_rx_mon_fp() - OSIF monitor mode receive function for single
 *                               MPDU (802.11 format)
 * @vdev:
 * @mpdu:
 * @rx_status:
 */
typedef void (*ol_txrx_rx_mon_fp)(ol_osif_vdev_handle vdev,
				  qdf_nbuf_t mpdu,
				  void *rx_status);

/**
 * typedef ol_txrx_proxy_arp_fp() - proxy arp function pointer
 * @vdev:
 * @netbuf:
 */
typedef int (*ol_txrx_proxy_arp_fp)(ol_osif_vdev_handle vdev,
				    qdf_nbuf_t netbuf);

/**
 * typedef ol_txrx_mcast_me_fp() - function pointer for multicast enhancement
 * @vdev:
 * @netbuf:
 */
typedef int (*ol_txrx_mcast_me_fp)(ol_osif_vdev_handle vdev,
				   qdf_nbuf_t netbuf);

/**
 * typedef ol_txrx_stats_callback() - statistics notify callback
 * @ctxt:
 * @type:
 * @buf:
 * @bytes:
 */
typedef void (*ol_txrx_stats_callback)(void *ctxt,
				       enum htt_cmn_dbg_stats_type type,
				       uint8_t *buf, int bytes);

/**
 * typedef ol_txrx_pktdump_cb() - callback for packet dump feature
 * @soc:
 * @pdev_id:
 * @vdev_id:
 * @netbuf:
 * @status:
 * @type:
 */
typedef void (*ol_txrx_pktdump_cb)(ol_txrx_soc_handle soc,
				   uint8_t pdev_id,
				   uint8_t vdev_id,
				   qdf_nbuf_t netbuf,
				   enum qdf_dp_tx_rx_status status,
				   enum qdf_pkt_type type);

/**
 * typedef ol_txrx_get_tsf_time() - callback to get tsf time
 * @osif_dev:
 * @input_time:
 * @tsf_time:
 */
typedef QDF_STATUS(*ol_txrx_get_tsf_time)(void *osif_dev, uint64_t input_time,
					  uint64_t *tsf_time);

/**
 * struct ol_txrx_ops - (pointers to) the functions used for tx and rx
 * data xfer
 *
 * There are two portions of these txrx operations.
 * The rx portion is filled in by OSIF SW before calling
 * ol_txrx_osif_vdev_register; inside the ol_txrx_osif_vdev_register
 * the txrx SW stores a copy of these rx function pointers, to use
 * as it delivers rx data frames to the OSIF SW.
 * The tx portion is filled in by the txrx SW inside
 * ol_txrx_osif_vdev_register; when the function call returns,
 * the OSIF SW stores a copy of these tx functions to use as it
 * delivers tx data frames to the txrx SW.
 *
 * @tx: tx function pointers - specified by txrx, stored by OS shim
 * @tx.std:  the tx function pointer for standard data
 * frames This function pointer is set by the txrx SW
 * perform host-side transmit operations based on
 * whether a HL or LL host/target interface is in use.
 * @tx.flow_control_cb: the transmit flow control
 * function that is registered by the
 * OSIF which is called from txrx to
 * indicate whether the transmit OS
 * queues should be paused/resumed
 * @rx: rx function pointers - specified by OS shim, stored by txrx
 * @rx.rx: the OS shim rx function to deliver rx data
 * frames to. This can have different values for
 * different virtual devices, e.g. so one virtual
 * device's OS shim directly hands rx frames to the OS,
 * but another virtual device's OS shim filters out P2P
 * messages before sending the rx frames to the OS. The
 * netbufs delivered to the osif_rx function are in the
 * format specified by the OS to use for tx and rx
 * frames (either 802.3 or native WiFi). In case RX Threads are enabled, pkts
 * are given to the thread, instead of the stack via this pointer.
 * @rx.rx_eapol: This rx function pointer used to receive only eapol frames
 * @rx.stack: function to give packets to the stack. Differs from @rx.rx.
 * In case RX Threads are enabled, this pointer holds the callback to give
 * packets to the stack.
 * @rx.rx_gro_flush: GRO flush indication to stack for a given RX CTX ID
 * @rx.wai_check: the tx function pointer for WAPI frames
 * @rx.mon: the OS shim rx monitor function to deliver
 * monitor data to Though in practice, it is probable
 * that the same function will be used for delivering
 * rx monitor data for all virtual devices, in theory
 * each different virtual device can have a different
 * OS shim function for accepting rx monitor data. The
 * netbufs delivered to the osif_rx_mon function are in
 * 802.11 format.  Each netbuf holds a 802.11 MPDU, not
 * an 802.11 MSDU. Depending on compile-time
 * configuration, each netbuf may also have a
 * monitor-mode encapsulation header such as a radiotap
 * header added before the MPDU contents.
 * @rx.std: the OS shim rx function to deliver rx data
 * @proxy_arp: proxy arp function pointer - specified by
 * OS shim, stored by txrx
 * @me_convert:
 * @get_key: function pointer to get key of the peer with
 * specific key index
 * @get_tsf_time: function pointer to get TSF
 */
struct ol_txrx_ops {
	struct {
		ol_txrx_tx_fp         tx;
		ol_txrx_tx_fast_fp    tx_fast;
		ol_txrx_tx_exc_fp     tx_exception;
		ol_txrx_tx_free_ext_fp tx_free_ext;
		ol_txrx_completion_fp tx_comp;
		ol_txrx_classify_critical_pkt_fp tx_classify_critical_pkt_cb;
	} tx;

	struct {
		ol_txrx_rx_fp           rx;
#ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT
		ol_txrx_rx_fp     rx_eapol;
#endif
		ol_txrx_rx_fp           rx_stack;
		ol_txrx_rx_flush_fp     rx_flush;
		ol_txrx_rx_gro_flush_ind_fp           rx_gro_flush;
		ol_txrx_rx_check_wai_fp wai_check;
		ol_txrx_rx_mon_fp       mon;
		ol_txrx_stats_rx_fp           stats_rx;
		ol_txrx_rsim_rx_decap_fp rsim_rx_decap;
		ol_txrx_fisa_rx_fp	osif_fisa_rx;
		ol_txrx_fisa_flush_fp   osif_fisa_flush;
	} rx;
	/* proxy arp function pointer - specified by OS shim, stored by txrx */
	ol_txrx_proxy_arp_fp      proxy_arp;
	ol_txrx_mcast_me_fp          me_convert;

	ol_txrx_get_key_fp  get_key;
	ol_txrx_get_tsf_time get_tsf_time;
};

/**
 * struct ol_txrx_hardtart_ctxt - handlers for dp tx path
 * @tx: normal tx function
 * @tx_fast: fast tx function
 * @tx_exception: exception tx function
 */
struct ol_txrx_hardtart_ctxt {
	ol_txrx_tx_fp         tx;
	ol_txrx_tx_fast_fp    tx_fast;
	ol_txrx_tx_exc_fp     tx_exception;
};

/**
 * struct ol_txrx_stats_req - specifications of the requested
 *                            statistics
 * @stats_type_upload_mask: which stats to upload
 * @stats_type_reset_mask: which stats to reset
 * @print: control to print uploaded stats. stats will be printed if
 *         either print element is set
 * @print.verbose: verbose stats printout
 * @print.concise: concise stats printout (takes precedence)
 * @callback: callback context
 * @callback.fp: function pointer to call. stats notify callback will
 *               be invoked if fp is non-NULL
 * @callback.ctxt: opaque context to pass to callback function
 * @copy: copy context
 * @copy.buf: stats will be copied into the specified buffer if buf is
 *            non-NULL
 * @byte_limit: don't copy more than this
 * @wait: wait context
 * @wait.blocking: If true, the caller will take the specified
 *                 semaphore to wait for the stats to be uploaded, and
 *                 the driver will release the semaphore when the
 *                 stats are done being uploaded.
 * @wait.sem_ptr: Semaphore to use for blocking
 */
struct ol_txrx_stats_req {
	uint32_t stats_type_upload_mask;
	uint32_t stats_type_reset_mask;

	struct {
		int verbose;
		int concise;
	} print;

	struct {
		ol_txrx_stats_callback fp;
		void *ctxt;
	} callback;

	struct {
		uint8_t *buf;
		int byte_limit;
	} copy;

	struct {
		int blocking;
		qdf_semaphore_t *sem_ptr;
	} wait;
};


/* DP soc struct definition */
struct cdp_soc_t {
	struct cdp_ops *ops;
	struct ol_if_ops *ol_ops;
};

/**
 * enum cdp_peer_param_type - different types of parameters
 *			      to set values in peer
 * @CDP_CONFIG_NAWDS: Enable nawds mode
 * @CDP_CONFIG_NAC: Enable nac
 * @CDP_CONFIG_ISOLATION: Enable isolation
 * @CDP_CONFIG_IN_TWT: In TWT session or not
 */
enum cdp_peer_param_type {
	CDP_CONFIG_NAWDS,
	CDP_CONFIG_NAC,
	CDP_CONFIG_ISOLATION,
	CDP_CONFIG_IN_TWT,
};

/**
 * enum cdp_pdev_param_type - different types of parameters
 *			      to set values in pdev
 * @CDP_CONFIG_DEBUG_SNIFFER: Enable debug sniffer feature
 * @CDP_CONFIG_BPR_ENABLE: Enable bcast probe feature
 * @CDP_CONFIG_PRIMARY_RADIO: Configure radio as primary
 * @CDP_CONFIG_ENABLE_PERPKT_TXSTATS: Enable per packet statistics
 * @CDP_CONFIG_IGMPMLD_OVERRIDE: Override IGMP/MLD
 * @CDP_CONFIG_IGMPMLD_TID: Configurable TID value when igmmld_override is set
 * @CDP_CONFIG_ARP_DBG_CONF: Enable ARP debug
 * @CDP_CONFIG_CAPTURE_LATENCY: Capture time latency
 * @CDP_INGRESS_STATS: Accumulate ingress statistics
 * @CDP_OSIF_DROP: Accumulate drops in OSIF layer
 * @CDP_CONFIG_ENH_RX_CAPTURE: Enable enhanced RX capture
 * @CDP_CONFIG_ENH_TX_CAPTURE: Enable enhanced TX capture
 * @CDP_CONFIG_HMMC_TID_OVERRIDE: Enable hmmc tid override
 * @CDP_CONFIG_HMMC_TID_VALUE: set hmmc tid value
 * @CDP_CONFIG_TX_CAPTURE: set tx capture
 * @CDP_CHAN_NOISE_FLOOR: set channel noise floor
 * @CDP_CONFIG_VOW: set/get vow config
 * @CDP_TIDQ_OVERRIDE: set/get tid queue override
 * @CDP_TIDMAP_PRTY: set/get tid map prty
 * @CDP_TX_PENDING: get tx pending
 * @CDP_FILTER_NEIGH_PEERS: filter neighbour peers
 * @CDP_FILTER_UCAST_DATA: filter unicast data
 * @CDP_FILTER_MCAST_DATA: filter multicast data
 * @CDP_FILTER_NO_DATA: filter no data
 * @CDP_MONITOR_CHANNEL: monitor channel
 * @CDP_MONITOR_FREQUENCY: monitor frequency
 * @CDP_CONFIG_BSS_COLOR: configure bss color
 * @CDP_SET_ATF_STATS_ENABLE: set ATF stats flag
 * @CDP_CONFIG_SPECIAL_VAP: Configure Special vap
 * @CDP_RESET_SCAN_SPCL_VAP_STATS_ENABLE: Enable scan spcl vap stats reset
 * @CDP_CONFIG_ENHANCED_STATS_ENABLE:
 * @CDP_ISOLATION: set isolation flag
 * @CDP_CONFIG_UNDECODED_METADATA_CAPTURE_ENABLE: Undecoded metadata capture
 */
enum cdp_pdev_param_type {
	CDP_CONFIG_DEBUG_SNIFFER,
	CDP_CONFIG_BPR_ENABLE,
	CDP_CONFIG_PRIMARY_RADIO,
	CDP_CONFIG_ENABLE_PERPKT_TXSTATS,
	CDP_CONFIG_IGMPMLD_OVERRIDE,
	CDP_CONFIG_IGMPMLD_TID,
	CDP_CONFIG_ARP_DBG_CONF,
	CDP_CONFIG_CAPTURE_LATENCY,
	CDP_INGRESS_STATS,
	CDP_OSIF_DROP,
	CDP_CONFIG_ENH_RX_CAPTURE,
	CDP_CONFIG_ENH_TX_CAPTURE,
	CDP_CONFIG_HMMC_TID_OVERRIDE,
	CDP_CONFIG_HMMC_TID_VALUE,
	CDP_CONFIG_TX_CAPTURE,
	CDP_CHAN_NOISE_FLOOR,
	CDP_CONFIG_VOW,
	CDP_TIDQ_OVERRIDE,
	CDP_TIDMAP_PRTY,
	CDP_TX_PENDING,
	CDP_FILTER_NEIGH_PEERS,
	CDP_FILTER_UCAST_DATA,
	CDP_FILTER_MCAST_DATA,
	CDP_FILTER_NO_DATA,
	CDP_MONITOR_CHANNEL,
	CDP_MONITOR_FREQUENCY,
	CDP_CONFIG_BSS_COLOR,
	CDP_SET_ATF_STATS_ENABLE,
	CDP_CONFIG_SPECIAL_VAP,
	CDP_RESET_SCAN_SPCL_VAP_STATS_ENABLE,
	CDP_CONFIG_ENHANCED_STATS_ENABLE,
	CDP_ISOLATION,
	CDP_CONFIG_UNDECODED_METADATA_CAPTURE_ENABLE,
};

/**
 * typedef cdp_config_param_type - union of different types of parameters
 *			to set values into dp handles.
 *
 * @cdp_peer_param_nawds: Enable nawds mode
 * @cdp_peer_param_isolation: Enable isolation
 * @cdp_peer_param_in_twt: in TWT session or not
 * @cdp_peer_param_nac: Enable nac
 *
 * @cdp_vdev_param_nawds: set nawds enable/disable
 * @cdp_vdev_param_mcast_en: enable/disable multicast enhancement
 * @cdp_vdev_param_wds: wds sta
 * @cdp_vdev_param_mec: MEC enable flags
 * @cdp_vdev_param_proxysta: proxy sta
 * @cdp_vdev_param_tdls_flags: tdls link flags
 * @cdp_vdev_param_ap_brdg_en: set ap_bridging enable/disable
 * @cdp_vdev_param_cipher_en: set cipher type based on security
 * @cdp_vdev_param_qwrap_isolation: qwrap isolation mode
 * @cdp_vdev_param_tx_encap: tx encap type
 * @cdp_vdev_param_rx_decap: rx decap type
 * @cdp_vdev_param_mesh_rx_filter: set mesh rx filter
 * @cdp_vdev_param_tidmap_prty: set tid vdev prty
 * @cdp_vdev_param_tidmap_tbl_id: set tidmap table id
 * @cdp_vdev_param_mesh_mode: set mesh mode
 * @cdp_vdev_param_safe_mode: set safe mode
 * @cdp_vdev_param_drop_unenc: set drop unencrypted flag
 * @cdp_vdev_param_hlos_tid_override: set hlos tid override
 * @cdp_vdev_param_peer_authorize: set peer authorize
 * @cdp_vdev_param_peer_tid_latency_enable: set peer tid latency enable flag
 * @cdp_vdev_param_mesh_tid: config tatency tid on vdev
 * @cdp_vdev_param_dscp_tid_map_id: set dscp to tid map id
 * @cdp_vdev_param_mcast_vdev: set mcast vdev params
 * @cdp_vdev_param_wrap: qwrap ap vap
 *
 * @cdp_pdev_param_dbg_snf: Enable debug sniffer feature
 * @cdp_pdev_param_bpr_enable: Enable bcast probe feature
 * @cdp_pdev_param_primary_radio: Configure radio as primary
 * @cdp_pdev_param_en_perpkt_txstats: Enable per packet statistics
 * @cdp_pdev_param_igmpmld_override: Override IGMP/MLD
 * @cdp_pdev_param_igmpmld_tid: TID value when igmmld_override is set
 * @cdp_pdev_param_arp_dbg_conf: Enable ARP debug
 * @cdp_pdev_param_cptr_latcy: Capture time latency
 * @cdp_pdev_param_ingrs_stats: Accumulate ingress statistics
 * @cdp_pdev_param_osif_drop: Accumulate drops in OSIF layer
 * @cdp_pdev_param_en_rx_cap: Enable enhanced RX capture
 * @cdp_pdev_param_en_tx_cap: Enable enhanced TX capture
 * @cdp_pdev_param_hmmc_tid_ovrd: Enable hmmc tid override
 * @cdp_pdev_param_hmmc_tid: set hmmc tid value
 * @cdp_pdev_param_tx_capture: set tx capture
 * @cdp_pdev_param_chn_noise_flr: set channel noise floor
 * @cdp_pdev_param_cfg_vow: set/get vow config
 * @cdp_pdev_param_tidq_override: set/get tid queue override
 * @cdp_pdev_param_mon_freq: set monitor frequency
 * @cdp_pdev_param_bss_color: configure bss color
 * @cdp_pdev_param_tidmap_prty: set/get tid map prty
 * @cdp_pdev_param_tx_pending: get tx pending
 * @cdp_pdev_param_fltr_neigh_peers: filter neighbour peers
 * @cdp_pdev_param_fltr_ucast: filter unicast data
 * @cdp_pdev_param_fltr_mcast: filter multicast data
 * @cdp_pdev_param_fltr_none: filter no data
 * @cdp_pdev_param_monitor_chan: monitor channel
 * @cdp_pdev_param_atf_stats_enable: ATF stats enable
 * @cdp_pdev_param_config_special_vap: Configure Special vap
 * @cdp_pdev_param_isolation : set isolation mode
 *
 * @cdp_psoc_param_en_rate_stats: set rate stats enable/disable
 * @cdp_psoc_param_en_nss_cfg: set nss cfg
 * @cdp_psoc_param_ppeds_enabled: PPE-DS feature enable
 * @cdp_ipa_enabled : set ipa mode
 * @cdp_psoc_param_vdev_stats_hw_offload: Configure HW vdev stats offload
 * @cdp_pdev_param_undecoded_metadata_enable: Undecoded metadata capture enable
 * @cdp_sawf_enabled: SAWF enable/disable
 * @cdp_sawf_stats: SAWF stats config
 * @cdp_vdev_param_traffic_end_ind: Traffic end indication enable/disable
 * @cdp_skel_enable : Enable/Disable skeleton code for Umac reset debug
 * @cdp_drop_tx_mcast: Enable/Disable tx mcast drop
 * @cdp_vdev_tx_to_fw: Set to_fw bit for all tx packets for the vdev
 */
typedef union cdp_config_param_t {
	/* peer params */
	bool cdp_peer_param_nawds;
	bool cdp_peer_param_isolation;
	uint8_t cdp_peer_param_nac;
	bool cdp_peer_param_in_twt;

	/* vdev params */
	bool cdp_vdev_param_wds;
	bool cdp_vdev_param_mec;
	bool cdp_vdev_param_nawds;
	bool cdp_vdev_param_proxysta;
	bool cdp_vdev_param_tdls_flags;
	bool cdp_vdev_param_ap_brdg_en;
	bool cdp_vdev_param_qwrap_isolation;
	bool cdp_vdev_param_update_multipass;
	uint8_t cdp_vdev_param_da_war;
	uint8_t cdp_vdev_param_mcast_en;
	uint8_t cdp_vdev_param_igmp_mcast_en;
	uint8_t cdp_vdev_param_tidmap_prty;
	uint8_t cdp_vdev_param_tidmap_tbl_id;
	uint32_t cdp_vdev_param_aging_tmr;
	uint32_t cdp_vdev_param_cipher_en;
	uint32_t cdp_vdev_param_tx_encap;
	uint32_t cdp_vdev_param_rx_decap;
	uint32_t cdp_vdev_param_mesh_rx_filter;
	uint32_t cdp_vdev_param_mesh_mode;
	uint32_t cdp_vdev_param_safe_mode;
	uint32_t cdp_vdev_param_drop_unenc;
	uint8_t cdp_vdev_param_hlos_tid_override;
	bool cdp_vdev_param_wds_ext;
	uint8_t cdp_vdev_param_peer_authorize;
	uint8_t cdp_vdev_param_peer_tid_latency_enable;
	uint8_t cdp_vdev_param_mesh_tid;
	uint8_t cdp_vdev_param_dscp_tid_map_id;
	bool cdp_vdev_param_mcast_vdev;
	bool cdp_vdev_param_wrap;

	/* pdev params */
	bool cdp_pdev_param_cptr_latcy;
	bool cdp_pdev_param_hmmc_tid_ovrd;
	bool cdp_pdev_param_fltr_neigh_peers;
	bool cdp_pdev_param_cfg_vow;
	bool cdp_pdev_param_fltr_mcast;
	bool cdp_pdev_param_fltr_none;
	bool cdp_pdev_param_fltr_ucast;
	uint8_t cdp_pdev_param_primary_radio;
	uint8_t cdp_pdev_param_en_rx_cap;
	uint8_t cdp_pdev_param_en_tx_cap;
	uint8_t cdp_pdev_param_tx_capture;
	uint8_t cdp_pdev_param_hmmc_tid;
	uint8_t cdp_pdev_param_tidmap_prty;
	uint8_t cdp_pdev_param_igmpmld_override;
	uint8_t cdp_pdev_param_igmpmld_tid;
	uint8_t cdp_pdev_param_arp_dbg_conf;
	uint8_t cdp_pdev_param_tidq_override;
	uint8_t cdp_pdev_param_bss_color;
	uint16_t cdp_pdev_param_chn_noise_flr;
	qdf_freq_t cdp_pdev_param_mon_freq;
	int cdp_pdev_param_dbg_snf;
	int cdp_pdev_param_bpr_enable;
	int cdp_pdev_param_monitor_chan;
	uint32_t cdp_pdev_param_ingrs_stats;
	uint32_t cdp_pdev_param_osif_drop;
	uint32_t cdp_pdev_param_en_perpkt_txstats;
	uint32_t cdp_pdev_param_tx_pending;
	bool cdp_pdev_param_atf_stats_enable;
	bool cdp_pdev_param_config_special_vap;
	bool cdp_pdev_param_reset_scan_spcl_vap_stats_enable;
	bool cdp_pdev_param_enhanced_stats_enable;
	bool cdp_pdev_param_isolation;

	/* psoc params */
	bool cdp_psoc_param_en_rate_stats;
	int cdp_psoc_param_en_nss_cfg;
	int cdp_psoc_param_preferred_hw_mode;
	bool cdp_psoc_param_pext_stats;
	bool cdp_psoc_param_ppeds_enabled;

	bool cdp_skip_bar_update;
	bool cdp_ipa_enabled;
	bool cdp_psoc_param_vdev_stats_hw_offload;
	bool cdp_pdev_param_undecoded_metadata_enable;
	bool cdp_sawf_enabled;
	uint8_t cdp_sawf_stats;
	bool cdp_drop_3addr_mcast;
	bool cdp_vdev_param_traffic_end_ind;
	bool cdp_umac_rst_skel;
	bool cdp_drop_tx_mcast;
	bool cdp_vdev_tx_to_fw;
} cdp_config_param_type;

/**
 * enum cdp_rx_enh_capture_mode - Rx enhanced capture modes
 * @CDP_RX_ENH_CAPTURE_DISABLED: Disable Rx enhance capture
 * @CDP_RX_ENH_CAPTURE_MPDU: Enable capture of 128 bytes of each MPDU
 * @CDP_RX_ENH_CAPTURE_MPDU_MSDU: Enable capture of 128 bytes of each MSDU
 */
enum cdp_rx_enh_capture_mode {
	CDP_RX_ENH_CAPTURE_DISABLED = 0,
	CDP_RX_ENH_CAPTURE_MPDU,
	CDP_RX_ENH_CAPTURE_MPDU_MSDU,
};

/**
 * enum cdp_rx_enh_capture_peer - Rx enhanced capture peer filtering
 * @CDP_RX_ENH_CAPTURE_PEER_DISABLED: Disable Rx ENH capture peer filtering
 * @CDP_RX_ENH_CAPTURE_PEER_ENABLED: Enable Rx ENH capture peer filtering
 */
enum cdp_rx_enh_capture_peer {
	CDP_RX_ENH_CAPTURE_PEER_DISABLED = 0,
	CDP_RX_ENH_CAPTURE_PEER_ENABLED,
};

/**
 * enum cdp_tx_enh_capture_mode - Tx enhanced capture modes
 * @CDP_TX_ENH_CAPTURE_DISABLED: Disable Tx enhance capture for all peers
 * @CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS: Enable tx capture for all peers
 * @CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER: Enable/disable per peer as necessary
 * @CDP_TX_ENH_CAPTURE_MAX: Max value
 */
enum cdp_tx_enh_capture_mode {
	CDP_TX_ENH_CAPTURE_DISABLED = 0,
	CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS,
	CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER,
	CDP_TX_ENH_CAPTURE_MAX,
};

/**
 * enum cdp_pdev_bpr_param - different types of parameters
 *			     to set value in pdev
 * @CDP_BPR_DISABLE: Set bpr to disable state
 * @CDP_BPR_ENABLE: set bpr to enable state
 *
 * Enum indicating bpr state to enable/disable.
 */
enum cdp_pdev_bpr_param {
	CDP_BPR_DISABLE,
	CDP_BPR_ENABLE,
};

/**
 * enum cdp_vdev_param_type - different types of parameters
 *			      to set values in vdev
 * @CDP_ENABLE_NAWDS: set nawds enable/disable
 * @CDP_ENABLE_MCAST_EN: enable/disable multicast enhancement
 * @CDP_ENABLE_WDS: wds sta
 * @CDP_ENABLE_MEC: MEC enable flags
 * @CDP_ENABLE_DA_WAR:
 * @CDP_ENABLE_PROXYSTA: proxy sta
 * @CDP_UPDATE_TDLS_FLAGS: tdls link flags
 * @CDP_CFG_WDS_AGING_TIMER: modify/stop wds aging timer
 * @CDP_ENABLE_AP_BRIDGE: set ap_bridging enable/disable
 * @CDP_ENABLE_CIPHER: set cipher type based on security
 * @CDP_ENABLE_QWRAP_ISOLATION: qwrap isolation mode
 * @CDP_UPDATE_MULTIPASS: enable/disable multipass
 * @CDP_TX_ENCAP_TYPE: tx encap type
 * @CDP_RX_DECAP_TYPE: rx decap type
 * @CDP_MESH_RX_FILTER: set mesh rx filter
 * @CDP_TID_VDEV_PRTY: set tid vdev prty
 * @CDP_TIDMAP_TBL_ID: set tidmap table id
 * @CDP_MESH_MODE: set mesh mode
 * @CDP_SAFEMODE: set safe mode
 * @CDP_DROP_UNENC: set drop unencrypted flag
 * @CDP_ENABLE_IGMP_MCAST_EN: enable/disable igmp multicast enhancement
 * @CDP_ENABLE_HLOS_TID_OVERRIDE: set hlos tid override flag
 * @CDP_CFG_WDS_EXT: enable/disable wds ext feature
 * @CDP_DROP_TX_MCAST: enable/disable tx mcast drop
 * @CDP_ENABLE_PEER_AUTHORIZE: enable peer authorize flag
 * @CDP_ENABLE_PEER_TID_LATENCY: set peer tid latency enable flag
 * @CDP_SET_VAP_MESH_TID: Set latency tid in vap
 * @CDP_SKIP_BAR_UPDATE_AP: enable/disable bar
 * @CDP_UPDATE_DSCP_TO_TID_MAP: Set DSCP to TID map id
 * @CDP_SET_MCAST_VDEV: Set primary mcast vdev
 * @CDP_RESET_MLO_MCAST_VDEV: Reset mlo mcast vdev settings
 * @CDP_SET_MCAST_VDEV_HW_UPDATE: Not in use
 * @CDP_DROP_3ADDR_MCAST: enable/disable drop 3addr multicast flag
 * @CDP_ENABLE_WRAP: qwrap ap
 * @CDP_ENABLE_TRAFFIC_END_INDICATION: enable/disable traffic end indication
 * @CDP_VDEV_TX_TO_FW: Set to_fw bit for tx packets for the vdev
 */
enum cdp_vdev_param_type {
	CDP_ENABLE_NAWDS,
	CDP_ENABLE_MCAST_EN,
	CDP_ENABLE_WDS,
	CDP_ENABLE_MEC,
	CDP_ENABLE_DA_WAR,
	CDP_ENABLE_PROXYSTA,
	CDP_UPDATE_TDLS_FLAGS,
	CDP_CFG_WDS_AGING_TIMER,
	CDP_ENABLE_AP_BRIDGE,
	CDP_ENABLE_CIPHER,
	CDP_ENABLE_QWRAP_ISOLATION,
	CDP_UPDATE_MULTIPASS,
	CDP_TX_ENCAP_TYPE,
	CDP_RX_DECAP_TYPE,
	CDP_MESH_RX_FILTER,
	CDP_TID_VDEV_PRTY,
	CDP_TIDMAP_TBL_ID,
#ifdef MESH_MODE_SUPPORT
	CDP_MESH_MODE,
#endif
	CDP_SAFEMODE,
	CDP_DROP_UNENC,
	CDP_ENABLE_IGMP_MCAST_EN,
	CDP_ENABLE_HLOS_TID_OVERRIDE,
#ifdef QCA_SUPPORT_WDS_EXTENDED
	CDP_CFG_WDS_EXT,
	CDP_DROP_TX_MCAST,
#endif /* QCA_SUPPORT_WDS_EXTENDED */
	CDP_ENABLE_PEER_AUTHORIZE,
#ifdef WLAN_SUPPORT_MESH_LATENCY
	CDP_ENABLE_PEER_TID_LATENCY,
	CDP_SET_VAP_MESH_TID,
#endif
#ifdef WLAN_VENDOR_SPECIFIC_BAR_UPDATE
	CDP_SKIP_BAR_UPDATE_AP,
#endif
	CDP_UPDATE_DSCP_TO_TID_MAP,
	CDP_SET_MCAST_VDEV,
	CDP_RESET_MLO_MCAST_VDEV,
	CDP_SET_MCAST_VDEV_HW_UPDATE,
	CDP_DROP_3ADDR_MCAST,
	CDP_ENABLE_WRAP,
#ifdef DP_TRAFFIC_END_INDICATION
	CDP_ENABLE_TRAFFIC_END_INDICATION,
#endif
#ifdef FEATURE_DIRECT_LINK
	CDP_VDEV_TX_TO_FW,
#endif
};

/**
 * enum cdp_psoc_param_type - different types of parameters
 *			      to set values in psoc
 * @CDP_ENABLE_RATE_STATS: set rate stats enable/disable
 * @CDP_SET_NSS_CFG: set nss cfg
 * @CDP_SET_PREFERRED_HW_MODE: set preferred hw mode
 * @CDP_CFG_PEER_EXT_STATS: Peer extended stats mode.
 * @CDP_IPA_ENABLE : set IPA enable mode.
 * @CDP_CFG_VDEV_STATS_HW_OFFLOAD: HW Vdev stats config
 * @CDP_SAWF_ENABLE:
 * @CDP_UMAC_RST_SKEL_ENABLE: Enable Umac reset skeleton code for debug
 * @CDP_PPEDS_ENABLE: PPEDS is enabled or not
 * @CDP_SAWF_STATS: set SAWF stats config
 */
enum cdp_psoc_param_type {
	CDP_ENABLE_RATE_STATS,
	CDP_SET_NSS_CFG,
	CDP_SET_PREFERRED_HW_MODE,
	CDP_CFG_PEER_EXT_STATS,
	CDP_IPA_ENABLE,
	CDP_CFG_VDEV_STATS_HW_OFFLOAD,
	CDP_SAWF_ENABLE,
	CDP_UMAC_RST_SKEL_ENABLE,
	CDP_PPEDS_ENABLE,
	CDP_SAWF_STATS,
};

#define TXRX_FW_STATS_TXSTATS                     1
#define TXRX_FW_STATS_RXSTATS                     2
#define TXRX_FW_STATS_RX_RATE_INFO                3
#define TXRX_FW_STATS_PHYSTATS                    4
#define TXRX_FW_STATS_PHYSTATS_CONCISE            5
#define TXRX_FW_STATS_TX_RATE_INFO                6
#define TXRX_FW_STATS_TID_STATE                   7
#define TXRX_FW_STATS_HOST_STATS                  8
#define TXRX_FW_STATS_CLEAR_HOST_STATS            9
#define TXRX_FW_STATS_CE_STATS                   10
#define TXRX_FW_STATS_VOW_UMAC_COUNTER           11
#define TXRX_FW_STATS_ME_STATS                   12
#define TXRX_FW_STATS_TXBF_INFO                  13
#define TXRX_FW_STATS_SND_INFO                   14
#define TXRX_FW_STATS_ERROR_INFO                 15
#define TXRX_FW_STATS_TX_SELFGEN_INFO            16
#define TXRX_FW_STATS_TX_MU_INFO                 17
#define TXRX_FW_SIFS_RESP_INFO                   18
#define TXRX_FW_RESET_STATS                      19
#define TXRX_FW_MAC_WDOG_STATS                   20
#define TXRX_FW_MAC_DESC_STATS                   21
#define TXRX_FW_MAC_FETCH_MGR_STATS              22
#define TXRX_FW_MAC_PREFETCH_MGR_STATS           23
#define TXRX_FW_STATS_DURATION_INFO              24
#define TXRX_FW_STATS_DURATION_INFO_RESET        25
#define TXRX_FW_HALPHY_STATS                     26
#define TXRX_FW_COEX_STATS                       27

#define PER_RADIO_FW_STATS_REQUEST 0
#define PER_VDEV_FW_STATS_REQUEST 1
/**
 * enum data_stall_log_event_indicator - Module triggering data stall
 * @DATA_STALL_LOG_INDICATOR_UNUSED: Unused
 * @DATA_STALL_LOG_INDICATOR_HOST_DRIVER: Host driver indicates data stall
 * @DATA_STALL_LOG_INDICATOR_FIRMWARE: FW indicates data stall
 * @DATA_STALL_LOG_INDICATOR_FRAMEWORK: Framework indicates data stall
 *
 * Enum indicating the module that indicates data stall event
 */
enum data_stall_log_event_indicator {
	DATA_STALL_LOG_INDICATOR_UNUSED,
	DATA_STALL_LOG_INDICATOR_HOST_DRIVER,
	DATA_STALL_LOG_INDICATOR_FIRMWARE,
	DATA_STALL_LOG_INDICATOR_FRAMEWORK,
};

/**
 * enum data_stall_log_event_type - data stall event type
 * @DATA_STALL_LOG_NONE:
 * @DATA_STALL_LOG_FW_VDEV_PAUSE:
 * @DATA_STALL_LOG_HWSCHED_CMD_FILTER:
 * @DATA_STALL_LOG_HWSCHED_CMD_FLUSH:
 * @DATA_STALL_LOG_FW_RX_REFILL_FAILED:
 * @DATA_STALL_LOG_FW_RX_FCS_LEN_ERROR:
 * @DATA_STALL_LOG_FW_WDOG_ERRORS:
 * @DATA_STALL_LOG_BB_WDOG_ERROR:
 * @DATA_STALL_LOG_POST_TIM_NO_TXRX_ERROR:
 * @DATA_STALL_LOG_HOST_STA_TX_TIMEOUT:
 * @DATA_STALL_LOG_HOST_SOFTAP_TX_TIMEOUT:
 * @DATA_STALL_LOG_NUD_FAILURE:
 *
 * Enum indicating data stall event type
 */
enum data_stall_log_event_type {
	DATA_STALL_LOG_NONE,
	DATA_STALL_LOG_FW_VDEV_PAUSE,
	DATA_STALL_LOG_HWSCHED_CMD_FILTER,
	DATA_STALL_LOG_HWSCHED_CMD_FLUSH,
	DATA_STALL_LOG_FW_RX_REFILL_FAILED,
	DATA_STALL_LOG_FW_RX_FCS_LEN_ERROR,
	DATA_STALL_LOG_FW_WDOG_ERRORS,
	DATA_STALL_LOG_BB_WDOG_ERROR,
	DATA_STALL_LOG_POST_TIM_NO_TXRX_ERROR,
	/* Stall events triggered by host/framework start from 0x100 onwards. */
	DATA_STALL_LOG_HOST_STA_TX_TIMEOUT = 0x100,
	DATA_STALL_LOG_HOST_SOFTAP_TX_TIMEOUT,
	DATA_STALL_LOG_NUD_FAILURE,
};

/**
 * enum data_stall_log_recovery_type - data stall recovery type
 * @DATA_STALL_LOG_RECOVERY_NONE:
 * @DATA_STALL_LOG_RECOVERY_CONNECT_DISCONNECT:
 * @DATA_STALL_LOG_RECOVERY_TRIGGER_PDR:
 *
 * Enum indicating data stall recovery type
 */
enum data_stall_log_recovery_type {
	DATA_STALL_LOG_RECOVERY_NONE = 0,
	DATA_STALL_LOG_RECOVERY_CONNECT_DISCONNECT,
	DATA_STALL_LOG_RECOVERY_TRIGGER_PDR,
};

/**
 * struct data_stall_event_info - data stall info
 * @indicator: Module triggering data stall
 * @data_stall_type: data stall event type
 * @vdev_id_bitmap: vdev_id_bitmap
 * @pdev_id: pdev id
 * @recovery_type: data stall recovery type
 */
struct data_stall_event_info {
	uint32_t indicator;
	uint32_t data_stall_type;
	uint32_t vdev_id_bitmap;
	uint32_t pdev_id;
	uint32_t recovery_type;
};

typedef void (*data_stall_detect_cb)(struct data_stall_event_info *);

/**
 * enum cdp_stats - options for host and firmware statistics
 * @CDP_TXRX_STATS_0:
 * @CDP_TXRX_STATS_1: HTT Pdev tx stats
 * @CDP_TXRX_STATS_2: HTT Pdev rx stats
 * @CDP_TXRX_STATS_3: HTT Pdev Tx HW Queue stats
 * @CDP_TXRX_STATS_4: HTT Pdev Tx HW Sched stats
 * @CDP_TXRX_STATS_5: HTT Pdev error stats
 * @CDP_TXRX_STATS_6: HTT TQM stats
 * @CDP_TXRX_STATS_7: HTT TQM CMDQ stats
 * @CDP_TXRX_STATS_8: HTT Tx_de_cmn thread stats
 * @CDP_TXRX_STATS_9: HTT Pdev Tx rate stats
 * @CDP_TXRX_STATS_10: HTT Pdev Rx rate stats
 * @CDP_TXRX_STATS_11: HTT Peer stats
 * @CDP_TXRX_STATS_12: HTT Tx Self Gen Info
 * @CDP_TXRX_STATS_13: HTT Tx MU HWQ stats
 * @CDP_TXRX_STATS_14: HTT Ring interface info stats
 * @CDP_TXRX_STATS_15: HTT SRNG info stats
 * @CDP_TXRX_STATS_16: HTT SFM info stats
 * @CDP_TXRX_STATS_17: HTT Pdev tx mu mimo sched info
 * @CDP_TXRX_STATS_18: HTT Peer list details
 * @CDP_TXRX_STATS_19: Reserved
 * @CDP_TXRX_STATS_20: Reset Host stats
 * @CDP_TXRX_STATS_21: Host Rx rate stats
 * @CDP_TXRX_STATS_22: Host Tx rate stats
 * @CDP_TXRX_STATS_23: Host Tx stats
 * @CDP_TXRX_STATS_24: Host Rx stats
 * @CDP_TXRX_STATS_25: Host Ast stats
 * @CDP_TXRX_STATS_26: Host Head/Tail Pointer stats
 * @CDP_TXRX_STATS_27: Host Monitor mode stats
 * @CDP_TXRX_STATS_28: Host Peer entry stats
 * @CDP_TXRX_STATS_29: Host Soc config params info
 * @CDP_TXRX_STATS_30: Host Pdev config params info
 * @CDP_TXRX_STATS_31: Host DP Interrupt Stats
 * @CDP_TXRX_STATS_HTT_MAX:
 * @CDP_TXRX_MAX_STATS:
 */
enum cdp_stats {
	CDP_TXRX_STATS_0  = 0,
	CDP_TXRX_STATS_1,
	CDP_TXRX_STATS_2,
	CDP_TXRX_STATS_3,
	CDP_TXRX_STATS_4,
	CDP_TXRX_STATS_5,
	CDP_TXRX_STATS_6,
	CDP_TXRX_STATS_7,
	CDP_TXRX_STATS_8,
	CDP_TXRX_STATS_9,
	CDP_TXRX_STATS_10,
	CDP_TXRX_STATS_11,
	CDP_TXRX_STATS_12,
	CDP_TXRX_STATS_13,
	CDP_TXRX_STATS_14,
	CDP_TXRX_STATS_15,
	CDP_TXRX_STATS_16,
	CDP_TXRX_STATS_17,
	CDP_TXRX_STATS_18,
	CDP_TXRX_STATS_19,
	CDP_TXRX_STATS_20,
	CDP_TXRX_STATS_21,
	CDP_TXRX_STATS_22,
	CDP_TXRX_STATS_23,
	CDP_TXRX_STATS_24,
	CDP_TXRX_STATS_25,
	CDP_TXRX_STATS_26,
	CDP_TXRX_STATS_27,
	CDP_TXRX_STATS_28,
	CDP_TXRX_STATS_29,
	CDP_TXRX_STATS_30,
	CDP_TXRX_STATS_31,
	CDP_TXRX_STATS_HTT_MAX = 256,
	CDP_TXRX_MAX_STATS = 265,
};

/**
 * enum cdp_stat_update_type - Different Stat update types sent to
 *                             OL_IF
 * @UPDATE_PEER_STATS: update peer stats
 * @UPDATE_VDEV_STATS: update vdev stats
 * @UPDATE_PDEV_STATS: Update pdev stats
 */
enum cdp_stat_update_type {
	UPDATE_PEER_STATS = 0,
	UPDATE_VDEV_STATS = 1,
	UPDATE_PDEV_STATS = 2,
};

/**
 * struct cdp_tx_sojourn_stats - Tx sojourn stats
 * @ppdu_seq_id: ppdu_seq_id from tx completion
 * @avg_sojourn_msdu: average sojourn msdu time
 * @sum_sojourn_msdu: sum sojourn msdu time
 * @num_msdus: number of msdus per ppdu
 * @cookie: cookie to be used by upper layer
 */
struct cdp_tx_sojourn_stats {
	uint32_t ppdu_seq_id;
	qdf_ewma_tx_lag avg_sojourn_msdu[CDP_DATA_TID_MAX];
	uint32_t sum_sojourn_msdu[CDP_DATA_TID_MAX];
	uint32_t num_msdus[CDP_DATA_TID_MAX];
	struct cdp_stats_cookie *cookie;
};

/**
 * struct cdp_delayed_tx_completion_ppdu_user - Delayed Tx PPDU completion
 *                                              per-user information
 * @frame_ctrl: frame control field in 802.11 header
 * @qos_ctrl: QoS control field in 802.11 header
 * @mpdu_tried_ucast: number of unicast mpdus tried
 * @mpdu_tried_mcast: number of multicastmpdus tried
 * @ltf_size: ltf_size
 * @stbc: stbc
 * @he_re: he_re (range extension)
 * @txbf: txbf
 * @bw: Transmission bandwidth
 *       <enum 2 transmit_bw_20_MHz>
 *       <enum 3 transmit_bw_40_MHz>
 *       <enum 4 transmit_bw_80_MHz>
 *       <enum 5 transmit_bw_160_MHz>
 * @nss: NSS 1,2, ...8
 * @mcs: MCS index
 * @preamble: preamble
 * @gi: guard interval 800/400/1600/3200 ns
 * @dcm: dcm
 * @ldpc: ldpc
 * @delayed_ba:
 * @ru_start: RU start index
 * @ru_tones: RU tones length
 * @is_mcast: MCAST or UCAST
 * @user_pos: user position
 * @mu_group_id: mu group id
 * @ppdu_start_timestamp: 64 bits ppdu start timestamp
 * @ppdu_end_timestamp: 64 bits ppdu end timestamp
 */
struct cdp_delayed_tx_completion_ppdu_user {
	uint32_t frame_ctrl:16,
		 qos_ctrl:16;
	uint32_t mpdu_tried_ucast:16,
		mpdu_tried_mcast:16;
	uint32_t ltf_size:2,
		 stbc:1,
		 he_re:1,
		 txbf:4,
		 bw:4,
		 nss:4,
		 mcs:4,
		 preamble:4,
		 gi:4,
		 dcm:1,
		 ldpc:1,
		 delayed_ba:1;
	uint16_t ru_start;
	uint16_t ru_tones;
	bool is_mcast;
	uint32_t user_pos;
	uint32_t mu_group_id;
	uint64_t ppdu_start_timestamp;
	uint64_t ppdu_end_timestamp;
};

/**
 * struct cdp_tx_completion_ppdu_user - Tx PPDU completion per-user information
 * @completion_status: completion status - OK/Filter/Abort/Timeout
 * @tid: TID number
 * @peer_id: Peer ID
 * @mac_addr:
 * @ba_size: Block-Ack size
 * @frame_ctrl: frame control field in 802.11 header
 * @qos_ctrl: QoS control field in 802.11 header
 * @mpdu_tried_ucast: number of unicast mpdus tried
 * @mpdu_tried_mcast: number of multicast mpdus tried
 * @mpdu_success: number of mpdus successfully transmitted
 * @mpdu_failed:
 * @long_retries: long retries
 * @short_retries: short retries
 * @tx_ratecode:
 * @is_ampdu: mpdu aggregate or non-aggregate?
 * @ppdu_type:
 * @pream_punct:
 * @is_seq_num_valid:
 * @success_bytes: bytes successfully transmitted
 * @retry_bytes: bytes retried
 * @failed_bytes:
 * @success_msdus: MSDUs successfully transmitted
 * @retry_msdus: MSDUs retried
 * @retry_mpdus: MPDUs retried
 * @failed_msdus: MSDUs failed transmission
 * @duration: user duration in ppdu
 * @ltf_size: ltf_size
 * @stbc: stbc
 * @he_re: he_re (range extension)
 * @txbf: txbf
 * @bw: Transmission bandwidth
 *       <enum 2 transmit_bw_20_MHz>
 *       <enum 3 transmit_bw_40_MHz>
 *       <enum 4 transmit_bw_80_MHz>
 *       <enum 5 transmit_bw_160_MHz>
 * @nss: NSS 1,2, ...8
 * @mcs: MCS index
 * @preamble: preamble
 * @gi: guard interval 800/400/1600/3200 ns
 * @dcm: dcm
 * @ldpc: ldpc
 * @delayed_ba: delayed ba bit
 * @ack_ba_tlv: ack ba recv tlv bit
 * @ba_seq_no: Block Ack sequence number
 * @ba_bitmap: Block Ack bitmap
 * @start_seq: Sequence number of first MPDU
 * @enq_bitmap: Enqueue MPDU bitmap
 * @failed_bitmap:
 * @num_mpdu:
 * @num_msdu:
 * @tx_duration:
 * @ru_start: RU start index
 * @ru_tones: RU tones length
 * @is_mcast: MCAST or UCAST
 * @tx_rate: Transmission Rate
 * @tx_ratekbps:
 * @ack_rssi: ack rssi for separate chains
 * @ack_rssi_valid:
 * @usr_ack_rssi:
 * @user_pos: user position
 * @mu_group_id: mu group id
 * @rix: rate index
 * @is_ppdu_cookie_valid : Indicates that ppdu_cookie is valid
 * @ppdu_cookie: 16-bit ppdu_cookie
 * @sa_is_training: smart antenna training packets indication
 * @rssi_chain: rssi chain per bandwidth
 * @sa_tx_antenna: antenna in which packet is transmitted
 * @sa_max_rates: smart antenna tx feedback info max rates
 * @sa_goodput: smart antenna tx feedback info goodput
 * @current_rate_per: Moving average per
 * @last_enq_seq: last equeue sequence number
 * @is_bss_peer: is bss peer check
 * @mpdu_q: queue of mpdu in a ppdu
 * @mpdus: MPDU list based on enqueue sequence bitmap
 * @pending_retries: pending MPDUs (retries)
 * @tlv_bitmap: per user tlv bitmap
 * @skip: tx capture skip flag
 * @mon_procd: to indicate user processed in ppdu of the sched cmd
 * @debug_copied: flag to indicate bar frame copied
 * @peer_last_delayed_ba: flag to indicate peer last delayed ba
 * @phy_tx_time_us: Phy TX duration for the User
 * @mpdu_bytes: accumulated bytes per mpdu for mem limit feature
 * @punc_mode: puncutured mode to indicate punctured bw
 * @punc_pattern_bitmap: bitmap indicating punctured pattern
 * @mprot_type: medium protection type
 * @rts_success: rts success
 * @rts_failure: rts failure
 */
struct cdp_tx_completion_ppdu_user {
	uint32_t completion_status:8,
		 tid:8,
		 peer_id:16;
	uint8_t mac_addr[6];
	uint16_t ba_size;
	uint32_t frame_ctrl:16,
		 qos_ctrl:16;
	uint32_t mpdu_tried_ucast:16,
		mpdu_tried_mcast:16;
	uint16_t mpdu_success:16;
	uint16_t mpdu_failed:16;
	uint32_t long_retries:4,
		 short_retries:4,
		 tx_ratecode:16,
		 is_ampdu:1,
		 ppdu_type:5,
		 pream_punct:1,
		 is_seq_num_valid:1;
	uint32_t success_bytes;
	uint32_t retry_bytes;
	uint32_t failed_bytes;
	uint32_t success_msdus:16,
		 retry_msdus:16;
	uint32_t retry_mpdus;
	uint32_t failed_msdus:16,
		 duration:16;
	uint32_t ltf_size:2,
		 stbc:1,
		 he_re:1,
		 txbf:4,
		 bw:4,
		 nss:4,
		 mcs:4,
		 preamble:4,
		 gi:4,
		 dcm:1,
		 ldpc:1,
		 delayed_ba:1,
		 ack_ba_tlv:1;
	uint32_t ba_seq_no;
	uint32_t ba_bitmap[CDP_BA_256_BIT_MAP_SIZE_DWORDS];
	uint32_t start_seq;
	uint32_t enq_bitmap[CDP_BA_256_BIT_MAP_SIZE_DWORDS];
	uint32_t failed_bitmap[CDP_BA_256_BIT_MAP_SIZE_DWORDS];
	uint32_t num_mpdu:9,
		 num_msdu:16;
	uint32_t tx_duration;
	uint16_t ru_start;
	uint16_t ru_tones;
	bool is_mcast;
	uint32_t tx_rate;
	uint32_t tx_ratekbps;
	uint32_t ack_rssi[CDP_RSSI_CHAIN_LEN];
	bool ack_rssi_valid;
	uint32_t usr_ack_rssi;
	uint32_t user_pos;
	uint32_t mu_group_id;
	uint32_t rix;
	uint8_t is_ppdu_cookie_valid;
	uint16_t ppdu_cookie;
	uint8_t sa_is_training;
	uint32_t rssi_chain[CDP_RSSI_CHAIN_LEN];
	uint32_t sa_tx_antenna;
	/*Max rates for BW: 20MHZ, 40MHZ and 80MHZ and 160MHZ
	 * |---------------------------------------|
	 * | 16 bits | 16 bits | 16 bits | 16 bits |
	 * |   BW-1  |   BW-2  |   BW-3  |   BW-4  |
	 * |      /\  \                            |
	 * |     /  \  \                           |
	 * |    /    \  \                          |
	 * |   /      \  \                         |
	 * |  /        \  \                        |
	 * | /          \  \                       |
	 * |/            \  \                      |
	 * |[11|8]     [5|8] \                     |
	 * | BW1      PADDED  \                    |
	 * |---------------------------------------|
	 */
	uint16_t sa_max_rates[CDP_NUM_SA_BW];
	uint32_t sa_goodput;
	/* below field is used to calculate goodput in non-training period
	 * Note: As host is exposing goodput and hence current_rate_per is
	 * of no use. It is just for Host computation.
	 */
	uint32_t current_rate_per;
	uint32_t last_enq_seq;

	uint8_t is_bss_peer;

	qdf_nbuf_queue_t mpdu_q;
	qdf_nbuf_t *mpdus;
	uint32_t pending_retries;
	uint32_t tlv_bitmap;
	bool skip;
	bool mon_procd;
	bool debug_copied;
	bool peer_last_delayed_ba;

	uint16_t phy_tx_time_us;
	uint32_t mpdu_bytes;
	uint8_t punc_mode;
	uint16_t punc_pattern_bitmap;
	uint8_t mprot_type:3,
		rts_success:1,
		rts_failure:1;
};

/**
 * struct cdp_tx_indication_mpdu_info - Tx MPDU completion information
 * @ppdu_id: PPDU id
 * @tx_duration: user duration in ppdu
 * @frame_type: frame type MGMT/CTRL/DATA/BAR
 * @frame_ctrl: frame control field in 802.11 header
 * @qos_ctrl: QoS control field in 802.11 header
 * @tid: TID number
 * @num_msdu: number of msdu in MPDU
 * @seq_no: Sequence number of first MPDU
 * @ltf_size: ltf_size
 * @he_re: he_re (range extension)
 * @txbf: txbf
 * @bw: Transmission bandwidth
 *       <enum 2 transmit_bw_20_MHz>
 *       <enum 3 transmit_bw_40_MHz>
 *       <enum 4 transmit_bw_80_MHz>
 *       <enum 5 transmit_bw_160_MHz>
 * @nss: NSS 1,2, ...8
 * @mcs: MCS index
 * @preamble: preamble
 * @gi: guard interval 800/400/1600/3200 ns
 * @channel: frequency
 * @channel_num: channel number
 * @ack_rssi: ack rssi
 * @ldpc: ldpc
 * @tx_rate: Transmission Rate
 * @mac_address: peer mac address
 * @bss_mac_address: bss mac address
 * @ppdu_start_timestamp: TSF at PPDU start
 * @ppdu_end_timestamp: TSF at PPDU end
 * @ba_start_seq: Block Ack sequence number
 * @ba_bitmap: Block Ack bitmap
 * @ppdu_cookie: 16-bit ppdu_cookie
 * @long_retries: long retries
 * @short_retries: short retries
 * @completion_status: completion status - OK/Filter/Abort/Timeout
 * @resp_type: response type
 * @mprot_type: medium protection type
 * @rts_success: rts success
 * @rts_failure: rts failure
 * @usr_idx: user index
 */
struct cdp_tx_indication_mpdu_info {
	uint32_t ppdu_id;
	uint32_t tx_duration;
	uint16_t frame_type;
	uint16_t frame_ctrl;
	uint16_t qos_ctrl;
	uint8_t tid;
	uint32_t num_msdu;
	uint32_t seq_no;
	uint32_t ltf_size:2,
		 he_re:1,
		 txbf:4,
		 bw:4,
		 nss:4,
		 mcs:4,
		 preamble:4,
		 gi:4;
	uint32_t channel;
	uint8_t channel_num;
	uint32_t ack_rssi;
	uint32_t ldpc;
	uint32_t tx_rate;
	uint8_t mac_address[QDF_MAC_ADDR_SIZE];
	uint8_t bss_mac_address[QDF_MAC_ADDR_SIZE];
	uint64_t ppdu_start_timestamp;
	uint64_t ppdu_end_timestamp;
	uint32_t ba_start_seq;
	uint32_t ba_bitmap[CDP_BA_256_BIT_MAP_SIZE_DWORDS];
	uint16_t ppdu_cookie;
	uint16_t long_retries:4,
		 short_retries:4,
		 completion_status:8;
	uint16_t resp_type:4,
		 mprot_type:3,
		 rts_success:1,
		 rts_failure:1;
	uint8_t usr_idx;
};

/**
 * struct cdp_tx_indication_info - Tx capture information
 * @radiotap_done: Flag to say radiotap already done or not
 *			0 - radiotap not updated
 *			1 - radiotap header updated
 * @mpdu_info: Tx MPDU completion information
 * @mpdu_nbuf: reconstructed mpdu packet
 * @ppdu_desc: tx completion ppdu
 * @osif_vdev: OS IF vdev handle
 */
struct cdp_tx_indication_info {
	bool radiotap_done;
	struct cdp_tx_indication_mpdu_info mpdu_info;
	qdf_nbuf_t mpdu_nbuf;
	struct cdp_tx_completion_ppdu *ppdu_desc;
#ifdef QCA_SUPPORT_LITE_MONITOR
	ol_osif_vdev_handle osif_vdev;
#endif
};

/**
 * struct cdp_tx_mgmt_comp_info - Tx mgmt comp info
 * @ppdu_id: ppdu_id
 * @is_sgen_pkt: payload received from wmi or htt path
 * @retries_count: retries count
 * @tx_tsf: 64 bit timestamp
 */
struct cdp_tx_mgmt_comp_info {
	uint32_t ppdu_id;
	bool is_sgen_pkt;
	uint16_t retries_count;
	uint64_t tx_tsf;
};

/**
 * struct cdp_tx_completion_ppdu - Tx PPDU completion information
 * @completion_status: completion status - OK/Filter/Abort/Timeout
 * @ppdu_id: PPDU Id
 * @ppdu_seq_id: ppdu sequence id for sojourn stats
 * @vdev_id: VAP Id
 * @bar_num_users: BA response user count, based on completion common TLV
 * @num_users: Number of users
 * @max_users: Number of users from USR_INFO TLV
 * @last_usr_index:
 * @drop_reason: drop reason from flush status
 * @is_flush: is_flush is set based on flush tlv
 * @flow_type: tx flow type from flush status
 * @queue_type: queue type from flush status
 * @num_mpdu: Number of MPDUs in PPDU
 * @num_msdu: Number of MSDUs in PPDU
 * @frame_type: frame SU or MU
 * @htt_frame_type: frame type from htt
 * @frame_ctrl: frame control of 80211 header
 * @channel: Channel informartion
 * @resp_type: response type
 * @mprot_type: medium protection type
 * @rts_success: rts success
 * @rts_failure: rts failure
 * @phy_mode: phy mode
 * @ack_rssi: RSSI value of last ack packet (units=dB above noise floor)
 * @tx_duration: PPDU airtime
 * @ppdu_start_timestamp: TSF at PPDU start
 * @ppdu_end_timestamp: TSF at PPDU end
 * @ack_timestamp: TSF at the reception of ACK
 * @delayed_ba: Delayed ba flag
 * @beam_change: beam change bit in ppdu for he-information
 * @bss_color: 6 bit value for full bss color
 * @doppler: value for doppler (will be 0 most of the times)
 * @spatial_reuse: value for spatial reuse used in radiotap HE header
 * @usr_nss_sum: Sum of user nss
 * @usr_ru_tones_sum: Sum of user ru_tones
 * @bar_ppdu_id: BAR ppdu_id
 * @bar_tx_duration: BAR tx duration
 * @bar_ppdu_start_timestamp: BAR start timestamp
 * @bar_ppdu_end_timestamp: BAR end timestamp
 * @tlv_bitmap: tlv_bitmap for the PPDU
 * @sched_cmdid: schedule command id
 * @phy_ppdu_tx_time_us: Phy per PPDU TX duration
 * @ppdu_bytes: accumulated bytes per ppdu for mem limit feature
 * @user: per-User stats (array of per-user structures)
 */
struct cdp_tx_completion_ppdu {
	uint32_t ppdu_id;
	uint32_t ppdu_seq_id;
	uint16_t vdev_id;
	uint16_t bar_num_users;
	uint32_t num_users;
	uint8_t  max_users;
	uint8_t last_usr_index;
	uint32_t drop_reason;
	uint32_t is_flush:1,
		 flow_type:8,
		 queue_type:8;
	uint32_t num_mpdu:9,
		 num_msdu:16;
	uint16_t frame_type;
	uint16_t htt_frame_type;
	uint16_t frame_ctrl;
	uint16_t channel;
	uint16_t resp_type:4,
		 mprot_type:3,
		 rts_success:1,
		 rts_failure:1;
	uint16_t phy_mode;
	uint32_t ack_rssi;
	uint32_t tx_duration;
	uint64_t ppdu_start_timestamp;
	uint64_t ppdu_end_timestamp;
	uint64_t ack_timestamp;
	bool delayed_ba;
	uint8_t beam_change;
	uint8_t bss_color;
	uint8_t doppler;
	uint8_t spatial_reuse;
	uint8_t usr_nss_sum;
	uint32_t usr_ru_tones_sum;
	uint32_t bar_ppdu_id;
	uint32_t bar_tx_duration;
	uint64_t bar_ppdu_start_timestamp;
	uint64_t bar_ppdu_end_timestamp;
	uint32_t tlv_bitmap;
	uint16_t sched_cmdid;
	uint16_t phy_ppdu_tx_time_us;
	uint32_t ppdu_bytes;
	struct cdp_tx_completion_ppdu_user user[];
};

/**
 * struct cdp_dev_stats - Network device stats structure
 * @tx_packets: Tx total packets transmitted
 * @tx_errors : Tx error due to FW tx failure, Ring failure DMA etc
 * @tx_dropped: Tx dropped is same as tx errors as above
 * @rx_packets: Rx total packets transmitted
 * @rx_errors : Rx errors
 * @rx_dropped: Rx dropped stats
 * @tx_bytes  : Tx total bytes transmitted
 * @rx_bytes  : Rx total bytes transmitted
 */
struct cdp_dev_stats {
	uint32_t tx_packets;
	uint32_t tx_errors;
	uint32_t tx_dropped;
	uint32_t rx_packets;
	uint32_t rx_errors;
	uint32_t rx_dropped;
	uint64_t tx_bytes;
	uint64_t rx_bytes;
};

/**
 * struct cdp_rate_stats - Tx/Rx Rate statistics
 * @rate_stats_info_valid: set if the stats are valid
 * @bw: Indicates the BW of the upcoming transmission -
 *       <enum 2 transmit_bw_20_MHz>
 *       <enum 3 transmit_bw_40_MHz>
 *       <enum 4 transmit_bw_80_MHz>
 *       <enum 5 transmit_bw_160_MHz>
 * @pkt_type: Transmit Packet Type
 * @stbc: When set, STBC transmission rate was used
 * @ldpc: When set, use LDPC transmission rates
 * @sgi: <enum 0     0_8_us_sgi > Legacy normal GI
 *       <enum 1     0_4_us_sgi > Legacy short GI
 *       <enum 2     1_6_us_sgi > HE related GI
 *       <enum 3     3_2_us_sgi > HE
 * @mcs: Transmit MCS Rate
 * @ofdma: Set when the transmission was an OFDMA transmission
 * @tones_in_ru: The number of tones in the RU used.
 * @resvd0: reserved bits
 * @tsf: Lower 32 bits of the TSF (timestamp when ppdu transmission finished)
 * @peer_id: Peer ID of the flow or MPDU queue
 * @tid: TID of the flow or MPDU queue
 */
struct cdp_rate_stats {
	uint32_t rate_stats_info_valid:1,
		 bw:2,
		 pkt_type:4,
		 stbc:1,
		 ldpc:1,
		 sgi:2,
		 mcs:4,
		 ofdma:1,
		 tones_in_ru:12,
		 resvd0:4;
	uint32_t tsf;
	uint16_t peer_id;
	uint8_t tid;
};

/**
 * struct cdp_tx_completion_msdu - Tx MSDU completion descriptor
 * @ppdu_id: PPDU to which this MSDU belongs
 * @transmit_cnt: Number of times this frame has been transmitted
 * @ack_frame_rssi: RSSI of the received ACK or BA frame
 * @resvd0: reserved bit
 * @first_msdu: Indicates this MSDU is the first MSDU in AMSDU
 * @last_msdu: Indicates this MSDU is the last MSDU in AMSDU
 * @msdu_part_of_amsdu : Indicates this MSDU was part of an A-MSDU in MPDU
 * @extd: Extended structure containing rate statistics
 * @resvd1: reserved bits
 */
struct cdp_tx_completion_msdu {
	uint32_t ppdu_id;
	uint8_t transmit_cnt;
	uint32_t ack_frame_rssi:8,
		 resvd0:1,
		 first_msdu:1,
		 last_msdu:1,
		 msdu_part_of_amsdu:1,
		 resvd1:20;
	struct cdp_rate_stats extd;
};

/**
 * struct cdp_rx_stats_ppdu_user -- per user RX stats
 * @peer_id: Peer ID
 * @vdev_id: VAP ID
 * @is_ampdu: mpdu aggregate or non-aggregate?
 * @mu_ul_info_valid: MU UL info valid
 * @ofdma_ru_start_index: RU index number(0-73)
 * @ofdma_ru_width: size of RU in units of 1(26tone)RU
 * @nss: NSS 1,2, ...8
 * @mcs: MCS index
 * @user_index: user ID in multi-user case
 * @is_bss_peer: is bss peer check
 * @ast_index: ast index in multi-user case
 * @tid: TID number
 * @num_msdu: Number of MSDUs in PPDU
 * @tcp_msdu_count: Number of TCP MSDUs in PPDU
 * @udp_msdu_count: Number of UDP MSDUs in PPDU
 * @other_msdu_count: Number of MSDUs other than UDP and TCP MSDUs in PPDU
 * @frame_control: frame control field
 * @frame_control_info_valid: frame_control valid
 * @qos_control: qos control field
 * @qos_control_info_valid: qos_control valid
 * @data_sequence_control_info_valid: data_sequence_control_info valid
 * @first_data_seq_ctrl: Sequence control field of first data frame
 * @preamble_type: preamble
 * @ht_flags: HT flags
 * @vht_flags: VHT flags
 * @he_flags: HE flags
 * @mac_addr: Peer MAC Address
 * @mpdu_cnt_fcs_ok: Number of MPDUs in PPDU with fcs ok
 * @mpdu_cnt_fcs_err: Number of MPDUs in PPDU with fcs err
 * @mpdu_fcs_ok_bitmap: MPDU with fcs ok bitmap
 * @mpdu_ok_byte_count:
 * @mpdu_err_byte_count:
 * @retries: number of retries
 * @rx_ratekbps: rx rate in kbps
 * @rix: rate index
 * @mpdu_retries: retries of mpdu in rx
 * @rx_time_us: Rx duration
 */
struct cdp_rx_stats_ppdu_user {
	uint16_t peer_id;
	uint8_t vdev_id;
	bool is_ampdu;
	uint32_t mu_ul_info_valid:1,
		 ofdma_ru_start_index:7,
		 ofdma_ru_width:7,
		 nss:4,
		 mcs:4;
	/* user id */
	uint8_t  user_index;
	uint8_t is_bss_peer;
	uint32_t ast_index;
	uint32_t tid;
	uint32_t num_msdu;
	uint16_t  tcp_msdu_count;
	uint16_t  udp_msdu_count;
	uint16_t  other_msdu_count;
	uint16_t frame_control;
	uint8_t  frame_control_info_valid;
	uint16_t qos_control;
	uint8_t  qos_control_info_valid;
	uint8_t data_sequence_control_info_valid;
	uint16_t first_data_seq_ctrl;
	uint32_t preamble_type;
	uint16_t ht_flags;
	uint16_t vht_flags;
	uint16_t he_flags;
	uint8_t  mac_addr[QDF_MAC_ADDR_SIZE];
	uint32_t mpdu_cnt_fcs_ok;
	uint32_t mpdu_cnt_fcs_err;
	uint32_t mpdu_fcs_ok_bitmap[QDF_MON_STATUS_MPDU_FCS_BMAP_NWORDS];
	uint32_t mpdu_ok_byte_count;
	uint32_t mpdu_err_byte_count;
	uint32_t retries;
	uint32_t rx_ratekbps;
	uint32_t rix;
	uint32_t mpdu_retries;
	uint16_t rx_time_us;
};

/**
 * struct cdp_rx_indication_ppdu - Rx PPDU indication structure
 * @ppdu_id: PPDU Id
 * @is_ampdu: mpdu aggregate or non-aggregate?
 * @num_mpdu: Number of MPDUs in PPDU
 * @reserved: Reserved bits for future use
 * @num_msdu: Number of MSDUs in PPDU
 * @num_bytes: Number of bytes
 * @udp_msdu_count: Number of UDP MSDUs in PPDU
 * @tcp_msdu_count: Number of TCP MSDUs in PPDU
 * @other_msdu_count: Number of MSDUs other than UDP and TCP MSDUs in PPDU
 * @duration: PPDU duration
 * @tid: TID number
 * @peer_id: Peer ID
 * @vdev_id: VAP ID
 * @mac_addr: Peer MAC Address
 * @first_data_seq_ctrl: Sequence control field of first data frame
 * @u: union of rate information representations
 * @rate_info: consolidated rate fields
 * @ltf_size: ltf_size
 * @stbc: When set, STBC rate was used
 * @he_re: he_re (range extension)
 * @bw: Bandwidth
 *       <enum 0 bw_20_MHz>
 *       <enum 1 bw_40_MHz>
 *       <enum 2 bw_80_MHz>
 *       <enum 3 bw_160_MHz>
 * @nss: NSS 1,2, ...8
 * @mcs: MCS index
 * @preamble: preamble
 * @gi: <enum 0     0_8_us_sgi > Legacy normal GI
 *       <enum 1     0_4_us_sgi > Legacy short GI
 *       <enum 2     1_6_us_sgi > HE related GI
 *       <enum 3     3_2_us_sgi > HE
 * @dcm: dcm
 * @ldpc: ldpc
 * @ppdu_type: SU/MU_MIMO/MU_OFDMA/MU_MIMO_OFDMA/UL_TRIG/BURST_BCN/UL_BSR_RESP/
 * UL_BSR_TRIG/UNKNOWN
 * @rix: rate index
 * @lsig_a: L-SIG in 802.11 PHY header
 * @rssi: RSSI value (units = dB above noise floor)
 * @timestamp: TSF at the reception of PPDU
 * @length: PPDU length
 * @channel: Channel information
 * @beamformed:
 * @rx_ratekbps:
 * @ppdu_rx_rate:
 * @retries:
 * @rx_byte_count:
 * @rx_ratecode:
 * @fcs_error_mpdus:
 * @frame_ctrl: frame control field
 * @rssi_chain: rssi chain per nss per bw
 * @evm_info:
 * @rx_antenna:
 * @num_users:
 * @nf: noise floor
 * @per_chain_rssi: rssi per antenna
 * @is_mcast_bcast:
 * @cfr_info:
 * @punc_bw: punctured bw
 * @phyrx_abort: rx aborted undecoded frame indication
 * @phyrx_abort_reason: abort reason defined in phyrx_abort_request_info
 * @l_sig_length: L SIG A length
 * @l_sig_a_parity: L SIG A parity
 * @l_sig_a_pkt_type: L SIG A info pkt type
 * @l_sig_a_implicit_sounding: L SIG A info captured implicit sounding
 * @vht_crc: Indicate vht crc
 * @group_id:
 * @ht_length: num of bytes in PSDU
 * @ht_smoothing: Indicate ht_smoothing
 * @ht_not_sounding: Indicate ht not sounding
 * @ht_aggregation: Indicate ht aggregation
 * @ht_stbc: Indicate ht stbc
 * @ht_crc: Indicate ht crc
 * @vht_no_txop_ps: Indicate TXOP power save mode
 * @bss_color_id: Indicate BSS color ID
 * @beam_change: Indicates whether spatial mapping is changed
 * @dl_ul_flag: Differentiates between DL and UL transmission
 * @transmit_mcs: Indicates the data MCS
 * @ldpc_extra_sym: LDPC extra symbol
 * @special_reuse: Spatial reuse
 * @ltf_sym: Indictaes HE NSTS
 * @txbf: Indicates whether beamforming is applied
 * @pe_disambiguity: packet extension disambiguity
 * @pre_fec_pad: packet extension a factor
 * @dopplar: Doppler support
 * @txop_duration: Indicates the remaining time in the current TXOP
 * @sig_b_mcs: MCS of HE-SIG-B
 * @sig_b_dcm: DCM of HE-SIG-B
 * @sig_b_sym: Number of symbols of HE-SIG-B
 * @sig_b_comp: Compression mode of HE-SIG-B
 * @he_crc: CRC for HE-SIG contents
 * @usr_nss_sum: Sum of user nss
 * @usr_ru_tones_sum: Sum of user ru_tones
 * @user: per user stats in MU-user case
 */
struct cdp_rx_indication_ppdu {
	uint32_t ppdu_id;
	uint16_t is_ampdu:1,
		 num_mpdu:9,
		 reserved:6;
	uint32_t num_msdu;
	uint32_t num_bytes;
	uint16_t udp_msdu_count;
	uint16_t tcp_msdu_count;
	uint16_t other_msdu_count;
	uint16_t duration;
	uint32_t tid:8,
		 peer_id:16;
	uint8_t vdev_id;
	uint8_t mac_addr[6];
	uint16_t first_data_seq_ctrl;
	union {
		uint32_t rate_info;
		struct {
			uint32_t ltf_size:2,
				 stbc:1,
				 he_re:1,
				 bw:4,
				 nss:4,
				 mcs:4,
				 preamble:4,
				 gi:4,
				 dcm:1,
				 ldpc:1,
				 ppdu_type:5;
		};
	} u;
	uint32_t rix;
	uint32_t lsig_a;
	uint32_t rssi;
	uint64_t timestamp;
	uint32_t length;
	uint8_t channel;
	uint8_t beamformed;

	uint32_t rx_ratekbps;
	uint32_t ppdu_rx_rate;

	uint32_t retries;
	uint32_t rx_byte_count;
	uint16_t rx_ratecode;
	uint8_t fcs_error_mpdus;
	uint16_t frame_ctrl;
	int8_t rssi_chain[SS_COUNT][MAX_BW];
	struct cdp_rx_su_evm_info evm_info;
	uint32_t rx_antenna;
	uint8_t num_users;
	uint32_t nf;
	uint8_t  per_chain_rssi[MAX_CHAIN];
	uint8_t is_mcast_bcast;
#if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
	struct cdp_rx_ppdu_cfr_info cfr_info;
#endif
	uint8_t punc_bw;
#ifdef QCA_UNDECODED_METADATA_SUPPORT
	bool phyrx_abort;
	uint8_t phyrx_abort_reason;
	uint32_t l_sig_length:12,
		 l_sig_a_parity:1,
		 l_sig_a_pkt_type:4,
		 l_sig_a_implicit_sounding:1,
		 vht_crc:8,
		 group_id:6;
	uint32_t ht_length:16,
		 ht_smoothing:1,
		 ht_not_sounding:1,
		 ht_aggregation:1,
		 ht_stbc:2,
		 ht_crc:8,
		 vht_no_txop_ps:1;
	uint32_t bss_color_id:6,
		 beam_change:1,
		 dl_ul_flag:1,
		 transmit_mcs:4,
		 ldpc_extra_sym:1,
		 special_reuse:4,
		 ltf_sym:3,
		 txbf:1,
		 pe_disambiguity:1,
		 pre_fec_pad:4,
		 dopplar:1;
	uint32_t txop_duration:7,
		 sig_b_mcs:3,
		 sig_b_dcm:1,
		 sig_b_sym:4,
		 sig_b_comp:1,
		 he_crc:4;
#endif
	uint8_t usr_nss_sum;
	uint32_t usr_ru_tones_sum;
	struct cdp_rx_stats_ppdu_user user[];
};

/**
 * struct cdp_rx_indication_msdu - Rx MSDU info
 * @ppdu_id: PPDU to which the MSDU belongs
 * @msdu_len: Length of MSDU in bytes
 * @ack_frame_rssi: RSSI of the received ACK or BA frame
 * @resvd0: reserved bit
 * @first_msdu: Indicates this MSDU is the first MSDU in AMSDU
 * @last_msdu: Indicates this MSDU is the last MSDU in AMSDU
 * @msdu_part_of_amsdu: Indicates this MSDU was part of an A-MSDU in MPDU
 * @msdu_part_of_ampdu:
 * @resvd1: reserved bit
 * @extd: Extended structure containing rate statistics
 */
struct cdp_rx_indication_msdu {
	uint32_t ppdu_id;
	uint16_t msdu_len;
	uint32_t ack_frame_rssi:8,
		 resvd0:1,
		 first_msdu:1,
		 last_msdu:1,
		 msdu_part_of_amsdu:1,
		 msdu_part_of_ampdu:1,
		 resvd1:19;
	struct cdp_rate_stats extd;
};

/**
 * struct cdp_config_params - Propagate configuration parameters to datapath
 * @tso_enable: Enable/Disable TSO
 * @lro_enable: Enable/Disable LRO
 * @gro_enable: Enable/Disable GRO
 * @flow_steering_enable: Enable/Disable Rx Hash based flow steering
 * @p2p_tcp_udp_checksumoffload: Enable/Disable TCP/UDP Checksum Offload for P2P
 * @nan_tcp_udp_checksumoffload: Enable/Disable TCP/UDP Checksum Offload for NAN
 * @tcp_udp_checksumoffload: Enable/Disable TCP/UDP Checksum Offload
 * @legacy_mode_checksumoffload_disable: Disable TCP/UDP Checksum Offload for
 *					 legacy modes.
 * @napi_enable: Enable/Disable Napi
 * @ipa_enable: Flag indicating if IPA is enabled or not
 * @tx_flow_stop_queue_threshold: Value to Pause tx queues
 * @tx_flow_start_queue_offset: Available Tx descriptors to unpause
 *				tx queue
 * @tx_comp_loop_pkt_limit: Max # of packets to be processed in 1 tx comp loop
 * @rx_reap_loop_pkt_limit: Max # of packets to be processed in 1 rx reap loop
 * @rx_hp_oos_update_limit: Max # of HP OOS (out of sync) updates
 */
struct cdp_config_params {
	unsigned int tso_enable:1;
	unsigned int lro_enable:1;
	unsigned int gro_enable:1;
	unsigned int flow_steering_enable:1;
	unsigned int p2p_tcp_udp_checksumoffload:1;
	unsigned int nan_tcp_udp_checksumoffload:1;
	unsigned int tcp_udp_checksumoffload:1;
	unsigned int legacy_mode_checksumoffload_disable:1;
	unsigned int napi_enable:1;
	unsigned int ipa_enable:1;
	/* Set when QCA_LL_TX_FLOW_CONTROL_V2 is enabled */
	uint8_t tx_flow_stop_queue_threshold;
	uint8_t tx_flow_start_queue_offset;
	uint32_t tx_comp_loop_pkt_limit;
	uint32_t rx_reap_loop_pkt_limit;
	uint32_t rx_hp_oos_update_limit;

};

/**
 * struct cdp_txrx_stats_req - stats request wrapper
 *	used to pass request information to cdp layer
 * @stats: type of stats requested
 * @param0: opaque argument 0 to be passed to htt
 * @param1: opaque argument 1 to be passed to htt
 * @param2: opaque argument 2 to be passed to htt
 * @param3: opaque argument 3 to be passed to htt
 * @cookie_val: cookie
 * @mac_id: mac id
 * @peer_addr: peer address
 */
struct cdp_txrx_stats_req {
	enum cdp_stats	stats;
	uint32_t	param0;
	uint32_t	param1;
	uint32_t	param2;
	uint32_t	param3;
	uint32_t	cookie_val;
	uint8_t		mac_id;
	char		*peer_addr;
};

/**
 * struct cdp_monitor_filter - monitor filter info
 * @mode: set filter mode
 * @fp_mgmt: set Filter Pass MGMT Configuration
 * @fp_ctrl: set Filter Pass CTRL Configuration
 * @fp_data: set Filter Pass DATA Configuration
 * @mo_mgmt: set Monitor Other MGMT Configuration
 * @mo_ctrl: set Monitor Other CTRL Configuration
 * @mo_data: set Monitor other DATA Configuration
 *
 */
struct cdp_monitor_filter {
	uint16_t mode;
	uint16_t fp_mgmt;
	uint16_t fp_ctrl;
	uint16_t fp_data;
	uint16_t mo_mgmt;
	uint16_t mo_ctrl;
	uint16_t mo_data;
};

/**
 * enum cdp_dp_cfg - CDP ENUMs to get to DP configation
 * @cfg_dp_enable_data_stall: context passed to be used by consumer
 * @cfg_dp_enable_p2p_ip_tcp_udp_checksum_offload: get P2P checksum config
 * @cfg_dp_enable_nan_ip_tcp_udp_checksum_offload: get NAN TX checksum config
 * @cfg_dp_enable_ip_tcp_udp_checksum_offload: get TX checksum config for others
 * @cfg_dp_disable_legacy_mode_csum_offload: Disable checksum offload for
 *                                           legacy modes
 * @cfg_dp_tso_enable: get TSO enable config
 * @cfg_dp_lro_enable: get LRO enable config
 * @cfg_dp_gro_enable: get GRO enable config
 * @cfg_dp_tc_based_dyn_gro_enable: get TC based dynamic gro enable config
 * @cfg_dp_tc_ingress_prio: priority value to be checked for tc filters
 * @cfg_dp_sg_enable:
 * @cfg_dp_tx_flow_start_queue_offset: get DP TX flow start queue offset
 * @cfg_dp_tx_flow_stop_queue_threshold: get DP TX flow stop queue threshold
 * @cfg_dp_ipa_uc_tx_buf_size: get IPA TX buf size config
 * @cfg_dp_ipa_uc_tx_partition_base: get IPA UC TX partition base config
 * @cfg_dp_ipa_uc_rx_ind_ring_count: get IPA rx indication ring count config
 * @cfg_dp_enable_flow_steering: get flow steerint enable config
 * @cfg_dp_reorder_offload_supported: get reorder offload support config
 * @cfg_dp_ce_classify_enable: get CE classify enable config
 * @cfg_dp_disable_intra_bss_fwd: get intra bss fwd config
 * @cfg_dp_pktlog_buffer_size: get packet log buffer size config
 * @cfg_dp_wow_check_rx_pending: get wow rx pending frame check config
 */
enum cdp_dp_cfg {
	cfg_dp_enable_data_stall,
	cfg_dp_enable_p2p_ip_tcp_udp_checksum_offload,
	cfg_dp_enable_nan_ip_tcp_udp_checksum_offload,
	cfg_dp_enable_ip_tcp_udp_checksum_offload,
	cfg_dp_disable_legacy_mode_csum_offload,
	cfg_dp_tso_enable,
	cfg_dp_lro_enable,
	cfg_dp_gro_enable,
	cfg_dp_tc_based_dyn_gro_enable,
	cfg_dp_tc_ingress_prio,
	cfg_dp_sg_enable,
	cfg_dp_tx_flow_start_queue_offset,
	cfg_dp_tx_flow_stop_queue_threshold,
	cfg_dp_ipa_uc_tx_buf_size,
	cfg_dp_ipa_uc_tx_partition_base,
	cfg_dp_ipa_uc_rx_ind_ring_count,
	cfg_dp_enable_flow_steering,
	cfg_dp_reorder_offload_supported,
	cfg_dp_ce_classify_enable,
	cfg_dp_disable_intra_bss_fwd,
	cfg_dp_pktlog_buffer_size,
	cfg_dp_wow_check_rx_pending,
};

/**
 * struct cdp_peer_cookie - cookie used when creating peer
 * @ctx: context passed to be used by consumer
 * @mac_addr: MAC address of peer
 * @peer_id: peer id
 * @pdev_id: pdev_id
 * @cookie: cookie to be used by consumer
 */
struct cdp_peer_cookie {
	struct cdp_stats_cookie *ctx;
	uint8_t mac_addr[QDF_MAC_ADDR_SIZE];
	uint8_t peer_id;
	uint8_t pdev_id;
	uint8_t cookie;
};

#ifdef WLAN_SUPPORT_RX_FISA
struct cdp_flow_stats {
	uint32_t aggr_count;
	uint32_t curr_aggr_count;
	uint32_t flush_count;
	uint32_t bytes_aggregated;
};
#else
/**
 * struct cdp_flow_stats - Per-Flow (5-tuple) statistics
 * @msdu_count: number of rx msdus matching this flow
 * @mon_msdu_count: number of msdus matching this flow in mon path
 *
 * HW also includes msdu_byte_count and timestamp, which
 * are not currently tracked in SW.
 */
struct cdp_flow_stats {
	uint32_t msdu_count;
	uint32_t mon_msdu_count;
};
#endif

/**
 * enum cdp_flow_fst_operation - RX FST operations allowed
 * @CDP_FLOW_FST_ENTRY_ADD: Add entry
 * @CDP_FLOW_FST_ENTRY_DEL: Delete entry
 * @CDP_FLOW_FST_RX_BYPASS_ENABLE: RX bypass enable
 * @CDP_FLOW_FST_RX_BYPASS_DISABLE: RX bypass disable
 */
enum cdp_flow_fst_operation {
	CDP_FLOW_FST_ENTRY_ADD,
	CDP_FLOW_FST_ENTRY_DEL,
	CDP_FLOW_FST_RX_BYPASS_ENABLE,
	CDP_FLOW_FST_RX_BYPASS_DISABLE
};

/**
 * enum cdp_flow_protocol_type - RX FST supported protocol types,
 *                               mapped to HW spec
 * @CDP_FLOW_PROTOCOL_TYPE_TCP: TCP
 * @CDP_FLOW_PROTOCOL_TYPE_UDP: UDP
 */
enum cdp_flow_protocol_type {
	CDP_FLOW_PROTOCOL_TYPE_TCP = 6,
	CDP_FLOW_PROTOCOL_TYPE_UDP = 17,
};

/**
 * struct cdp_rx_flow_tuple_info - RX flow tuple info used for addition/deletion
 * @tuple_populated:
 * @is_exception: Flows which are added to flow table but not aggregated.
 * @bypass_fisa: Flow which are not added to flow table.
 * @dest_ip_127_96: destination IP address bit fields 96-127
 * @dest_ip_95_64: destination IP address bit fields 64-95
 * @dest_ip_63_32: destination IP address bit fields 32-63
 * @dest_ip_31_0: destination IP address bit fields 0-31
 * @src_ip_127_96: source IP address bit fields 96-127
 * @src_ip_95_64: source IP address bit fields 64-95
 * @src_ip_63_32: source IP address bit fields 32-63
 * @src_ip_31_0: source IP address bit fields 0-31
 * @dest_port: destination port of flow
 * @src_port: source port of flow
 * @l4_protocol: protocol type in flow (TCP/UDP)
 */
struct cdp_rx_flow_tuple_info {
#ifdef WLAN_SUPPORT_RX_FISA
	uint8_t tuple_populated;
	uint8_t is_exception;
	bool bypass_fisa;
#endif
	uint32_t dest_ip_127_96;
	uint32_t dest_ip_95_64;
	uint32_t dest_ip_63_32;
	uint32_t dest_ip_31_0;
	uint32_t src_ip_127_96;
	uint32_t src_ip_95_64;
	uint32_t src_ip_63_32;
	uint32_t src_ip_31_0;
	uint16_t dest_port;
	uint16_t src_port;
	uint16_t l4_protocol;
};

/**
 * struct cdp_rx_flow_info - RX flow info used for addition/deletion
 * @is_addr_ipv4: indicates whether given IP address is IPv4/IPv6
 * @op_code: add/delete/enable/disable operation requested
 * @flow_tuple_info: structure containing tuple info
 * @fse_metadata: metadata to be set in RX flow
 * @use_ppe_ds: use DS mode
 * @priority_vld: is priority valid
 * @service_code: service code for DS
 */
struct cdp_rx_flow_info {
	bool is_addr_ipv4;
	enum cdp_flow_fst_operation op_code;
	struct cdp_rx_flow_tuple_info flow_tuple_info;
	uint16_t fse_metadata;
	uint8_t use_ppe_ds;
	uint8_t priority_vld;
	uint16_t service_code;
};

#ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
/**
 * struct cdp_scan_spcl_vap_stats - Special vap statistics info
 * @rx_ok_pkts: rx fcs ok pkts count
 * @rx_ok_bytes: rx fcs ok bytes count
 * @rx_err_pkts: rx fcs err pkts count
 * @rx_err_bytes: rx fcs err bytes count
 * @rx_mgmt_pkts: rx mgmt pkts count
 * @rx_ctrl_pkts: rx ctrl pkts count
 * @rx_data_pkts: rx data pkts count
 */
struct cdp_scan_spcl_vap_stats {
	uint64_t rx_ok_pkts;
	uint64_t rx_ok_bytes;
	uint64_t rx_err_pkts;
	uint64_t rx_err_bytes;
	uint64_t rx_mgmt_pkts;
	uint64_t rx_ctrl_pkts;
	uint64_t rx_data_pkts;
};
#endif

/**
 * struct cdp_soc_attach_params
 *
 * @hif_handle: Opaque HIF handle
 * @htc_handle: Opaque HTC handle
 * @qdf_osdev: QDF device
 * @ol_ops: Offload Operations
 * @device_id: Device ID
 * @ml_context: DP ML object context
 * @mlo_chip_id: MLO chip id, for legacy SOCs chip_id need to 0
 * @mlo_enabled: MLO enable bit
 */
struct cdp_soc_attach_params {
	struct hif_opaque_softc *hif_handle;
	HTC_HANDLE htc_handle;
	qdf_device_t qdf_osdev;
	struct ol_if_ops *ol_ops;
	uint16_t device_id;
	struct cdp_mlo_ctxt *ml_context;
	uint8_t mlo_chip_id;
	uint8_t mlo_enabled;
};

/**
 * struct cdp_pdev_attach_params - params for pdev attach
 *
 * @htc_handle: HTC handle for host-target interface
 * @qdf_osdev: QDF OS device
 * @pdev_id: PDEV ID
 * @mlo_link_id: ML link id
 */
struct cdp_pdev_attach_params {
	HTC_HANDLE htc_handle;
	qdf_device_t qdf_osdev;
	uint8_t pdev_id;
	uint32_t mlo_link_id;
};
#endif