linux/drivers/net/wireless/ath/ath12k/wmi.h

/* SPDX-License-Identifier: BSD-3-Clause-Clear */
/*
 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#ifndef ATH12K_WMI_H
#define ATH12K_WMI_H

#include <net/mac80211.h>
#include "htc.h"

/* Naming conventions for structures:
 *
 * _cmd means that this is a firmware command sent from host to firmware.
 *
 * _event means that this is a firmware event sent from firmware to host
 *
 * _params is a structure which is embedded either into _cmd or _event (or
 * both), it is not sent individually.
 *
 * _arg is used inside the host, the firmware does not see that at all.
 */

struct ath12k_base;
struct ath12k;
struct ath12k_vif;

/* There is no signed version of __le32, so for a temporary solution come
 * up with our own version. The idea is from fs/ntfs/endian.h.
 *
 * Use a_ prefix so that it doesn't conflict if we get proper support to
 * linux/types.h.
 */
a_sle32;

static inline a_sle32 a_cpu_to_sle32(s32 val)
{}

static inline s32 a_sle32_to_cpu(a_sle32 val)
{}

/* defines to set Packet extension values which can be 0 us, 8 usec or 16 usec */
#define MAX_HE_NSS
#define MAX_HE_MODULATION
#define MAX_HE_RU
#define HE_MODULATION_NONE
#define HE_PET_0_USEC
#define HE_PET_8_USEC
#define HE_PET_16_USEC

#define WMI_MAX_CHAINS

#define WMI_MAX_NUM_SS
#define WMI_MAX_NUM_RU

#define WMI_TLV_CMD(grp_id)
#define WMI_TLV_EV(grp_id)
#define WMI_TLV_CMD_UNSUPPORTED
#define WMI_TLV_PDEV_PARAM_UNSUPPORTED
#define WMI_TLV_VDEV_PARAM_UNSUPPORTED

struct wmi_cmd_hdr {} __packed;

struct wmi_tlv {} __packed;

#define WMI_TLV_LEN
#define WMI_TLV_TAG
#define TLV_HDR_SIZE

#define WMI_CMD_HDR_CMD_ID
#define WMI_MAX_MEM_REQS
#define ATH12K_MAX_HW_LISTEN_INTERVAL

#define WMI_HOST_RC_DS_FLAG
#define WMI_HOST_RC_CW40_FLAG
#define WMI_HOST_RC_SGI_FLAG
#define WMI_HOST_RC_HT_FLAG
#define WMI_HOST_RC_RTSCTS_FLAG
#define WMI_HOST_RC_TX_STBC_FLAG
#define WMI_HOST_RC_RX_STBC_FLAG
#define WMI_HOST_RC_RX_STBC_FLAG_S
#define WMI_HOST_RC_WEP_TKIP_FLAG
#define WMI_HOST_RC_TS_FLAG
#define WMI_HOST_RC_UAPSD_FLAG

#define WMI_HT_CAP_ENABLED
#define WMI_HT_CAP_HT20_SGI
#define WMI_HT_CAP_DYNAMIC_SMPS
#define WMI_HT_CAP_TX_STBC
#define WMI_HT_CAP_TX_STBC_MASK_SHIFT
#define WMI_HT_CAP_RX_STBC
#define WMI_HT_CAP_RX_STBC_MASK_SHIFT
#define WMI_HT_CAP_LDPC
#define WMI_HT_CAP_L_SIG_TXOP_PROT
#define WMI_HT_CAP_MPDU_DENSITY
#define WMI_HT_CAP_MPDU_DENSITY_MASK_SHIFT
#define WMI_HT_CAP_HT40_SGI
#define WMI_HT_CAP_RX_LDPC
#define WMI_HT_CAP_TX_LDPC
#define WMI_HT_CAP_IBF_BFER

/* These macros should be used when we wish to advertise STBC support for
 * only 1SS or 2SS or 3SS.
 */
#define WMI_HT_CAP_RX_STBC_1SS
#define WMI_HT_CAP_RX_STBC_2SS
#define WMI_HT_CAP_RX_STBC_3SS

#define WMI_HT_CAP_DEFAULT_ALL

#define WMI_VHT_CAP_MAX_MPDU_LEN_MASK
#define WMI_VHT_CAP_RX_LDPC
#define WMI_VHT_CAP_SGI_80MHZ
#define WMI_VHT_CAP_SGI_160MHZ
#define WMI_VHT_CAP_TX_STBC
#define WMI_VHT_CAP_RX_STBC_MASK
#define WMI_VHT_CAP_RX_STBC_MASK_SHIFT
#define WMI_VHT_CAP_SU_BFER
#define WMI_VHT_CAP_SU_BFEE
#define WMI_VHT_CAP_MAX_CS_ANT_MASK
#define WMI_VHT_CAP_MAX_CS_ANT_MASK_SHIFT
#define WMI_VHT_CAP_MAX_SND_DIM_MASK
#define WMI_VHT_CAP_MAX_SND_DIM_MASK_SHIFT
#define WMI_VHT_CAP_MU_BFER
#define WMI_VHT_CAP_MU_BFEE
#define WMI_VHT_CAP_MAX_AMPDU_LEN_EXP
#define WMI_VHT_CAP_MAX_AMPDU_LEN_EXP_SHIT
#define WMI_VHT_CAP_RX_FIXED_ANT
#define WMI_VHT_CAP_TX_FIXED_ANT

#define WMI_VHT_CAP_MAX_MPDU_LEN_11454

/* These macros should be used when we wish to advertise STBC support for
 * only 1SS or 2SS or 3SS.
 */
#define WMI_VHT_CAP_RX_STBC_1SS
#define WMI_VHT_CAP_RX_STBC_2SS
#define WMI_VHT_CAP_RX_STBC_3SS

#define WMI_VHT_CAP_DEFAULT_ALL

#define WLAN_SCAN_MAX_HINT_S_SSID
#define WLAN_SCAN_MAX_HINT_BSSID
#define MAX_RNR_BSS

#define WMI_APPEND_TO_EXISTING_CHAN_LIST_FLAG

#define WMI_BA_MODE_BUFFER_SIZE_256

/* HW mode config type replicated from FW header
 * @WMI_HOST_HW_MODE_SINGLE: Only one PHY is active.
 * @WMI_HOST_HW_MODE_DBS: Both PHYs are active in different bands,
 *                        one in 2G and another in 5G.
 * @WMI_HOST_HW_MODE_SBS_PASSIVE: Both PHYs are in passive mode (only rx) in
 *                        same band; no tx allowed.
 * @WMI_HOST_HW_MODE_SBS: Both PHYs are active in the same band.
 *                        Support for both PHYs within one band is planned
 *                        for 5G only(as indicated in WMI_MAC_PHY_CAPABILITIES),
 *                        but could be extended to other bands in the future.
 *                        The separation of the band between the two PHYs needs
 *                        to be communicated separately.
 * @WMI_HOST_HW_MODE_DBS_SBS: 3 PHYs, with 2 on the same band doing SBS
 *                           as in WMI_HW_MODE_SBS, and 3rd on the other band
 * @WMI_HOST_HW_MODE_DBS_OR_SBS: Two PHY with one PHY capabale of both 2G and
 *                        5G. It can support SBS (5G + 5G) OR DBS (5G + 2G).
 * @WMI_HOST_HW_MODE_MAX: Max hw_mode_id. Used to indicate invalid mode.
 */
