samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Add non-tlv APIs for new WMI commands and support for old commands

Browse Source 
Implement following WMI commands and corresponding event extraction
APIs added for WIN release-
WMI_PEER_GID_USERPOS_LIST_CMDID
WMI_PEER_TX_MU_TXMIT_RSTCNT_CMDID
WMI_PEER_TX_MU_TXMIT_COUNT_CMDID
WMI_PDEV_CHECK_CAL_VERSION_CMDID
WMI_BTCOEX_CFG_CMDID

Additions to following existing WMI commands-
WMI_MU_CAL_START_CMDID
WMI_SET_LTEU_CONFIG_CMDID
WMI_PDEV_GET_TPC_CONFIG_CMDID
WMI_START_SCAN_CMDID

Change-Id: Ifd43addf196f2bc3cbff33671ef66202b8b0b487
CRs-Fixed: 1059400
This commit is contained in:
Sathish Kumar
2016-11-14 17:44:29 +05:30
committed by qcabuildsw
parent 3fb189b406
commit 4f30c00e1c
6 changed files with 822 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
wmi/inc/wmi_unified_api.h
View File

@@ -873,6 +873,19 @@ QDF_STATUS wmi_unified_pdev_get_tpc_config_cmd_send(void *wmi_hdl,
QDF_STATUS wmi_unified_set_bwf_cmd_send(void *wmi_hdl, QDF_STATUS wmi_unified_set_bwf_cmd_send(void *wmi_hdl,
struct set_bwf_params *param); struct set_bwf_params *param);
QDF_STATUS wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value);
QDF_STATUS wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value);
QDF_STATUS wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl,
uint32_t value);
QDF_STATUS wmi_send_pdev_caldata_version_check_cmd(void *wmi_hdl,
uint32_t value);
QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl,
int value);
QDF_STATUS wmi_unified_set_atf_cmd_send(void *wmi_hdl, QDF_STATUS wmi_unified_set_atf_cmd_send(void *wmi_hdl,
struct set_atf_params *param); struct set_atf_params *param);
@@ -1157,6 +1170,18 @@ QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf,
QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf, QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf,
wmi_host_mu_report_event *param); wmi_host_mu_report_event *param);
QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf,
uint8_t idx, wmi_host_mu_db_entry *param);
QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf,
wmi_host_peer_txmu_cnt_event *param);
QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl,
void *evt_buf, wmi_host_peer_gid_userpos_list_event *param);
QDF_STATUS wmi_extract_pdev_caldata_version_check_ev_param(void *wmi_hdl,
void *evt_buf, wmi_host_pdev_check_cal_version_event *param);
QDF_STATUS wmi_extract_pdev_tpc_config_ev_param(void *wmi_hdl, void *evt_buf, QDF_STATUS wmi_extract_pdev_tpc_config_ev_param(void *wmi_hdl, void *evt_buf,
wmi_host_pdev_tpc_config_event *param); wmi_host_pdev_tpc_config_event *param);
@@ -1269,6 +1294,12 @@ QDF_STATUS wmi_extract_peer_stats(void *wmi_hdl, void *evt_buf,
QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf, QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf,
wmi_host_tx_data_traffic_ctrl_event *ev); wmi_host_tx_data_traffic_ctrl_event *ev);
QDF_STATUS wmi_extract_atf_peer_stats_ev(void *wmi_hdl, void *evt_buf,
wmi_host_atf_peer_stats_event *ev);
QDF_STATUS wmi_extract_atf_token_info_ev(void *wmi_hdl, void *evt_buf,
uint8_t idx, wmi_host_atf_peer_stats_info *atf_token_info);
QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf, QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf,
uint32_t index, wmi_host_vdev_stats *vdev_stats); uint32_t index, wmi_host_vdev_stats *vdev_stats);

13
wmi/inc/wmi_unified_non_tlv.h
View File

@@ -124,3 +124,16 @@ QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle,
QDF_STATUS send_scan_chan_list_cmd_non_tlv(wmi_unified_t wmi_handle, QDF_STATUS send_scan_chan_list_cmd_non_tlv(wmi_unified_t wmi_handle,
struct scan_chan_list_params *param); struct scan_chan_list_params *param);
QDF_STATUS send_get_user_position_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS send_reset_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS send_get_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle);
QDF_STATUS send_pdev_caldata_version_check_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS send_btcoex_wlan_priority_cmd_non_tlv(wmi_unified_t wmi_handle,
int value);

165
wmi/inc/wmi_unified_param.h
View File