enum wmi_host_hw_mode_config_type {};

/* HW mode priority values used to detect the preferred HW mode
 * on the available modes.
 */
enum wmi_host_hw_mode_priority {};

enum WMI_HOST_WLAN_BAND {};

enum wmi_cmd_group {};

#define WMI_CMD_GRP(grp_id)
#define WMI_EVT_GRP_START_ID(grp_id)

enum wmi_tlv_cmd_id {};

enum wmi_tlv_event_id {};

enum wmi_tlv_pdev_param {};

enum wmi_tlv_vdev_param {};

enum wmi_tlv_peer_flags {};

enum wmi_tlv_peer_flags_ext {};

/** Enum list of TLV Tags for each parameter structure type. */
enum wmi_tlv_tag {};

enum wmi_tlv_service {};

enum {};

enum wmi_tpc_chainmask {};

enum wmi_peer_param {};

#define WMI_PEER_PUNCTURE_BITMAP

enum wmi_slot_time {};

enum wmi_preamble {};

enum wmi_peer_smps_state {};

enum wmi_peer_chwidth {};

enum wmi_beacon_gen_mode {};

enum wmi_direct_buffer_module {};

struct ath12k_wmi_pdev_band_arg {};

struct ath12k_wmi_ppe_threshold_arg {};

#define PSOC_HOST_MAX_PHY_SIZE
#define ATH12K_11B_SUPPORT
#define ATH12K_11G_SUPPORT
#define ATH12K_11A_SUPPORT
#define ATH12K_11N_SUPPORT
#define ATH12K_11AC_SUPPORT
#define ATH12K_11AX_SUPPORT

struct ath12k_wmi_hal_reg_capabilities_ext_arg {};

#define WMI_HOST_MAX_PDEV

struct ath12k_wmi_host_mem_chunk_params {} __packed;

struct ath12k_wmi_host_mem_chunk_arg {};

enum ath12k_peer_metadata_version {};

struct ath12k_wmi_resource_config_arg {};

struct ath12k_wmi_init_cmd_arg {};

struct ath12k_wmi_pdev_band_to_mac_params {} __packed;

/* This is both individual command WMI_PDEV_SET_HW_MODE_CMDID and also part
 * of WMI_TAG_INIT_CMD.
 */
struct ath12k_wmi_pdev_set_hw_mode_cmd {} __packed;

struct ath12k_wmi_ppe_threshold_params {} __packed;

#define HW_BD_INFO_SIZE

struct ath12k_wmi_abi_version_params {} __packed;

struct wmi_init_cmd {} __packed;

#define WMI_RSRC_CFG_HOST_SVC_FLAG_REG_CC_EXT_SUPPORT_BIT
#define WMI_RSRC_CFG_FLAGS2_RX_PEER_METADATA_VERSION
#define WMI_RSRC_CFG_FLAG1_BSS_CHANNEL_INFO_64
#define WMI_RSRC_CFG_FLAGS2_CALC_NEXT_DTIM_COUNT_SET

struct ath12k_wmi_resource_config_params {} __packed;

struct wmi_service_ready_event {} __packed;

#define WMI_SERVICE_BM_SIZE

#define WMI_SERVICE_SEGMENT_BM_SIZE32
#define WMI_SERVICE_EXT_BM_SIZE
#define WMI_AVAIL_SERVICE_BITS_IN_SIZE32
#define WMI_SERVICE_BITS_IN_SIZE32

struct wmi_service_ready_ext_event {} __packed;

struct ath12k_wmi_soc_mac_phy_hw_mode_caps_params {} __packed;

struct ath12k_wmi_hw_mode_cap_params {} __packed;

#define WMI_MAX_HECAP_PHY_SIZE

/* pdev_id is present in lower 16 bits of pdev_and_hw_link_ids in
 * ath12k_wmi_mac_phy_caps_params & ath12k_wmi_caps_ext_params.
 *
 * hw_link_id is present in higher 16 bits of pdev_and_hw_link_ids.
 */
#define WMI_CAPS_PARAMS_PDEV_ID
#define WMI_CAPS_PARAMS_HW_LINK_ID

struct ath12k_wmi_mac_phy_caps_params {} __packed;

struct ath12k_wmi_hal_reg_caps_ext_params {} __packed;

struct ath12k_wmi_soc_hal_reg_caps_params {} __packed;

enum wmi_channel_width {};

#define WMI_MAX_EHTCAP_MAC_SIZE
#define WMI_MAX_EHTCAP_PHY_SIZE
#define WMI_MAX_EHTCAP_RATE_SET

/* Used for EHT MCS-NSS array. Data at each array index follows the format given
 * in IEEE P802.11be/D2.0, May 20229.4.2.313.4.
 *
 * Index interpretation:
 * 0 - 20 MHz only sta, all 4 bytes valid
 * 1 - index for bandwidths <= 80 MHz except 20 MHz-only, first 3 bytes valid
 * 2 - index for 160 MHz, first 3 bytes valid
 * 3 - index for 320 MHz, first 3 bytes valid
 */
#define WMI_MAX_EHT_SUPP_MCS_2G_SIZE
#define WMI_MAX_EHT_SUPP_MCS_5G_SIZE

#define WMI_EHTCAP_TXRX_MCS_NSS_IDX_80
#define WMI_EHTCAP_TXRX_MCS_NSS_IDX_160
#define WMI_EHTCAP_TXRX_MCS_NSS_IDX_320

#define WMI_EHT_MCS_NSS_0_7
#define WMI_EHT_MCS_NSS_8_9
#define WMI_EHT_MCS_NSS_10_11
#define WMI_EHT_MCS_NSS_12_13

struct wmi_service_ready_ext2_event {} __packed;

struct ath12k_wmi_caps_ext_params {} __packed;

/* 2 word representation of MAC addr */
struct ath12k_wmi_mac_addr_params {} __packed;

struct ath12k_wmi_dma_ring_caps_params {} __packed;

struct ath12k_wmi_ready_event_min_params {} __packed;

struct wmi_ready_event {} __packed;

struct wmi_service_available_event {} __packed;

struct ath12k_wmi_vdev_create_arg {};

#define ATH12K_MAX_VDEV_STATS_ID
#define ATH12K_INVAL_VDEV_STATS_ID

struct wmi_vdev_create_cmd {} __packed;

struct ath12k_wmi_vdev_txrx_streams_params {} __packed;

struct wmi_vdev_delete_cmd {} __packed;

struct ath12k_wmi_vdev_up_params {};

struct wmi_vdev_up_cmd {} __packed;

struct wmi_vdev_stop_cmd {} __packed;

struct wmi_vdev_down_cmd {} __packed;

#define WMI_VDEV_START_HIDDEN_SSID
#define WMI_VDEV_START_PMF_ENABLED
#define WMI_VDEV_START_LDPC_RX_ENABLED

#define ATH12K_WMI_SSID_LEN

struct ath12k_wmi_ssid_params {} __packed;

#define ATH12K_VDEV_SETUP_TIMEOUT_HZ

enum wmi_vdev_mbssid_flags {};

struct wmi_vdev_start_request_cmd {} __packed;

#define MGMT_TX_DL_FRM_LEN

struct ath12k_wmi_channel_arg {};

enum wmi_phy_mode {};

struct wmi_vdev_start_req_arg {};

struct ath12k_wmi_peer_create_arg {};

struct ath12k_wmi_pdev_set_regdomain_arg {};

struct ath12k_wmi_rx_reorder_queue_remove_arg {};

#define WMI_HOST_PDEV_ID_SOC
#define WMI_HOST_PDEV_ID_0
#define WMI_HOST_PDEV_ID_1
#define WMI_HOST_PDEV_ID_2

#define WMI_PDEV_ID_SOC
#define WMI_PDEV_ID_1ST
#define WMI_PDEV_ID_2ND
#define WMI_PDEV_ID_3RD

/* Freq units in MHz */
#define REG_RULE_START_FREQ
#define REG_RULE_END_FREQ
#define REG_RULE_FLAGS
#define REG_RULE_MAX_BW
#define REG_RULE_REG_PWR
#define REG_RULE_ANT_GAIN
#define REG_RULE_PSD_INFO
#define REG_RULE_PSD_EIRP

#define WMI_VDEV_PARAM_TXBF_SU_TX_BFEE
#define WMI_VDEV_PARAM_TXBF_MU_TX_BFEE
#define WMI_VDEV_PARAM_TXBF_SU_TX_BFER
#define WMI_VDEV_PARAM_TXBF_MU_TX_BFER

#define HECAP_PHYDWORD_0
#define HECAP_PHYDWORD_1
#define HECAP_PHYDWORD_2

#define HECAP_PHY_SU_BFER
#define HECAP_PHY_SU_BFEE
#define HECAP_PHY_MU_BFER
#define HECAP_PHY_UL_MUMIMO
#define HECAP_PHY_UL_MUOFDMA

#define HECAP_PHY_SUBFMR_GET(hecap_phy)

#define HECAP_PHY_SUBFME_GET(hecap_phy)

#define HECAP_PHY_MUBFMR_GET(hecap_phy)

#define HECAP_PHY_ULMUMIMO_GET(hecap_phy)

#define HECAP_PHY_ULOFDMA_GET(hecap_phy)

#define HE_MODE_SU_TX_BFEE
#define HE_MODE_SU_TX_BFER
#define HE_MODE_MU_TX_BFEE
#define HE_MODE_MU_TX_BFER
#define HE_MODE_DL_OFDMA
#define HE_MODE_UL_OFDMA
#define HE_MODE_UL_MUMIMO

#define HE_DL_MUOFDMA_ENABLE
#define HE_UL_MUOFDMA_ENABLE
#define HE_DL_MUMIMO_ENABLE
#define HE_MU_BFEE_ENABLE
#define HE_SU_BFEE_ENABLE

#define HE_VHT_SOUNDING_MODE_ENABLE
#define HE_SU_MU_SOUNDING_MODE_ENABLE
#define HE_TRIG_NONTRIG_SOUNDING_MODE_ENABLE

/* HE or VHT Sounding */
#define HE_VHT_SOUNDING_MODE
/* SU or MU Sounding */
#define HE_SU_MU_SOUNDING_MODE
/* Trig or Non-Trig Sounding */
#define HE_TRIG_NONTRIG_SOUNDING_MODE

#define WMI_TXBF_STS_CAP_OFFSET_LSB
#define WMI_TXBF_STS_CAP_OFFSET_MASK
#define WMI_BF_SOUND_DIM_OFFSET_LSB
#define WMI_BF_SOUND_DIM_OFFSET_MASK

enum wmi_peer_type {};

struct wmi_peer_create_cmd {} __packed;

struct wmi_peer_delete_cmd {} __packed;

struct wmi_peer_reorder_queue_setup_cmd {} __packed;

struct wmi_peer_reorder_queue_remove_cmd {} __packed;

enum wmi_bss_chan_info_req_type {};

struct wmi_pdev_set_param_cmd {} __packed;

struct wmi_pdev_set_ps_mode_cmd {} __packed;

struct wmi_pdev_suspend_cmd {} __packed;

struct wmi_pdev_resume_cmd {} __packed;

struct wmi_pdev_bss_chan_info_req_cmd {} __packed;

struct wmi_ap_ps_peer_cmd {} __packed;

struct wmi_sta_powersave_param_cmd {} __packed;

struct wmi_pdev_set_regdomain_cmd {} __packed;

struct wmi_peer_set_param_cmd {} __packed;

struct wmi_peer_flush_tids_cmd {} __packed;

struct wmi_dfs_phyerr_offload_cmd {} __packed;

struct wmi_bcn_offload_ctrl_cmd {} __packed;

enum scan_dwelltime_adaptive_mode {};

#define WLAN_SCAN_MAX_NUM_SSID
#define WLAN_SCAN_MAX_NUM_BSSID

struct ath12k_wmi_element_info_arg {};

#define WMI_IE_BITMAP_SIZE

#define WMI_SCAN_MAX_NUM_SSID
/* prefix used by scan requestor ids on the host */
#define WMI_HOST_SCAN_REQUESTOR_ID_PREFIX

/* prefix used by scan request ids generated on the host */
/* host cycles through the lower 12 bits to generate ids */
#define WMI_HOST_SCAN_REQ_ID_PREFIX

#define WLAN_SCAN_PARAMS_MAX_SSID
#define WLAN_SCAN_PARAMS_MAX_BSSID
#define WLAN_SCAN_PARAMS_MAX_IE_LEN

/* Values lower than this may be refused by some firmware revisions with a scan
 * completion with a timedout reason.
 */
#define WMI_SCAN_CHAN_MIN_TIME_MSEC

/* Scan priority numbers must be sequential, starting with 0 */
enum wmi_scan_priority {};

enum wmi_scan_event_type {};

enum wmi_scan_completion_reason {};

struct  wmi_start_scan_cmd {} __packed;

#define WMI_SCAN_FLAG_PASSIVE
#define WMI_SCAN_ADD_BCAST_PROBE_REQ
#define WMI_SCAN_ADD_CCK_RATES
#define WMI_SCAN_ADD_OFDM_RATES
#define WMI_SCAN_CHAN_STAT_EVENT
#define WMI_SCAN_FILTER_PROBE_REQ
#define WMI_SCAN_BYPASS_DFS_CHN
#define WMI_SCAN_CONTINUE_ON_ERROR
#define WMI_SCAN_FILTER_PROMISCUOS
#define WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS
#define WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ
#define WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ
#define WMI_SCAN_ADD_SPOOF_MAC_IN_PROBE_REQ
#define WMI_SCAN_OFFCHAN_MGMT_TX
#define WMI_SCAN_OFFCHAN_DATA_TX
#define WMI_SCAN_CAPTURE_PHY_ERROR
#define WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN
#define WMI_SCAN_FLAG_HALF_RATE_SUPPORT
#define WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT
#define WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ
#define WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ

#define WMI_SCAN_DWELL_MODE_MASK

enum {};

struct ath12k_wmi_hint_short_ssid_arg {};

struct ath12k_wmi_hint_bssid_arg {};

struct ath12k_wmi_scan_req_arg {};

struct wmi_ssid_arg {};

struct wmi_bssid_arg {};

#define WMI_SCAN_STOP_ONE
#define WMI_SCAN_STOP_VAP_ALL
#define WMI_SCAN_STOP_ALL

/* Prefix 0xA000 indicates that the scan request
 * is trigger by HOST
 */