@@ -127,6 +127,9 @@
#define MAX_SUPPORTED_RATES 128 #define MAX_SUPPORTED_RATES 128
#define WMI_HOST_MAX_BUFFER_SIZE 1712 #define WMI_HOST_MAX_BUFFER_SIZE 1712
#define WMI_HAL_MAX_SANTENNA 4 #define WMI_HAL_MAX_SANTENNA 4
#define WMI_HOST_PDEV_VI_PRIORITY_BIT (1<<2)
#define WMI_HOST_PDEV_BEACON_PRIORITY_BIT (1<<4)
#define WMI_HOST_PDEV_MGMT_PRIORITY_BIT (1<<5)
#ifdef CONFIG_WIN #ifdef CONFIG_WIN
#if ATH_SUPPORT_FIPS #if ATH_SUPPORT_FIPS
@@ -145,6 +148,17 @@
(_var) |= (((_v) << (_f##_S)) & (_f)); \ (_var) |= (((_v) << (_f##_S)) & (_f)); \
} while (0) } while (0)
/* vdev capabilities bit mask */
#define WMI_HOST_VDEV_BEACON_SUPPORT 0x1
#define WMI_HOST_VDEV_WDS_LRN_ENABLED 0x2
#define WMI_HOST_VDEV_VOW_ENABLED 0x4
#define WMI_HOST_VDEV_IS_BEACON_SUPPORTED(param) \
((param) & WMI_HOST_VDEV_BEACON_SUPPORT)
#define WMI_HOST_VDEV_IS_WDS_LRN_ENABLED(param) \
((param) & WMI_HOST_VDEV_WDS_LRN_ENABLED)
#define WMI_HOST_VDEV_IS_VOW_ENABLED(param) \
((param) & WMI_HOST_VDEV_VOW_ENABLED)
/* TXBF capabilities masks */ /* TXBF capabilities masks */
#define WMI_HOST_TXBF_CONF_SU_TX_BFEE_S 0 #define WMI_HOST_TXBF_CONF_SU_TX_BFEE_S 0
#define WMI_HOST_TXBF_CONF_SU_TX_BFEE_M 0x1 #define WMI_HOST_TXBF_CONF_SU_TX_BFEE_M 0x1
@@ -1051,6 +1065,8 @@ struct scan_start_params {
uint16_t uie_fieldOffset; uint16_t uie_fieldOffset;
uint8_t mac_add_bytes[IEEE80211_ADDR_LEN]; uint8_t mac_add_bytes[IEEE80211_ADDR_LEN];
#ifndef CONFIG_MCL #ifndef CONFIG_MCL
bool half_rate;
bool quarter_rate;
bool is_strict_pscan_en; bool is_strict_pscan_en;
bool is_promiscous_mode; bool is_promiscous_mode;
bool is_phy_error; bool is_phy_error;
@@ -3353,6 +3369,18 @@ typedef struct {
*/ */
uint32_t fw_feature_bitmap; uint32_t fw_feature_bitmap;
/* WLAN priority GPIO number
* The target uses a GPIO pin to indicate when it is transmitting
* high-priority traffic (e.g. beacon, management, or AC_VI) or
* low-priority traffic (e.g. AC_BE, AC_BK). The HW uses this
* WLAN GPIO pin to determine whether to abort WLAN tx in favor of
* BT activity.
* Which GPIO is used for this WLAN tx traffic priority specification
* varies between platforms, so the host needs to indicate to the
* target which GPIO to use.
*/
uint32_t wlan_priority_gpio;
/* add new members here */ /* add new members here */
} wmi_host_ext_resource_config; } wmi_host_ext_resource_config;
@@ -3733,6 +3761,11 @@ struct mu_scan_params {
uint8_t type; uint8_t type;
uint32_t duration; uint32_t duration;
uint32_t lteu_tx_power; uint32_t lteu_tx_power;
uint32_t rssi_thr_bssid;
uint32_t rssi_thr_sta;
uint32_t rssi_thr_sc;
uint32_t plmn_id;
uint32_t alpha_num_bssid;
}; };
/** /**
@@ -3757,6 +3790,7 @@ struct lteu_config_params {
uint32_t lteu_scan_timeout; uint32_t lteu_scan_timeout;
uint32_t alpha_num_bssid; uint32_t alpha_num_bssid;
uint32_t wifi_tx_power; uint32_t wifi_tx_power;
uint32_t allow_err_packets;
}; };
struct wmi_macaddr_t { struct wmi_macaddr_t {
@@ -4831,6 +4865,10 @@ typedef enum {
wmi_soc_hw_mode_transition_event_id, wmi_soc_hw_mode_transition_event_id,
wmi_soc_set_dual_mac_config_resp_event_id, wmi_soc_set_dual_mac_config_resp_event_id,
wmi_tx_data_traffic_ctrl_event_id, wmi_tx_data_traffic_ctrl_event_id,
wmi_peer_tx_mu_txmit_count_event_id,
wmi_peer_gid_userpos_list_event_id,
wmi_pdev_check_cal_version_event_id,
wmi_atf_peer_stats_event_id,
wmi_events_max, wmi_events_max,
} wmi_conv_event_id; } wmi_conv_event_id;
@@ -4969,6 +5007,8 @@ typedef enum {
wmi_pdev_param_rx_chain_mask_5g, wmi_pdev_param_rx_chain_mask_5g,
wmi_pdev_param_tx_chain_mask_cck, wmi_pdev_param_tx_chain_mask_cck,
wmi_pdev_param_tx_chain_mask_1ss, wmi_pdev_param_tx_chain_mask_1ss,
wmi_pdev_param_enable_btcoex,
wmi_pdev_param_atf_peer_stats,
wmi_pdev_param_max, wmi_pdev_param_max,
} wmi_conv_pdev_params_id; } wmi_conv_pdev_params_id;
@@ -5073,6 +5113,9 @@ typedef enum {
wmi_vdev_param_mcc_rtscts_protection_enable, wmi_vdev_param_mcc_rtscts_protection_enable,
wmi_vdev_param_mcc_broadcast_probe_enable, wmi_vdev_param_mcc_broadcast_probe_enable,
wmi_vdev_param_capabilities, wmi_vdev_param_capabilities,
wmi_vdev_param_mgmt_tx_power,
wmi_vdev_param_atf_ssid_sched_policy,
wmi_vdev_param_disable_dyn_bw_rts,
wmi_vdev_param_max, wmi_vdev_param_max,
} wmi_conv_vdev_param_id; } wmi_conv_vdev_param_id;
@@ -5182,6 +5225,7 @@ typedef enum {
wmi_service_tx_mode_push_only, wmi_service_tx_mode_push_only,
wmi_service_tx_mode_push_pull, wmi_service_tx_mode_push_pull,
wmi_service_tx_mode_dynamic, wmi_service_tx_mode_dynamic,
wmi_service_check_cal_version,
wmi_services_max, wmi_services_max,
} wmi_conv_service_ids; } wmi_conv_service_ids;
@@ -5649,18 +5693,40 @@ typedef enum {
/* max MU alg combinations supported by target */ /* max MU alg combinations supported by target */
#define WMI_HOST_MU_MAX_ALGO_TYPE 3 #define WMI_HOST_MU_MAX_ALGO_TYPE 3
/**
* struct wmi_host_mu_db_entry
* @event_type: 0=AP, 1=STA, 2=Small Cell(SC)
* @bssid_mac_addr: Transmitter MAC if entry is WiFi node. PLMNID if SC
* @tx_addr: Transmitter MAC if entry is WiFi node. PLMNID if SC
* @avg_duration_us: Avg. duration for which node was transmitting
* @avg_rssi: Avg. RSSI of all TX packets by node. Unit dBm
* @mu_percent: % medium utilization by node
*/
typedef struct {
uint32_t entry_type;
wmi_host_mac_addr bssid_mac_addr;
wmi_host_mac_addr tx_addr;
uint32_t avg_duration_us;
uint32_t avg_rssi;
uint32_t mu_percent;
} wmi_host_mu_db_entry;
/** /**
* struct wmi_host_mu_report_event - WMI_MU_REPORT_EVENTID * struct wmi_host_mu_report_event - WMI_MU_REPORT_EVENTID
* @mu_request_id: request id * @mu_request_id: request id
* @status_reason: MU_STATUS_REASON * @status_reason: MU_STATUS_REASON
* @total_mu: MU_ALG_TYPE combinations * @total_mu: MU_ALG_TYPE combinations
* @num_active_bssid: number of active bssid * @num_active_bssid: number of active bssid
* @hidden_node_mu : hidden node algo MU per bin
* @num_TA_entries : No. of entries found in MU db report
*/ */
typedef struct { typedef struct {
uint32_t mu_request_id; uint32_t mu_request_id;
uint32_t status_reason; uint32_t status_reason;
uint32_t total_mu[WMI_HOST_MU_MAX_ALGO_TYPE]; uint32_t total_mu[WMI_HOST_MU_MAX_ALGO_TYPE];
uint32_t num_active_bssid; uint32_t num_active_bssid;
uint32_t hidden_node_mu[LTEU_MAX_BINS];
uint32_t num_TA_entries;
} wmi_host_mu_report_event; } wmi_host_mu_report_event;
/** /**
@@ -6572,6 +6638,65 @@ typedef struct {
uint32_t ctrl_cmd; uint32_t ctrl_cmd;
} wmi_host_tx_data_traffic_ctrl_event; } wmi_host_tx_data_traffic_ctrl_event;
enum {
WMI_HOST_ATF_PEER_STATS_DISABLED = 0,
WMI_HOST_ATF_PEER_STATS_ENABLED = 1,
};
#define WMI_HOST_ATF_PEER_STATS_GET_PEER_AST_IDX(token_info) \
(token_info.field1 & 0xffff)
#define WMI_HOST_ATF_PEER_STATS_GET_USED_TOKENS(token_info) \
((token_info.field2 & 0xffff0000) >> 16)
#define WMI_HOST_ATF_PEER_STATS_GET_UNUSED_TOKENS(token_info) \
(token_info.field2 & 0xffff)
#define WMI_HOST_ATF_PEER_STATS_SET_PEER_AST_IDX(token_info, peer_ast_idx) \
do { \
token_info.field1 &= 0xffff0000; \
token_info.field1 |= ((peer_ast_idx) & 0xffff); \
} while (0)
#define WMI_HOST_ATF_PEER_STATS_SET_USED_TOKENS(token_info, used_token) \
do { \
token_info.field2 &= 0x0000ffff; \
token_info.field2 |= (((used_token) & 0xffff) << 16); \
} while (0)
#define WMI_HOST_ATF_PEER_STATS_SET_UNUSED_TOKENS(token_info, unused_token) \
do { \
token_info.field2 &= 0xffff0000; \
token_info.field2 |= ((unused_token) & 0xffff); \
} while (0)
typedef struct {
/**
* field1 contains:
* bits 15:0 peer_ast_index WMI_ATF_PEER_STATS_GET_PEER_AST_IDX
* WMI_ATF_PEER_STATS_SET_PEER_AST_IDX
* bits 31:16 reserved
*
* field2 contains:
* bits 15:0 used tokens WMI_ATF_PEER_STATS_GET_USED_TOKENS
* WMI_ATF_PEER_STATS_SET_USED_TOKENS
* bits 31:16 unused tokens WMI_ATF_PEER_STATS_GET_UNUSED_TOKENS
* WMI_ATF_PEER_STATS_SET_UNUSED_TOKENS
*
* field3 for future use
*/
uint32_t field1;
uint32_t field2;
uint32_t field3;
} wmi_host_atf_peer_stats_info;
typedef struct {
uint32_t num_atf_peers; /** number of peers in token_info_list */
uint32_t comp_usable_airtime; /** computed usable airtime in tokens */
uint32_t reserved[4]; /** reserved for future use */
wmi_host_atf_peer_stats_info token_info_list[1/*num_atf_peers*/];
} wmi_host_atf_peer_stats_event;
/** /**
* struct wmi_host_ath_dcs_cw_int * struct wmi_host_ath_dcs_cw_int
* @channel: either number or freq in mhz * @channel: either number or freq in mhz
@@ -6841,5 +6966,43 @@ struct WMI_HOST_HAL_REG_CAPABILITIES_EXT {
uint32_t low_5ghz_chan; uint32_t low_5ghz_chan;
uint32_t high_5ghz_chan; uint32_t high_5ghz_chan;
}; };
#endif /* _WMI_UNIFIED_PARAM_H_ */
/*
* struct wmi_host_peer_txmu_cnt_event
* @tx_mu_transmitted - MU-MIMO tx count
*/
typedef struct {
uint32_t tx_mu_transmitted;
} wmi_host_peer_txmu_cnt_event;
/*
* struct wmi_peer_gid_userpos_list_event
* @usr_list - User list
*/
#define GID_OVERLOAD_GROUP_COUNT 15
typedef struct {
uint32_t usr_list[GID_OVERLOAD_GROUP_COUNT];
} wmi_host_peer_gid_userpos_list_event;
#define WMI_HOST_BOARD_MCN_STRING_MAX_SIZE 19
#define WMI_HOST_BOARD_MCN_STRING_BUF_SIZE \
(WMI_HOST_BOARD_MCN_STRING_MAX_SIZE+1) /* null-terminator */
typedef struct {
uint32_t software_cal_version;
uint32_t board_cal_version;
/* board_mcn_detail:
* Provide a calibration message string for the host to display.
* Note: on a big-endian host, the 4 bytes within each A_UINT32 portion
* of a WMI message will be automatically byteswapped by the copy engine
* as the messages are transferred between host and target, to convert
* between the target's little-endianness and the host's big-endianness.
* Consequently, a big-endian host should manually unswap the bytes
* within the board_mcn_detail string buffer to get the bytes back into
* the desired natural order.
*/
uint8_t board_mcn_detail[WMI_HOST_BOARD_MCN_STRING_BUF_SIZE];
uint32_t cal_ok; /* filled with CALIBRATION_STATUS enum value */
} wmi_host_pdev_check_cal_version_event;
#endif /* _WMI_UNIFIED_PARAM_H_ */