#define ATH12K_SCAN_ID

enum scan_cancel_req_type {};

struct ath12k_wmi_scan_cancel_arg {};

struct wmi_bcn_send_from_host_cmd {};

#define WMI_CHAN_INFO_MODE
#define WMI_CHAN_INFO_HT40_PLUS
#define WMI_CHAN_INFO_PASSIVE
#define WMI_CHAN_INFO_ADHOC_ALLOWED
#define WMI_CHAN_INFO_AP_DISABLED
#define WMI_CHAN_INFO_DFS
#define WMI_CHAN_INFO_ALLOW_HT
#define WMI_CHAN_INFO_ALLOW_VHT
#define WMI_CHAN_INFO_CHAN_CHANGE_CAUSE_CSA
#define WMI_CHAN_INFO_HALF_RATE
#define WMI_CHAN_INFO_QUARTER_RATE
#define WMI_CHAN_INFO_DFS_FREQ2
#define WMI_CHAN_INFO_ALLOW_HE
#define WMI_CHAN_INFO_PSC

#define WMI_CHAN_REG_INFO1_MIN_PWR
#define WMI_CHAN_REG_INFO1_MAX_PWR
#define WMI_CHAN_REG_INFO1_MAX_REG_PWR
#define WMI_CHAN_REG_INFO1_REG_CLS

#define WMI_CHAN_REG_INFO2_ANT_MAX
#define WMI_CHAN_REG_INFO2_MAX_TX_PWR

struct ath12k_wmi_channel_params {} __packed;

enum wmi_sta_ps_mode {};

#define WMI_SMPS_MASK_LOWER_16BITS
#define WMI_SMPS_MASK_UPPER_3BITS
#define WMI_SMPS_PARAM_VALUE_SHIFT

#define ATH12K_WMI_FW_HANG_ASSERT_TYPE
#define ATH12K_WMI_FW_HANG_DELAY

/* type, 0:unused 1: ASSERT 2: not respond detect command
 * delay_time_ms, the simulate will delay time
 */

struct wmi_force_fw_hang_cmd {} __packed;

struct wmi_vdev_set_param_cmd {} __packed;

struct wmi_get_pdev_temperature_cmd {} __packed;

#define WMI_P2P_MAX_NOA_DESCRIPTORS

struct wmi_p2p_noa_event {} __packed;

struct ath12k_wmi_p2p_noa_descriptor {} __packed;

#define WMI_P2P_NOA_INFO_CHANGED_FLAG
#define WMI_P2P_NOA_INFO_INDEX
#define WMI_P2P_NOA_INFO_OPP_PS
#define WMI_P2P_NOA_INFO_CTWIN_TU
#define WMI_P2P_NOA_INFO_DESC_NUM

struct ath12k_wmi_p2p_noa_info {} __packed;

#define WMI_BEACON_TX_BUFFER_SIZE

#define WMI_EMA_BEACON_CNT
#define WMI_EMA_BEACON_IDX
#define WMI_EMA_BEACON_FIRST
#define WMI_EMA_BEACON_LAST

struct ath12k_wmi_bcn_tmpl_ema_arg {};

struct wmi_bcn_tmpl_cmd {} __packed;

struct wmi_p2p_go_set_beacon_ie_cmd {} __packed;

struct wmi_vdev_install_key_cmd {} __packed;

struct wmi_vdev_install_key_arg {};

#define WMI_MAX_SUPPORTED_RATES
#define WMI_HOST_MAX_HECAP_PHY_SIZE
#define WMI_HOST_MAX_HE_RATE_SET
#define WMI_HECAP_TXRX_MCS_NSS_IDX_80
#define WMI_HECAP_TXRX_MCS_NSS_IDX_160
#define WMI_HECAP_TXRX_MCS_NSS_IDX_80_80

struct wmi_rate_set_arg {};

struct ath12k_wmi_peer_assoc_arg {};

struct wmi_peer_assoc_complete_cmd {} __packed;

struct wmi_stop_scan_cmd {} __packed;

struct ath12k_wmi_scan_chan_list_arg {};

struct wmi_scan_chan_list_cmd {} __packed;

#define WMI_MGMT_SEND_DOWNLD_LEN

#define WMI_TX_PARAMS_DWORD0_POWER
#define WMI_TX_PARAMS_DWORD0_MCS_MASK
#define WMI_TX_PARAMS_DWORD0_NSS_MASK
#define WMI_TX_PARAMS_DWORD0_RETRY_LIMIT

#define WMI_TX_PARAMS_DWORD1_CHAIN_MASK
#define WMI_TX_PARAMS_DWORD1_BW_MASK
#define WMI_TX_PARAMS_DWORD1_PREAMBLE_TYPE
#define WMI_TX_PARAMS_DWORD1_FRAME_TYPE
#define WMI_TX_PARAMS_DWORD1_RSVD

struct wmi_mgmt_send_cmd {} __packed;

struct wmi_sta_powersave_mode_cmd {} __packed;

struct wmi_sta_smps_force_mode_cmd {} __packed;

struct wmi_sta_smps_param_cmd {} __packed;

struct ath12k_wmi_bcn_prb_info_params {} __packed;

enum {};

struct wmi_pdev_green_ap_ps_enable_cmd_param {} __packed;

struct ath12k_wmi_ap_ps_arg {};

enum set_init_cc_type {};

enum set_init_cc_flags {};

struct ath12k_wmi_init_country_arg {};

struct wmi_init_country_cmd {} __packed;

struct wmi_delba_send_cmd {} __packed;

struct wmi_addba_setresponse_cmd {} __packed;

struct wmi_addba_send_cmd {} __packed;

struct wmi_addba_clear_resp_cmd {} __packed;

#define DFS_PHYERR_UNIT_TEST_CMD
#define DFS_UNIT_TEST_MODULE
#define DFS_UNIT_TEST_TOKEN

enum dfs_test_args_idx {};

struct wmi_dfs_unit_test_arg {};

struct wmi_unit_test_cmd {} __packed;

#define MAX_SUPPORTED_RATES

struct ath12k_wmi_vht_rate_set_params {} __packed;

struct ath12k_wmi_he_rate_set_params {} __packed;

struct ath12k_wmi_eht_rate_set_params {} __packed;

#define MAX_REG_RULES
#define REG_ALPHA2_LEN
#define MAX_6G_REG_RULES
#define REG_US_5G_NUM_REG_RULES

enum wmi_start_event_param {};

struct wmi_vdev_start_resp_event {} __packed;

/* VDEV start response status codes */
enum wmi_vdev_start_resp_status_code {};

enum wmi_reg_6g_ap_type {};

enum wmi_reg_6g_client_type {};

/* Regulatory Rule Flags Passed by FW */
#define REGULATORY_CHAN_DISABLED
#define REGULATORY_CHAN_NO_IR
#define REGULATORY_CHAN_RADAR
#define REGULATORY_CHAN_NO_OFDM
#define REGULATORY_CHAN_INDOOR_ONLY

#define REGULATORY_CHAN_NO_HT40
#define REGULATORY_CHAN_NO_80MHZ
#define REGULATORY_CHAN_NO_160MHZ
#define REGULATORY_CHAN_NO_20MHZ
#define REGULATORY_CHAN_NO_10MHZ

enum {};

#define WMI_REG_CLIENT_MAX

struct wmi_reg_chan_list_cc_ext_event {} __packed;

struct ath12k_wmi_reg_rule_ext_params {} __packed;

struct wmi_vdev_delete_resp_event {} __packed;

struct wmi_peer_delete_resp_event {} __packed;

struct wmi_bcn_tx_status_event {} __packed;

struct wmi_vdev_stopped_event {} __packed;

struct wmi_pdev_bss_chan_info_event {} __packed;

#define WMI_VDEV_INSTALL_KEY_COMPL_STATUS_SUCCESS

struct wmi_vdev_install_key_compl_event {} __packed;

struct wmi_vdev_install_key_complete_arg {};

struct wmi_peer_assoc_conf_event {} __packed;

struct wmi_peer_assoc_conf_arg {};

struct wmi_fils_discovery_event {} __packed;

struct wmi_probe_resp_tx_status_event {} __packed;

struct wmi_pdev_ctl_failsafe_chk_event {} __packed;

struct ath12k_wmi_pdev_csa_event {} __packed;

struct ath12k_wmi_pdev_radar_event {} __packed;

struct wmi_pdev_temperature_event {} __packed;

#define WMI_RX_STATUS_OK
#define WMI_RX_STATUS_ERR_CRC
#define WMI_RX_STATUS_ERR_DECRYPT
#define WMI_RX_STATUS_ERR_MIC
#define WMI_RX_STATUS_ERR_KEY_CACHE_MISS

#define WLAN_MGMT_TXRX_HOST_MAX_ANTENNA

struct ath12k_wmi_mgmt_rx_arg {};

#define ATH_MAX_ANTENNA

struct ath12k_wmi_mgmt_rx_params {} __packed;

#define MAX_ANTENNA_EIGHT

struct wmi_mgmt_tx_compl_event {} __packed;

struct wmi_scan_event {} __packed;

struct wmi_peer_sta_kickout_arg {};

struct wmi_peer_sta_kickout_event {} __packed;

#define WMI_ROAM_REASON_MASK
#define WMI_ROAM_SUBNET_STATUS_MASK

enum wmi_roam_reason {};

struct wmi_roam_event {} __packed;

#define WMI_CHAN_INFO_START_RESP
#define WMI_CHAN_INFO_END_RESP

struct wmi_chan_info_event {} __packed;

struct ath12k_wmi_target_cap_arg {};

enum wmi_vdev_type {};

enum wmi_vdev_subtype {};

enum wmi_sta_powersave_param {};

enum wmi_sta_ps_param_uapsd {};

enum wmi_sta_ps_param_tx_wake_threshold {};

/* The maximum number of PS-Poll frames the FW will send in response to
 * traffic advertised in TIM before waking up (by sending a null frame with PS
 * = 0). Value 0 has a special meaning: there is no maximum count and the FW
 * will send as many PS-Poll as are necessary to retrieve buffered BU. This
 * parameter is used when the RX wake policy is
 * WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD and ignored when the RX wake
 * policy is WMI_STA_PS_RX_WAKE_POLICY_WAKE.
 */
enum wmi_sta_ps_param_pspoll_count {};

/* U-APSD configuration of peer station from (re)assoc request and TSPECs */
enum wmi_ap_ps_param_uapsd {};

/* U-APSD maximum service period of peer station */
enum wmi_ap_ps_peer_param_max_sp {};

enum wmi_ap_ps_peer_param {};

#define DISABLE_SIFS_RESPONSE_TRIGGER

#define WMI_MAX_KEY_INDEX
#define WMI_MAX_KEY_LEN

enum wmi_key_type {};

enum wmi_cipher_type {};

/* Value to disable fixed rate setting */
#define WMI_FIXED_RATE_NONE

#define ATH12K_RC_VERSION_OFFSET
#define ATH12K_RC_PREAMBLE_OFFSET
#define ATH12K_RC_NSS_OFFSET

#define ATH12K_HW_RATE_CODE(rate, nss, preamble)

/* Preamble types to be used with VDEV fixed rate configuration */
enum wmi_rate_preamble {};

/**
 * enum wmi_rtscts_prot_mode - Enable/Disable RTS/CTS and CTS2Self Protection.
 * @WMI_RTS_CTS_DISABLED: RTS/CTS protection is disabled.
 * @WMI_USE_RTS_CTS: RTS/CTS Enabled.
 * @WMI_USE_CTS2SELF: CTS to self protection Enabled.
 */
enum wmi_rtscts_prot_mode {};

/**
 * enum wmi_rtscts_profile - Selection of RTS CTS profile along with enabling
 *                           protection mode.
 * @WMI_RTSCTS_FOR_NO_RATESERIES: Neither of rate-series should use RTS-CTS
 * @WMI_RTSCTS_FOR_SECOND_RATESERIES: Only second rate-series will use RTS-CTS
 * @WMI_RTSCTS_ACROSS_SW_RETRIES: Only the second rate-series will use RTS-CTS,
 *                                but if there's a sw retry, both the rate
 *                                series will use RTS-CTS.
 * @WMI_RTSCTS_ERP: RTS/CTS used for ERP protection for every PPDU.
 * @WMI_RTSCTS_FOR_ALL_RATESERIES: Enable RTS-CTS for all rate series.
 */
enum wmi_rtscts_profile {};

#define WMI_SKB_HEADROOM

enum wmi_sta_ps_param_rx_wake_policy {};

/* Do not change existing values! Used by ath12k_frame_mode parameter
 * module parameter.
 */
enum ath12k_hw_txrx_mode {};

struct wmi_wmm_params {} __packed;

struct wmi_wmm_params_arg {};

struct wmi_vdev_set_wmm_params_cmd {} __packed;

struct wmi_wmm_params_all_arg {};

#define ATH12K_TWT_DEF_STA_CONG_TIMER_MS
#define ATH12K_TWT_DEF_DEFAULT_SLOT_SIZE
#define ATH12K_TWT_DEF_CONGESTION_THRESH_SETUP
#define ATH12K_TWT_DEF_CONGESTION_THRESH_TEARDOWN
#define ATH12K_TWT_DEF_CONGESTION_THRESH_CRITICAL
#define ATH12K_TWT_DEF_INTERFERENCE_THRESH_TEARDOWN
#define ATH12K_TWT_DEF_INTERFERENCE_THRESH_SETUP
#define ATH12K_TWT_DEF_MIN_NO_STA_SETUP
#define ATH12K_TWT_DEF_MIN_NO_STA_TEARDOWN
#define ATH12K_TWT_DEF_NO_OF_BCAST_MCAST_SLOTS
#define ATH12K_TWT_DEF_MIN_NO_TWT_SLOTS
#define ATH12K_TWT_DEF_MAX_NO_STA_TWT
#define ATH12K_TWT_DEF_MODE_CHECK_INTERVAL
#define ATH12K_TWT_DEF_ADD_STA_SLOT_INTERVAL
#define ATH12K_TWT_DEF_REMOVE_STA_SLOT_INTERVAL

struct wmi_twt_enable_params_cmd {} __packed;

struct wmi_twt_disable_params_cmd {} __packed;

struct wmi_obss_spatial_reuse_params_cmd {} __packed;

#define ATH12K_BSS_COLOR_COLLISION_SCAN_PERIOD_MS
#define ATH12K_OBSS_COLOR_COLLISION_DETECTION_DISABLE
#define ATH12K_OBSS_COLOR_COLLISION_DETECTION