38
wmi/inc/wmi_unified_priv.h
View File

@@ -971,6 +971,23 @@ QDF_STATUS
(*send_set_atf_grouping_cmd)(wmi_unified_t wmi_handle, (*send_set_atf_grouping_cmd)(wmi_unified_t wmi_handle,
struct atf_grouping_params *param); struct atf_grouping_params *param);
QDF_STATUS (*send_get_user_position_cmd)(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS
(*send_reset_peer_mumimo_tx_count_cmd)(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS (*send_get_peer_mumimo_tx_count_cmd)(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS
(*send_pdev_caldata_version_check_cmd)(wmi_unified_t wmi_handle,
uint32_t value);
QDF_STATUS
(*send_btcoex_wlan_priority_cmd)(wmi_unified_t wmi_handle, int value);
QDF_STATUS (*extract_wds_addr_event)(wmi_unified_t wmi_handle, QDF_STATUS (*extract_wds_addr_event)(wmi_unified_t wmi_handle,
void *evt_buf, uint16_t len, wds_addr_event_t *wds_ev); void *evt_buf, uint16_t len, wds_addr_event_t *wds_ev);
@@ -1009,6 +1026,19 @@ QDF_STATUS (*extract_vdev_scan_ev_param)(wmi_unified_t wmi_handle,
QDF_STATUS (*extract_mu_ev_param)(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS (*extract_mu_ev_param)(wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_mu_report_event *param); wmi_host_mu_report_event *param);
QDF_STATUS (*extract_mu_db_entry)(wmi_unified_t wmi_hdl, void *evt_buf,
uint8_t idx, wmi_host_mu_db_entry *param);
QDF_STATUS (*extract_mumimo_tx_count_ev_param)(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_peer_txmu_cnt_event *param);
QDF_STATUS (*extract_peer_gid_userpos_list_ev_param)(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_peer_gid_userpos_list_event *param);
QDF_STATUS (*extract_pdev_caldata_version_check_ev_param)(
wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_pdev_check_cal_version_event *param);
QDF_STATUS (*extract_pdev_tpc_config_ev_param)(wmi_unified_t wmi_handle, QDF_STATUS (*extract_pdev_tpc_config_ev_param)(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_pdev_tpc_config_event *param); void *evt_buf, wmi_host_pdev_tpc_config_event *param);
@@ -1122,6 +1152,14 @@ QDF_STATUS (*extract_inst_rssi_stats_event)(wmi_unified_t wmi_handle,
QDF_STATUS (*extract_tx_data_traffic_ctrl_ev)(wmi_unified_t wmi_handle, QDF_STATUS (*extract_tx_data_traffic_ctrl_ev)(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_tx_data_traffic_ctrl_event *ev); void *evt_buf, wmi_host_tx_data_traffic_ctrl_event *ev);
QDF_STATUS (*extract_atf_peer_stats_ev)(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_atf_peer_stats_event *ev);
QDF_STATUS (*extract_atf_token_info_ev)(wmi_unified_t wmi_handle,
void *evt_buf,
uint8_t idx,
wmi_host_atf_peer_stats_info *atf_token_info);
QDF_STATUS (*extract_vdev_extd_stats)(wmi_unified_t wmi_handle, void *evt_buf, QDF_STATUS (*extract_vdev_extd_stats)(wmi_unified_t wmi_handle, void *evt_buf,
uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats); uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats);

224
wmi/src/wmi_unified_api.c
View File

@@ -5072,6 +5072,82 @@ wmi_send_set_atf_grouping_cmd(void *wmi_hdl,
} }
/**
* wmi_send_get_user_position_cmd() - send get user position command to fw
* @wmi_handle: wmi handle
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value)
{
wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
if (wmi_handle->ops->send_get_user_position_cmd)
return wmi_handle->ops->send_get_user_position_cmd(wmi_handle,
value);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count
* command to fw
* @wmi_handle: wmi handle
* @value: user pos value
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->send_get_peer_mumimo_tx_count_cmd)
return wmi->ops->send_get_peer_mumimo_tx_count_cmd(wmi, value);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo
* tx count to fw
* @wmi_handle: wmi handle
* @value: reset tx count value
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->send_reset_peer_mumimo_tx_count_cmd)
return wmi->ops->send_reset_peer_mumimo_tx_count_cmd(wmi,
value);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_send_pdev_caldata_version_check_cmd() - send reset peer mumimo
* tx count to fw
* @wmi_handle: wmi handle
* @value: value
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS
wmi_send_pdev_caldata_version_check_cmd(void *wmi_hdl, uint32_t value)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->send_pdev_caldata_version_check_cmd)
return wmi->ops->send_pdev_caldata_version_check_cmd(wmi,
value);
return QDF_STATUS_E_FAILURE;
}
/* Extract - APIs */ /* Extract - APIs */
/** /**
@@ -5338,6 +5414,90 @@ QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
/**
* wmi_extract_mu_db_entry() - extract mu db entry from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold mu db entry
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf,
uint8_t idx, wmi_host_mu_db_entry *param)
{
wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
if (wmi_handle->ops->extract_mu_db_entry)
return wmi_handle->ops->extract_mu_db_entry(wmi_handle, evt_buf,
idx, param);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold mumimo tx count
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf,
wmi_host_peer_txmu_cnt_event *param)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->extract_mumimo_tx_count_ev_param)
return wmi->ops->extract_mumimo_tx_count_ev_param(wmi,
evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold peer gid userposition list
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl,
void *evt_buf,
wmi_host_peer_gid_userpos_list_event *param)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->extract_peer_gid_userpos_list_ev_param)
return wmi->ops->extract_peer_gid_userpos_list_ev_param(wmi,
evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_pdev_caldata_version_check_ev_param() - extract caldata
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold caldata version data
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_pdev_caldata_version_check_ev_param(void *wmi_hdl,
void *evt_buf,
wmi_host_pdev_check_cal_version_event *param)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->extract_pdev_caldata_version_check_ev_param)
return wmi->ops->extract_pdev_caldata_version_check_ev_param(
wmi, evt_buf, param);
return QDF_STATUS_E_FAILURE;
}
/** /**
* wmi_extract_pdev_tpc_config_ev_param() - extract pdev tpc configuration * wmi_extract_pdev_tpc_config_ev_param() - extract pdev tpc configuration
* param from event * param from event
@@ -6084,7 +6244,6 @@ QDF_STATUS wmi_extract_inst_rssi_stats_event(void *wmi_hdl, void *evt_buf,
* from event * from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer * @param evt_buf: pointer to event buffer
* @param index: Index into chan stats
* @param ev: Pointer to hold data traffic control * @param ev: Pointer to hold data traffic control
* *
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
@@ -6101,6 +6260,49 @@ QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
/**
* wmi_extract_atf_peer_stats_ev() - extract atf peer stats
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param ev: Pointer to hold atf peer stats
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_atf_peer_stats_ev(void *wmi_hdl, void *evt_buf,
wmi_host_atf_peer_stats_event *ev)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->extract_atf_peer_stats_ev)
return wmi->ops->extract_atf_peer_stats_ev(wmi,
evt_buf, ev);
return QDF_STATUS_E_FAILURE;
}
/**
* wmi_extract_atf_token_info_ev() - extract atf token info
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param idx: Index indicating the peer number
* @param ev: Pointer to hold atf token info
*
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/
QDF_STATUS wmi_extract_atf_token_info_ev(void *wmi_hdl, void *evt_buf,
uint8_t idx, wmi_host_atf_peer_stats_info *ev)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->extract_atf_token_info_ev)
return wmi->ops->extract_atf_token_info_ev(wmi,
evt_buf, idx, ev);
return QDF_STATUS_E_FAILURE;
}
/** /**
* wmi_extract_vdev_extd_stats() - extract extended vdev stats from event * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
@@ -6179,6 +6381,26 @@ QDF_STATUS wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl,
return wmi_handle->ops->send_encrypt_decrypt_send_cmd( return wmi_handle->ops->send_encrypt_decrypt_send_cmd(
wmi_handle, wmi_handle,
params); params);
return QDF_STATUS_E_FAILURE;
}
/*
* wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands
* @wmi_handle: wmi handle
* @value: Priority value
*
* Send WMI_BTCOEX_CFG_CMDID parameters to fw.
*
* Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
*/
QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl,
int value)
{
wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
if (wmi->ops->send_btcoex_wlan_priority_cmd)
return wmi->ops->send_btcoex_wlan_priority_cmd(wmi,
value);
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }

356
wmi/src/wmi_unified_non_tlv.c
View File

@@ -1922,7 +1922,7 @@ QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
WMI_SCAN_EVENT_FOREIGN_CHANNEL | WMI_SCAN_EVENT_FOREIGN_CHANNEL |
WMI_SCAN_EVENT_DEQUEUED WMI_SCAN_EVENT_DEQUEUED
#if QCA_LTEU_SUPPORT #if QCA_LTEU_SUPPORT
| WMI_SCAN_EVENT_INVALID | WMI_SCAN_EVENT_GPIO_TIMEOUT;
#endif #endif
; ;
@@ -1945,8 +1945,15 @@ QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
if (param->is_phy_error) if (param->is_phy_error)
cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR; cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
if (param->half_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
if (param->quarter_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
/** send multiple braodcast probe req with this delay in between */ /** send multiple braodcast probe req with this delay in between */
cmd->repeat_probe_time = param->repeat_probe_time; cmd->repeat_probe_time = param->repeat_probe_time;
cmd->probe_spacing_time = param->probe_spacing_time;
/** delay between channel change and first probe request */ /** delay between channel change and first probe request */
cmd->probe_delay = param->probe_delay; cmd->probe_delay = param->probe_delay;
/** idle time on channel for which if no traffic is seen /** idle time on channel for which if no traffic is seen
@@ -3157,6 +3164,11 @@ send_mu_scan_cmd_non_tlv(wmi_unified_t wmi_handle,
cmd->mu_duration = param->duration; cmd->mu_duration = param->duration;
cmd->mu_type = param->type; cmd->mu_type = param->type;
cmd->lteu_tx_power = param->lteu_tx_power; cmd->lteu_tx_power = param->lteu_tx_power;
cmd->rssi_thr_bssid = param->rssi_thr_bssid;
cmd->rssi_thr_sta = param->rssi_thr_sta;
cmd->rssi_thr_sc = param->rssi_thr_sc;
cmd->plmn_id = param->plmn_id;
cmd->alpha_num_bssid = param->alpha_num_bssid;
return wmi_unified_cmd_send(wmi_handle, buf, return wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_mu_start_cmd), sizeof(wmi_mu_start_cmd),
WMI_MU_CAL_START_CMDID); WMI_MU_CAL_START_CMDID);
@@ -3193,6 +3205,7 @@ send_lteu_config_cmd_non_tlv(wmi_unified_t wmi_handle,
cmd->alpha_num_bssid = param->alpha_num_bssid; cmd->alpha_num_bssid = param->alpha_num_bssid;
cmd->use_actual_nf = param->use_actual_nf; cmd->use_actual_nf = param->use_actual_nf;
cmd->wifi_tx_power = param->wifi_tx_power; cmd->wifi_tx_power = param->wifi_tx_power;
cmd->allow_err_packets = param->allow_err_packets;
return wmi_unified_cmd_send(wmi_handle, buf, return wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_set_lteu_config), sizeof(wmi_set_lteu_config),
WMI_SET_LTEU_CONFIG_CMDID); WMI_SET_LTEU_CONFIG_CMDID);
@@ -4337,7 +4350,8 @@ send_pdev_set_chan_cmd_non_tlv(wmi_unified_t wmi_handle,
if (param->quarter_rate) if (param->quarter_rate)
WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_QUARTER); WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_QUARTER);
if (param->phy_mode == MODE_11AC_VHT80_80) { if ((param->phy_mode == MODE_11AC_VHT80_80) ||
(param->phy_mode == MODE_11AC_VHT160)) {
qdf_print( qdf_print(
"WMI channel freq=%d, mode=%x band_center_freq1=%d band_center_freq2=%d\n", "WMI channel freq=%d, mode=%x band_center_freq1=%d band_center_freq2=%d\n",
cmd->chan.mhz, cmd->chan.mhz,
@@ -5066,6 +5080,162 @@ send_start_oem_data_cmd_non_tlv(wmi_unified_t wmi_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* send_get_user_position_cmd_non_tlv() - send cmd get user position from fw
* @wmi_handle: wmi handle
* @value: user pos value
*
* Return: 0 for success or error code
*/
QDF_STATUS
send_get_user_position_cmd_non_tlv(wmi_unified_t wmi_handle, uint32_t value)
{
wmi_buf_t buf;
wmi_peer_gid_userpos_list_cmd *cmd;
buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_gid_userpos_list_cmd));
if (!buf) {
qdf_print("No WMI resource!");
return QDF_STATUS_E_FAILURE;
}
qdf_nbuf_put_tail(buf, sizeof(wmi_peer_gid_userpos_list_cmd));
cmd = (wmi_peer_gid_userpos_list_cmd *)(wmi_buf_data(buf));
cmd->aid = value;
if (wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_peer_gid_userpos_list_cmd),
WMI_PEER_GID_USERPOS_LIST_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_reset_peer_mumimo_tx_count_cmd_non_tlv() - send mumimo reset tx count fw
* @wmi_handle: wmi handle
* @value: reset tx count
*
* Return: 0 for success or error code
*/
QDF_STATUS
send_reset_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t value)
{
wmi_buf_t buf;
wmi_peer_txmu_rstcnt_cmd *cmd;
buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_rstcnt_cmd));
if (!buf) {
qdf_print("No WMI resource!");
return QDF_STATUS_E_FAILURE;
}
qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_rstcnt_cmd));
cmd = (wmi_peer_txmu_rstcnt_cmd *)(wmi_buf_data(buf));
cmd->aid = value;
if (wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_peer_txmu_rstcnt_cmd),
WMI_PEER_TX_MU_TXMIT_RSTCNT_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_get_peer_mumimo_tx_count_cmd_non_tlv() - send cmd to get mumimo tx count from fw
* @wmi_handle: wmi handle
*
* Return: 0 for success or error code
*/
QDF_STATUS
send_get_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t value)
{
wmi_buf_t buf;
wmi_peer_txmu_cnt_cmd *cmd;
buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_cnt_cmd));
if (!buf) {
qdf_print("No WMI resource!");
return QDF_STATUS_E_FAILURE;
}
qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_cnt_cmd));
cmd = (wmi_peer_txmu_cnt_cmd *)(wmi_buf_data(buf));
cmd->aid = value;
if (wmi_unified_cmd_send(wmi_handle, buf,
sizeof(wmi_peer_txmu_cnt_cmd),
WMI_PEER_TX_MU_TXMIT_COUNT_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_pdev_caldata_version_check_cmd_non_tlv() - send caldata check cmd to fw
* @wmi_handle: wmi handle
* @param: reserved param
*
* Return: 0 for success or error code
*/
QDF_STATUS
send_pdev_caldata_version_check_cmd_non_tlv(wmi_unified_t wmi_handle,
uint32_t param)
{
wmi_pdev_check_cal_version_cmd *cmd;
wmi_buf_t buf;
int32_t len = sizeof(wmi_pdev_check_cal_version_cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s:wmi_buf_alloc failed\n", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_pdev_check_cal_version_cmd *)wmi_buf_data(buf);
cmd->reserved = param; /* set to 0x0 as expected from FW */
if (wmi_unified_cmd_send(wmi_handle, buf, len,
WMI_PDEV_CHECK_CAL_VERSION_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* send_btcoex_wlan_priority_cmd_non_tlv() - send btcoex wlan priority fw
* @wmi_handle: wmi handle
* @value: priority value
*
* Return: 0 for success or error code
*/
QDF_STATUS
send_btcoex_wlan_priority_cmd_non_tlv(wmi_unified_t wmi_handle, int value)
{
wmi_buf_t buf;
wmi_btcoex_cfg_cmd *cmd;
int len = sizeof(wmi_btcoex_cfg_cmd);
buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) {
qdf_print("%s:wmi_buf_alloc failed\n", __func__);
return QDF_STATUS_E_FAILURE;
}
cmd = (wmi_btcoex_cfg_cmd *) wmi_buf_data(buf);
cmd->btcoex_wlan_priority_bitmap = value;
if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_BTCOEX_CFG_CMDID)) {
wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/** /**
* wmi_copy_resource_config_non_tlv() - copy resource configuration function * wmi_copy_resource_config_non_tlv() - copy resource configuration function
* @param resource_cfg: pointer to resource configuration * @param resource_cfg: pointer to resource configuration
@@ -5849,6 +6019,99 @@ QDF_STATUS extract_mu_ev_param_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
param->status_reason = event->status_reason; param->status_reason = event->status_reason;
qdf_mem_copy(param->total_mu, event->total_mu, sizeof(param->total_mu)); qdf_mem_copy(param->total_mu, event->total_mu, sizeof(param->total_mu));
param->num_active_bssid = event->num_active_bssid; param->num_active_bssid = event->num_active_bssid;
qdf_mem_copy(param->hidden_node_mu, event->hidden_node_mu,
sizeof(param->hidden_node_mu));
param->num_TA_entries = event->num_TA_entries;
return QDF_STATUS_SUCCESS;
}
/**
* extract_mu_db_entry_non_tlv() - extract mu db entry from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param profile_data: Pointer to hold mu_db_entry
*
* Return: 0 for success or error code
*/
QDF_STATUS extract_mu_db_entry_non_tlv(wmi_unified_t wmi_handle,
void *evt_buf, uint8_t idx,
wmi_host_mu_db_entry *db_entry)
{
wmi_mu_report_event *event = (wmi_mu_report_event *)evt_buf;
if (idx > event->num_TA_entries)
return QDF_STATUS_E_INVAL;
qdf_mem_copy(db_entry, &event->mu_entry[idx],
sizeof(wmi_host_mu_db_entry));
return QDF_STATUS_SUCCESS;
}
/**
* extract_mumimo_tx_count_ev_param_non_tlv() - extract mumimo tx count from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold mu report
*
* Return: 0 for success or error code
*/
QDF_STATUS extract_mumimo_tx_count_ev_param_non_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_peer_txmu_cnt_event *param)
{
wmi_peer_txmu_cnt_event *event = (wmi_peer_txmu_cnt_event *)evt_buf;
param->tx_mu_transmitted = event->tx_mu_transmitted;
return QDF_STATUS_SUCCESS;
}
/**
* extract_peer_gid_userpos_list_ev_param_non_tlv() - extract gid user position
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold peer user position list
*
* Return: 0 for success or error code
*/
QDF_STATUS extract_peer_gid_userpos_list_ev_param_non_tlv(
wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_peer_gid_userpos_list_event *param)
{
wmi_peer_gid_userpos_list_event *event =
(wmi_peer_gid_userpos_list_event *)evt_buf;
qdf_mem_copy(param->usr_list, event->usr_list, sizeof(param->usr_list));
return QDF_STATUS_SUCCESS;
}
/**
* extract_pdev_caldata_version_check_ev_param_non_tlv() - extract caldata from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param param: Pointer to hold peer caldata version data
*
* Return: 0 for success or error code
*/
QDF_STATUS extract_pdev_caldata_version_check_ev_param_non_tlv(
wmi_unified_t wmi_handle,
void *evt_buf,
wmi_host_pdev_check_cal_version_event *param)
{
wmi_pdev_check_cal_version_event *event =
(wmi_pdev_check_cal_version_event *)evt_buf;
param->software_cal_version = event->software_cal_version;
param->board_cal_version = event->board_cal_version;
param->cal_ok = event->cal_ok;
qdf_mem_copy(param->board_mcn_detail, event->board_mcn_detail,
sizeof(param->board_mcn_detail));
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
@@ -7397,7 +7660,6 @@ static QDF_STATUS extract_inst_rssi_stats_event_non_tlv(
* from event * from event
* @wmi_handle: wmi handle * @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer * @param evt_buf: pointer to event buffer
* @param index: Index into chan stats
* @param ev: Pointer to hold data traffic control * @param ev: Pointer to hold data traffic control
* *
* Return: 0 for success or error code * Return: 0 for success or error code
@@ -7416,6 +7678,57 @@ static QDF_STATUS extract_tx_data_traffic_ctrl_ev_non_tlv(
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* extract_atf_peer_stats_ev_non_tlv() - extract atf peer stats
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @param ev: Pointer to hold atf stats event data
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_atf_peer_stats_ev_non_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
wmi_host_atf_peer_stats_event *ev)
{
wmi_atf_peer_stats_event *evt =
(wmi_atf_peer_stats_event *)evt_buf;
ev->num_atf_peers = evt->num_atf_peers;
ev->comp_usable_airtime = evt->comp_usable_airtime;
qdf_mem_copy(&ev->reserved[0], &evt->reserved[0],
sizeof(evt->reserved));
return QDF_STATUS_SUCCESS;
}
/**
* extract_atf_token_info_ev_non_tlv() - extract atf token info
* from event
* @wmi_handle: wmi handle
* @param evt_buf: pointer to event buffer
* @idx: Index indicating the peer number
* @param atf_token_info: Pointer to hold atf token info
*
* Return: 0 for success or error code
*/
static QDF_STATUS extract_atf_token_info_ev_non_tlv(
wmi_unified_t wmi_handle, void *evt_buf,
uint8_t idx, wmi_host_atf_peer_stats_info *atf_token_info)
{
wmi_atf_peer_stats_event *evt =
(wmi_atf_peer_stats_event *)evt_buf;
if (idx > evt->num_atf_peers)
return QDF_STATUS_E_INVAL;
atf_token_info->field1 = evt->token_info_list[idx].field1;
atf_token_info->field2 = evt->token_info_list[idx].field2;
atf_token_info->field3 = evt->token_info_list[idx].field3;
return QDF_STATUS_SUCCESS;
}
#ifdef WMI_INTERFACE_EVENT_LOGGING #ifdef WMI_INTERFACE_EVENT_LOGGING
static bool is_management_record_non_tlv(uint32_t cmd_id) static bool is_management_record_non_tlv(uint32_t cmd_id)
{ {
@@ -7555,6 +7868,14 @@ struct wmi_ops non_tlv_ops = {
.send_rtt_keepalive_req_cmd = send_rtt_keepalive_req_cmd_non_tlv, .send_rtt_keepalive_req_cmd = send_rtt_keepalive_req_cmd_non_tlv,
.send_periodic_chan_stats_config_cmd = .send_periodic_chan_stats_config_cmd =
send_periodic_chan_stats_config_cmd_non_tlv, send_periodic_chan_stats_config_cmd_non_tlv,
.send_get_user_position_cmd = send_get_user_position_cmd_non_tlv,
.send_reset_peer_mumimo_tx_count_cmd =
send_reset_peer_mumimo_tx_count_cmd_non_tlv,
.send_get_peer_mumimo_tx_count_cmd =
send_get_peer_mumimo_tx_count_cmd_non_tlv,
.send_pdev_caldata_version_check_cmd =
send_pdev_caldata_version_check_cmd_non_tlv,
.send_btcoex_wlan_priority_cmd = send_btcoex_wlan_priority_cmd_non_tlv,
.get_target_cap_from_service_ready = extract_service_ready_non_tlv, .get_target_cap_from_service_ready = extract_service_ready_non_tlv,
.extract_fw_version = extract_fw_version_non_tlv, .extract_fw_version = extract_fw_version_non_tlv,
@@ -7625,6 +7946,16 @@ struct wmi_ops non_tlv_ops = {
.extract_fips_event_data = extract_fips_event_data_non_tlv, .extract_fips_event_data = extract_fips_event_data_non_tlv,
.extract_fips_event_error_status = .extract_fips_event_error_status =
extract_fips_event_error_status_non_tlv, extract_fips_event_error_status_non_tlv,
.extract_mumimo_tx_count_ev_param =
extract_mumimo_tx_count_ev_param_non_tlv,
.extract_peer_gid_userpos_list_ev_param =
extract_peer_gid_userpos_list_ev_param_non_tlv,
.extract_pdev_caldata_version_check_ev_param =
extract_pdev_caldata_version_check_ev_param_non_tlv,
.extract_mu_db_entry = extract_mu_db_entry_non_tlv,
.extract_atf_peer_stats_ev = extract_atf_peer_stats_ev_non_tlv,
.extract_atf_token_info_ev = extract_atf_token_info_ev_non_tlv,
}; };
/** /**
@@ -7703,6 +8034,8 @@ static void populate_non_tlv_service(uint32_t *wmi_service)
wmi_service[wmi_service_tx_mode_push_pull] = wmi_service[wmi_service_tx_mode_push_pull] =
WMI_SERVICE_TX_MODE_PUSH_PULL; WMI_SERVICE_TX_MODE_PUSH_PULL;
wmi_service[wmi_service_tx_mode_dynamic] = WMI_SERVICE_TX_MODE_DYNAMIC; wmi_service[wmi_service_tx_mode_dynamic] = WMI_SERVICE_TX_MODE_DYNAMIC;
wmi_service[wmi_service_check_cal_version] =
WMI_SERVICE_CHECK_CAL_VERSION;
wmi_service[wmi_service_roam_scan_offload] = WMI_SERVICE_UNAVAILABLE; wmi_service[wmi_service_roam_scan_offload] = WMI_SERVICE_UNAVAILABLE;
wmi_service[wmi_service_arpns_offload] = WMI_SERVICE_UNAVAILABLE; wmi_service[wmi_service_arpns_offload] = WMI_SERVICE_UNAVAILABLE;
@@ -7851,6 +8184,14 @@ static void populate_non_tlv_events_id(uint32_t *event_ids)
event_ids[wmi_tx_data_traffic_ctrl_event_id] = event_ids[wmi_tx_data_traffic_ctrl_event_id] =
WMI_TX_DATA_TRAFFIC_CTRL_EVENTID; WMI_TX_DATA_TRAFFIC_CTRL_EVENTID;
event_ids[wmi_pdev_utf_event_id] = WMI_PDEV_UTF_EVENTID; event_ids[wmi_pdev_utf_event_id] = WMI_PDEV_UTF_EVENTID;
event_ids[wmi_peer_tx_mu_txmit_count_event_id] =
WMI_PEER_TX_MU_TXMIT_COUNT_EVENTID;
event_ids[wmi_peer_gid_userpos_list_event_id] =
WMI_PEER_GID_USERPOS_LIST_EVENTID;
event_ids[wmi_pdev_check_cal_version_event_id] =
WMI_PDEV_CHECK_CAL_VERSION_EVENTID;
event_ids[wmi_atf_peer_stats_event_id] =
WMI_ATF_PEER_STATS_EVENTID;
} }
/** /**
@@ -8034,6 +8375,10 @@ static void populate_pdev_param_non_tlv(uint32_t *pdev_param)
WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE; WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE;
pdev_param[wmi_pdev_param_atf_ssid_group_policy] = pdev_param[wmi_pdev_param_atf_ssid_group_policy] =
WMI_PDEV_PARAM_ATF_SSID_GROUP_POLICY; WMI_PDEV_PARAM_ATF_SSID_GROUP_POLICY;
pdev_param[wmi_pdev_param_enable_btcoex] =
WMI_PDEV_PARAM_ENABLE_BTCOEX;
pdev_param[wmi_pdev_param_atf_peer_stats] =
WMI_PDEV_PARAM_ATF_PEER_STATS;
pdev_param[wmi_pdev_param_rfkill_enable] = WMI_UNAVAILABLE_PARAM; pdev_param[wmi_pdev_param_rfkill_enable] = WMI_UNAVAILABLE_PARAM;
pdev_param[wmi_pdev_param_hw_rfkill_config] = WMI_UNAVAILABLE_PARAM; pdev_param[wmi_pdev_param_hw_rfkill_config] = WMI_UNAVAILABLE_PARAM;
pdev_param[wmi_pdev_param_low_power_rf_enable] = WMI_UNAVAILABLE_PARAM; pdev_param[wmi_pdev_param_low_power_rf_enable] = WMI_UNAVAILABLE_PARAM;
@@ -8195,6 +8540,11 @@ static void populate_vdev_param_non_tlv(uint32_t *vdev_param)
vdev_param[wmi_vdev_param_sta_kickout] = WMI_VDEV_PARAM_STA_KICKOUT; vdev_param[wmi_vdev_param_sta_kickout] = WMI_VDEV_PARAM_STA_KICKOUT;
vdev_param[wmi_vdev_param_capabilities] = vdev_param[wmi_vdev_param_capabilities] =
WMI_VDEV_PARAM_CAPABILITIES; WMI_VDEV_PARAM_CAPABILITIES;
vdev_param[wmi_vdev_param_mgmt_tx_power] = WMI_VDEV_PARAM_MGMT_TX_POWER;
vdev_param[wmi_vdev_param_atf_ssid_sched_policy] =
WMI_VDEV_PARAM_ATF_SSID_SCHED_POLICY;
vdev_param[wmi_vdev_param_disable_dyn_bw_rts] =
WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS;
} }
#endif #endif