#define ATH12K_BSS_COLOR_STA_PERIODS
#define ATH12K_BSS_COLOR_AP_PERIODS

struct wmi_obss_color_collision_cfg_params_cmd {} __packed;

struct wmi_bss_color_change_enable_params_cmd {} __packed;

#define ATH12K_IPV4_TH_SEED_SIZE
#define ATH12K_IPV6_TH_SEED_SIZE

struct ath12k_wmi_pdev_lro_config_cmd {} __packed;

#define ATH12K_WMI_SPECTRAL_COUNT_DEFAULT
#define ATH12K_WMI_SPECTRAL_PERIOD_DEFAULT
#define ATH12K_WMI_SPECTRAL_PRIORITY_DEFAULT
#define ATH12K_WMI_SPECTRAL_FFT_SIZE_DEFAULT
#define ATH12K_WMI_SPECTRAL_GC_ENA_DEFAULT
#define ATH12K_WMI_SPECTRAL_RESTART_ENA_DEFAULT
#define ATH12K_WMI_SPECTRAL_NOISE_FLOOR_REF_DEFAULT
#define ATH12K_WMI_SPECTRAL_INIT_DELAY_DEFAULT
#define ATH12K_WMI_SPECTRAL_NB_TONE_THR_DEFAULT
#define ATH12K_WMI_SPECTRAL_STR_BIN_THR_DEFAULT
#define ATH12K_WMI_SPECTRAL_WB_RPT_MODE_DEFAULT
#define ATH12K_WMI_SPECTRAL_RSSI_RPT_MODE_DEFAULT
#define ATH12K_WMI_SPECTRAL_RSSI_THR_DEFAULT
#define ATH12K_WMI_SPECTRAL_PWR_FORMAT_DEFAULT
#define ATH12K_WMI_SPECTRAL_RPT_MODE_DEFAULT
#define ATH12K_WMI_SPECTRAL_BIN_SCALE_DEFAULT
#define ATH12K_WMI_SPECTRAL_DBM_ADJ_DEFAULT
#define ATH12K_WMI_SPECTRAL_CHN_MASK_DEFAULT

struct ath12k_wmi_vdev_spectral_conf_arg {};

struct ath12k_wmi_vdev_spectral_conf_cmd {} __packed;

#define ATH12K_WMI_SPECTRAL_TRIGGER_CMD_TRIGGER
#define ATH12K_WMI_SPECTRAL_TRIGGER_CMD_CLEAR
#define ATH12K_WMI_SPECTRAL_ENABLE_CMD_ENABLE
#define ATH12K_WMI_SPECTRAL_ENABLE_CMD_DISABLE

struct ath12k_wmi_vdev_spectral_enable_cmd {} __packed;

struct ath12k_wmi_pdev_dma_ring_cfg_arg {};

struct ath12k_wmi_pdev_dma_ring_cfg_req_cmd {} __packed;

struct ath12k_wmi_dma_buf_release_fixed_params {} __packed;

struct ath12k_wmi_dma_buf_release_entry_params {} __packed;

#define WMI_SPECTRAL_META_INFO1_FREQ1
#define WMI_SPECTRAL_META_INFO1_FREQ2

#define WMI_SPECTRAL_META_INFO2_CHN_WIDTH

struct ath12k_wmi_dma_buf_release_meta_data_params {} __packed;

enum wmi_fils_discovery_cmd_type {};

struct wmi_fils_discovery_cmd {} __packed;

struct wmi_fils_discovery_tmpl_cmd {} __packed;

struct wmi_probe_tmpl_cmd {} __packed;

#define MAX_RADIOS

#define WMI_SERVICE_READY_TIMEOUT_HZ
#define WMI_SEND_TIMEOUT_HZ

struct ath12k_wmi_pdev {};

struct ath12k_wmi_base {};

struct wmi_pdev_set_bios_interface_cmd {} __packed;

enum wmi_bios_param_type {};

struct wmi_pdev_set_bios_sar_table_cmd {} __packed;

struct wmi_pdev_set_bios_geo_table_cmd {} __packed;

#define ATH12K_FW_STATS_BUF_SIZE

enum wmi_sys_cap_info_flags {};

#define WMI_RFKILL_CFG_GPIO_PIN_NUM
#define WMI_RFKILL_CFG_RADIO_LEVEL
#define WMI_RFKILL_CFG_PIN_AS_GPIO

enum wmi_rfkill_enable_radio {};

enum wmi_rfkill_radio_state {};

struct wmi_rfkill_state_change_event {} __packed;

struct wmi_twt_enable_event {} __packed;

struct wmi_twt_disable_event {} __packed;

/* WOW structures */
enum wmi_wow_wakeup_event {};

enum wmi_wow_interface_cfg {};

#define C2S

static inline const char *wow_wakeup_event(enum wmi_wow_wakeup_event ev)
{}

enum wmi_wow_wake_reason {};

static inline const char *wow_reason(enum wmi_wow_wake_reason reason)
{}

#undef C2S

#define WOW_DEFAULT_BITMAP_PATTERN_SIZE
#define WOW_DEFAULT_BITMASK_SIZE

#define WOW_MIN_PATTERN_SIZE
#define WOW_MAX_PATTERN_SIZE
#define WOW_MAX_PKT_OFFSET
#define WOW_HDR_LEN
#define WOW_MAX_REDUCE

struct wmi_wow_bitmap_pattern_params {} __packed;

struct wmi_wow_add_pattern_cmd {} __packed;

struct wmi_wow_del_pattern_cmd {} __packed;

enum wmi_tlv_pattern_type {};

struct wmi_wow_add_del_event_cmd {} __packed;

struct wmi_wow_enable_cmd {}  __packed;

struct wmi_wow_host_wakeup_cmd {} __packed;

struct wmi_wow_ev_param {} __packed;

struct wmi_wow_ev_pg_fault_param {} __packed;

struct wmi_wow_ev_arg {};

#define WMI_PNO_MAX_SCHED_SCAN_PLANS
#define WMI_PNO_MAX_SCHED_SCAN_PLAN_INT
#define WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS
#define WMI_PNO_MAX_NETW_CHANNELS
#define WMI_PNO_MAX_NETW_CHANNELS_EX
#define WMI_PNO_MAX_SUPP_NETWORKS
#define WMI_PNO_MAX_IE_LENGTH

/* size based of dot11 declaration without extra IEs as we will not carry those for PNO */
#define WMI_PNO_MAX_PB_REQ_SIZE

#define WMI_PNO_24GHZ_DEFAULT_CH
#define WMI_PNO_5GHZ_DEFAULT_CH

#define WMI_ACTIVE_MAX_CHANNEL_TIME
#define WMI_PASSIVE_MAX_CHANNEL_TIME

/* SSID broadcast type */
enum wmi_ssid_bcast_type {};

#define WMI_NLO_MAX_SSIDS
#define WMI_NLO_MAX_CHAN

#define WMI_NLO_CONFIG_STOP
#define WMI_NLO_CONFIG_START
#define WMI_NLO_CONFIG_RESET
#define WMI_NLO_CONFIG_SLOW_SCAN
#define WMI_NLO_CONFIG_FAST_SCAN
#define WMI_NLO_CONFIG_SSID_HIDE_EN

/* This bit is used to indicate if EPNO or supplicant PNO is enabled.
 * Only one of them can be enabled at a given time
 */
#define WMI_NLO_CONFIG_ENLO
#define WMI_NLO_CONFIG_SCAN_PASSIVE
#define WMI_NLO_CONFIG_ENLO_RESET
#define WMI_NLO_CONFIG_SPOOFED_MAC_IN_PROBE_REQ
#define WMI_NLO_CONFIG_RANDOM_SEQ_NO_IN_PROBE_REQ
#define WMI_NLO_CONFIG_ENABLE_IE_WHITELIST_IN_PROBE_REQ
#define WMI_NLO_CONFIG_ENABLE_CNLO_RSSI_CONFIG

struct wmi_nlo_ssid_params {} __packed;

struct wmi_nlo_enc_params {} __packed;

struct wmi_nlo_auth_params {} __packed;

struct wmi_nlo_bcast_nw_params {} __packed;

struct wmi_nlo_rssi_params {} __packed;

struct nlo_configured_params {} __packed;

struct wmi_network_type_arg {};

struct wmi_pno_scan_req_arg {};

struct wmi_wow_nlo_config_cmd {} __packed;

/* Definition of HW data filtering */
enum hw_data_filter_type {};

struct wmi_hw_data_filter_cmd {} __packed;

struct wmi_hw_data_filter_arg {};

#define WMI_IPV6_UC_TYPE
#define WMI_IPV6_AC_TYPE

#define WMI_IPV6_MAX_COUNT
#define WMI_IPV4_MAX_COUNT

struct wmi_arp_ns_offload_arg {};

#define WMI_MAX_NS_OFFLOADS
#define WMI_MAX_ARP_OFFLOADS

#define WMI_ARPOL_FLAGS_VALID
#define WMI_ARPOL_FLAGS_MAC_VALID
#define WMI_ARPOL_FLAGS_REMOTE_IP_VALID

struct wmi_arp_offload_params {} __packed;

#define WMI_NSOL_FLAGS_VALID
#define WMI_NSOL_FLAGS_MAC_VALID
#define WMI_NSOL_FLAGS_REMOTE_IP_VALID
#define WMI_NSOL_FLAGS_IS_IPV6_ANYCAST

#define WMI_NSOL_MAX_TARGET_IPS

struct wmi_ns_offload_params {} __packed;

struct wmi_set_arp_ns_offload_cmd {} __packed;

#define GTK_OFFLOAD_OPCODE_MASK
#define GTK_OFFLOAD_ENABLE_OPCODE
#define GTK_OFFLOAD_DISABLE_OPCODE
#define GTK_OFFLOAD_REQUEST_STATUS_OPCODE

#define GTK_OFFLOAD_KEK_BYTES
#define GTK_OFFLOAD_KCK_BYTES
#define GTK_REPLAY_COUNTER_BYTES
#define WMI_MAX_KEY_LEN
#define IGTK_PN_SIZE

struct wmi_gtk_offload_status_event {} __packed;

struct wmi_gtk_rekey_offload_cmd {} __packed;

struct wmi_sta_keepalive_cmd {} __packed;

struct wmi_sta_keepalive_arp_resp_params {} __packed;

struct wmi_sta_keepalive_arg {};

enum wmi_sta_keepalive_method {};

#define WMI_STA_KEEPALIVE_INTERVAL_DEFAULT
#define WMI_STA_KEEPALIVE_INTERVAL_DISABLE

void ath12k_wmi_init_qcn9274(struct ath12k_base *ab,
			     struct ath12k_wmi_resource_config_arg *config);
void ath12k_wmi_init_wcn7850(struct ath12k_base *ab,
			     struct ath12k_wmi_resource_config_arg *config);
int ath12k_wmi_cmd_send(struct ath12k_wmi_pdev *wmi, struct sk_buff *skb,
			u32 cmd_id);
struct sk_buff *ath12k_wmi_alloc_skb(struct ath12k_wmi_base *wmi_sc, u32 len);
int ath12k_wmi_mgmt_send(struct ath12k *ar, u32 vdev_id, u32 buf_id,
			 struct sk_buff *frame);
int ath12k_wmi_p2p_go_bcn_ie(struct ath12k *ar, u32 vdev_id,
			     const u8 *p2p_ie);
int ath12k_wmi_bcn_tmpl(struct ath12k *ar, u32 vdev_id,
			struct ieee80211_mutable_offsets *offs,
			struct sk_buff *bcn,
			struct ath12k_wmi_bcn_tmpl_ema_arg *ema_args);
int ath12k_wmi_vdev_down(struct ath12k *ar, u8 vdev_id);
int ath12k_wmi_vdev_up(struct ath12k *ar, struct ath12k_wmi_vdev_up_params *params);
int ath12k_wmi_vdev_stop(struct ath12k *ar, u8 vdev_id);
int ath12k_wmi_vdev_start(struct ath12k *ar, struct wmi_vdev_start_req_arg *arg,
			  bool restart);
int ath12k_wmi_set_peer_param(struct ath12k *ar, const u8 *peer_addr,
			      u32 vdev_id, u32 param_id, u32 param_val);
int ath12k_wmi_pdev_set_param(struct ath12k *ar, u32 param_id,
			      u32 param_value, u8 pdev_id);
int ath12k_wmi_pdev_set_ps_mode(struct ath12k *ar, int vdev_id, u32 enable);
int ath12k_wmi_wait_for_unified_ready(struct ath12k_base *ab);
int ath12k_wmi_cmd_init(struct ath12k_base *ab);
int ath12k_wmi_wait_for_service_ready(struct ath12k_base *ab);
int ath12k_wmi_connect(struct ath12k_base *ab);
int ath12k_wmi_pdev_attach(struct ath12k_base *ab,
			   u8 pdev_id);
int ath12k_wmi_attach(struct ath12k_base *ab);
void ath12k_wmi_detach(struct ath12k_base *ab);
int ath12k_wmi_vdev_create(struct ath12k *ar, u8 *macaddr,
			   struct ath12k_wmi_vdev_create_arg *arg);
int ath12k_wmi_send_peer_create_cmd(struct ath12k *ar,
				    struct ath12k_wmi_peer_create_arg *arg);
int ath12k_wmi_vdev_set_param_cmd(struct ath12k *ar, u32 vdev_id,
				  u32 param_id, u32 param_value);

int ath12k_wmi_set_sta_ps_param(struct ath12k *ar, u32 vdev_id,
				u32 param, u32 param_value);
int ath12k_wmi_force_fw_hang_cmd(struct ath12k *ar, u32 type, u32 delay_time_ms);
int ath12k_wmi_send_peer_delete_cmd(struct ath12k *ar,
				    const u8 *peer_addr, u8 vdev_id);
int ath12k_wmi_vdev_delete(struct ath12k *ar, u8 vdev_id);
void ath12k_wmi_start_scan_init(struct ath12k *ar,
				struct ath12k_wmi_scan_req_arg *arg);
int ath12k_wmi_send_scan_start_cmd(struct ath12k *ar,
				   struct ath12k_wmi_scan_req_arg *arg);
int ath12k_wmi_send_scan_stop_cmd(struct ath12k *ar,
				  struct ath12k_wmi_scan_cancel_arg *arg);
int ath12k_wmi_send_wmm_update_cmd(struct ath12k *ar, u32 vdev_id,
				   struct wmi_wmm_params_all_arg *param);
int ath12k_wmi_pdev_suspend(struct ath12k *ar, u32 suspend_opt,
			    u32 pdev_id);
int ath12k_wmi_pdev_resume(struct ath12k *ar, u32 pdev_id);

int ath12k_wmi_send_peer_assoc_cmd(struct ath12k *ar,
				   struct ath12k_wmi_peer_assoc_arg *arg);
int ath12k_wmi_vdev_install_key(struct ath12k *ar,
				struct wmi_vdev_install_key_arg *arg);
int ath12k_wmi_pdev_bss_chan_info_request(struct ath12k *ar,
					  enum wmi_bss_chan_info_req_type type);
int ath12k_wmi_send_pdev_temperature_cmd(struct ath12k *ar);
int ath12k_wmi_send_peer_flush_tids_cmd(struct ath12k *ar,
					u8 peer_addr[ETH_ALEN],
					u32 peer_tid_bitmap,
					u8 vdev_id);
int ath12k_wmi_send_set_ap_ps_param_cmd(struct ath12k *ar, u8 *peer_addr,
					struct ath12k_wmi_ap_ps_arg *arg);
int ath12k_wmi_send_scan_chan_list_cmd(struct ath12k *ar,
				       struct ath12k_wmi_scan_chan_list_arg *arg);
int ath12k_wmi_send_dfs_phyerr_offload_enable_cmd(struct ath12k *ar,
						  u32 pdev_id);
int ath12k_wmi_addba_clear_resp(struct ath12k *ar, u32 vdev_id, const u8 *mac);
int ath12k_wmi_addba_send(struct ath12k *ar, u32 vdev_id, const u8 *mac,
			  u32 tid, u32 buf_size);
int ath12k_wmi_addba_set_resp(struct ath12k *ar, u32 vdev_id, const u8 *mac,
			      u32 tid, u32 status);
int ath12k_wmi_delba_send(struct ath12k *ar, u32 vdev_id, const u8 *mac,
			  u32 tid, u32 initiator, u32 reason);
int ath12k_wmi_send_bcn_offload_control_cmd(struct ath12k *ar,
					    u32 vdev_id, u32 bcn_ctrl_op);
int ath12k_wmi_send_init_country_cmd(struct ath12k *ar,
				     struct ath12k_wmi_init_country_arg *arg);
int ath12k_wmi_peer_rx_reorder_queue_setup(struct ath12k *ar,
					   int vdev_id, const u8 *addr,
					   dma_addr_t paddr, u8 tid,
					   u8 ba_window_size_valid,
					   u32 ba_window_size);
int
ath12k_wmi_rx_reord_queue_remove(struct ath12k *ar,
				 struct ath12k_wmi_rx_reorder_queue_remove_arg *arg);
int ath12k_wmi_send_pdev_set_regdomain(struct ath12k *ar,
				       struct ath12k_wmi_pdev_set_regdomain_arg *arg);
int ath12k_wmi_simulate_radar(struct ath12k *ar);
int ath12k_wmi_send_twt_enable_cmd(struct ath12k *ar, u32 pdev_id);
int ath12k_wmi_send_twt_disable_cmd(struct ath12k *ar, u32 pdev_id);
int ath12k_wmi_send_obss_spr_cmd(struct ath12k *ar, u32 vdev_id,
				 struct ieee80211_he_obss_pd *he_obss_pd);
int ath12k_wmi_obss_color_cfg_cmd(struct ath12k *ar, u32 vdev_id,
				  u8 bss_color, u32 period,
				  bool enable);
int ath12k_wmi_send_bss_color_change_enable_cmd(struct ath12k *ar, u32 vdev_id,
						bool enable);
int ath12k_wmi_pdev_lro_cfg(struct ath12k *ar, int pdev_id);
int ath12k_wmi_pdev_dma_ring_cfg(struct ath12k *ar,
				 struct ath12k_wmi_pdev_dma_ring_cfg_arg *arg);
int ath12k_wmi_vdev_spectral_enable(struct ath12k *ar, u32 vdev_id,
				    u32 trigger, u32 enable);
int ath12k_wmi_vdev_spectral_conf(struct ath12k *ar,
				  struct ath12k_wmi_vdev_spectral_conf_arg *arg);
int ath12k_wmi_fils_discovery_tmpl(struct ath12k *ar, u32 vdev_id,
				   struct sk_buff *tmpl);
int ath12k_wmi_fils_discovery(struct ath12k *ar, u32 vdev_id, u32 interval,
			      bool unsol_bcast_probe_resp_enabled);
int ath12k_wmi_probe_resp_tmpl(struct ath12k *ar, u32 vdev_id,
			       struct sk_buff *tmpl);
int ath12k_wmi_set_hw_mode(struct ath12k_base *ab,
			   enum wmi_host_hw_mode_config_type mode);
int ath12k_wmi_set_bios_cmd(struct ath12k_base *ab, u32 param_id,
			    const u8 *buf, size_t buf_len);
int ath12k_wmi_set_bios_sar_cmd(struct ath12k_base *ab, const u8 *psar_table);
int ath12k_wmi_set_bios_geo_cmd(struct ath12k_base *ab, const u8 *pgeo_table);

static inline u32
ath12k_wmi_caps_ext_get_pdev_id(const struct ath12k_wmi_caps_ext_params *param)
{}

static inline u32
ath12k_wmi_caps_ext_get_hw_link_id(const struct ath12k_wmi_caps_ext_params *param)
{}

static inline u32
ath12k_wmi_mac_phy_get_pdev_id(const struct ath12k_wmi_mac_phy_caps_params *param)
{}

static inline u32
ath12k_wmi_mac_phy_get_hw_link_id(const struct ath12k_wmi_mac_phy_caps_params *param)
{}

int ath12k_wmi_wow_host_wakeup_ind(struct ath12k *ar);
int ath12k_wmi_wow_enable(struct ath12k *ar);
int ath12k_wmi_wow_del_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id);
int ath12k_wmi_wow_add_pattern(struct ath12k *ar, u32 vdev_id, u32 pattern_id,
			       const u8 *pattern, const u8 *mask,
			       int pattern_len, int pattern_offset);
int ath12k_wmi_wow_add_wakeup_event(struct ath12k *ar, u32 vdev_id,
				    enum wmi_wow_wakeup_event event,
				    u32 enable);
int ath12k_wmi_wow_config_pno(struct ath12k *ar, u32 vdev_id,
			      struct wmi_pno_scan_req_arg  *pno_scan);
int ath12k_wmi_hw_data_filter_cmd(struct ath12k *ar,
				  struct wmi_hw_data_filter_arg *arg);
int ath12k_wmi_arp_ns_offload(struct ath12k *ar,
			      struct ath12k_vif *arvif,
			      struct wmi_arp_ns_offload_arg *offload,
			      bool enable);
int ath12k_wmi_gtk_rekey_offload(struct ath12k *ar,
				 struct ath12k_vif *arvif, bool enable);
int ath12k_wmi_gtk_rekey_getinfo(struct ath12k *ar,
				 struct ath12k_vif *arvif);
int ath12k_wmi_sta_keepalive(struct ath12k *ar,
			     const struct wmi_sta_keepalive_arg *arg);

#endif