From 8972788adbeb646e35803d257cdd0251d80aa0f8 Mon Sep 17 00:00:00 2001 From: Govind Singh Date: Fri, 15 Apr 2016 13:58:27 +0530 Subject: [PATCH] qcacmn: Add non-tlv implementation in common wmi layer WIN platform uses non-tlv implementation for host to target wmi commands. Add support for non-tlv implementation in common wmi layer. Change-Id: I1f832695b0d41b521be6b18df0cad31aae11b6c9 Acked-by: Kiran Venkatappa CRs-Fixed: 1005778 --- wmi_unified_api.h | 488 +++++- wmi_unified_non_tlv.h | 4 - wmi_unified_param.h | 3794 ++++++++++++++++++++++++++++++++++++++++- wmi_unified_priv.h | 479 +++++- 4 files changed, 4733 insertions(+), 32 deletions(-) diff --git a/wmi_unified_api.h b/wmi_unified_api.h index db5d24994a..9fb1386a88 100644 --- a/wmi_unified_api.h +++ b/wmi_unified_api.h @@ -102,6 +102,9 @@ enum wmi_rx_exec_ctx { * attach for unified WMI * * @param scn_handle : handle to SCN. + * @param target_type : type of supported wmi command + * @param use_cookie : flag to indicate cookie based allocation + * @param ops : handle to wmi ops * @return opaque handle. */ void *wmi_unified_attach(void *scn_handle, @@ -148,11 +151,12 @@ void wmi_buf_free(wmi_buf_t net_buf); * @param wmi_handle : handle to WMI. * @param buf : wmi command buffer * @param buflen : wmi command buffer length + * @param cmd_id : WMI cmd id * @return 0 on success and -ve on failure. */ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t buflen, - WMI_CMD_ID cmd_id); + WMI_CMD_ID cmd_id); /** * wmi_unified_register_event_handler() - WMI event handler @@ -167,7 +171,7 @@ wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t buflen, */ int wmi_unified_register_event_handler(wmi_unified_t wmi_handle, - WMI_EVT_ID event_id, + uint32_t event_id, wmi_unified_event_handler handler_func, uint8_t rx_ctx); @@ -180,11 +184,12 @@ wmi_unified_register_event_handler(wmi_unified_t wmi_handle, */ int wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle, - WMI_EVT_ID event_id); + uint32_t event_id); /** * request wmi to connet its htc service. * @param wmi_handle : handle to WMI. + * @param htc_handle : handle to HTC. * @return void */ int @@ -193,27 +198,56 @@ wmi_unified_connect_htc_service(struct wmi_unified *wmi_handle, /* * WMI API to verify the host has enough credits to suspend + * @param wmi_handle : handle to WMI. */ int wmi_is_suspend_ready(wmi_unified_t wmi_handle); /** - WMI API to get updated host_credits + * WMI API to get updated host_credits + * @param wmi_handle : handle to WMI. */ int wmi_get_host_credits(wmi_unified_t wmi_handle); /** - WMI API to get WMI Pending Commands in the HTC queue + * WMI API to get WMI Pending Commands in the HTC queue + * @param wmi_handle : handle to WMI. */ int wmi_get_pending_cmds(wmi_unified_t wmi_handle); /** - WMI API to set target suspend state + * WMI API to set target suspend state + * @param wmi_handle : handle to WMI. + * @param val : suspend state boolean */ void wmi_set_target_suspend(wmi_unified_t wmi_handle, bool val); +/** + * generic function to block unified WMI command + * @param wmi_handle : handle to WMI. + * @return 0 on success and -ve on failure. + */ +int +wmi_stop(wmi_unified_t wmi_handle); + +/** + * API to flush all the previous packets associated with the wmi endpoint + * + * @param wmi_handle : handle to WMI. + */ +void +wmi_flush_endpoint(wmi_unified_t wmi_handle); + +/** + * API to handle wmi rx event after UMAC has taken care of execution + * context + * + * @param wmi_handle : handle to WMI. + * @param evt_buf : wmi event buffer + */ +void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf); #ifdef FEATURE_RUNTIME_PM void wmi_set_runtime_pm_inprogress(wmi_unified_t wmi_handle, bool val); @@ -233,6 +267,8 @@ static inline bool wmi_get_runtime_pm_inprogress(wmi_unified_t wmi_handle) /** * UMAC Callback to process fw event. + * @param wmi_handle : handle to WMI. + * @param evt_buf : wmi event buffer */ void wmi_process_fw_event(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf); uint16_t wmi_get_max_msg_len(wmi_unified_t wmi_handle); @@ -296,10 +332,16 @@ QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl, struct wow_cmd_params *param, uint8_t mac_id); +#ifdef WMI_NON_TLV_SUPPORT +QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, + WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT); +#else QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl, uint8_t macaddr[IEEE80211_ADDR_LEN], struct packet_enable_params *param); +#endif +QDF_STATUS wmi_unified_packet_log_disable_send(void *wmi_hdl); QDF_STATUS wmi_unified_suspend_send(void *wmi_hdl, struct suspend_params *param, @@ -313,6 +355,10 @@ wmi_unified_pdev_param_send(void *wmi_hdl, struct pdev_params *param, uint8_t mac_id); +QDF_STATUS wmi_unified_beacon_tmpl_send_cmd(void *wmi_hdl, + struct beacon_tmpl_params *param); + + QDF_STATUS wmi_unified_beacon_send_cmd(void *wmi_hdl, struct beacon_params *param); @@ -404,8 +450,10 @@ QDF_STATUS wmi_unified_set_mcc_channel_time_latency_cmd QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd( void *wmi_hdl, uint32_t mcc_adaptive_scheduler); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_bcn_buf_ll_cmd(void *wmi_hdl, wmi_bcn_send_from_host_cmd_fixed_param *param); +#endif QDF_STATUS wmi_unified_set_sta_sa_query_param_cmd(void *wmi_hdl, uint8_t vdev_id, uint32_t max_retries, @@ -418,10 +466,11 @@ QDF_STATUS wmi_unified_set_sta_keep_alive_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_vdev_set_gtx_cfg_cmd(void *wmi_hdl, uint32_t if_id, struct wmi_gtx_config *gtx_info); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl, uint8_t vdev_id, wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC]); +#endif QDF_STATUS wmi_unified_probe_rsp_tmpl_send_cmd(void *wmi_hdl, @@ -451,9 +500,11 @@ QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(void *wmi_hdl, struct wifi_passpoint_req_param *req); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(void *wmi_hdl, wmi_start_scan_cmd_fixed_param *scan_cmd_fp, struct roam_offload_scan_params *roam_req); +#endif QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(void *wmi_hdl, struct roam_offload_scan_rssi_params *roam_req); @@ -500,9 +551,11 @@ QDF_STATUS wmi_unified_plm_start_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_pno_stop_cmd(void *wmi_hdl, uint8_t vdev_id); +#ifdef FEATURE_WLAN_SCAN_PNO QDF_STATUS wmi_unified_pno_start_cmd(void *wmi_hdl, struct pno_scan_req_params *pno, uint32_t *gchannel_freq_list); +#endif QDF_STATUS wmi_unified_set_ric_req_cmd(void *wmi_hdl, void *msg, uint8_t is_add_ts); @@ -529,6 +582,7 @@ QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id); QDF_STATUS wmi_unified_link_status_req_cmd(void *wmi_hdl, struct link_status_params *link_status); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_lphb_config_hbenable_cmd(void *wmi_hdl, wmi_hb_set_enable_cmd_fixed_param *params); @@ -542,16 +596,17 @@ QDF_STATUS wmi_unified_lphb_config_udp_params_cmd(void *wmi_hdl, wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req); QDF_STATUS wmi_unified_lphb_config_udp_pkt_filter_cmd(void *wmi_hdl, - wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req); + wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req); QDF_STATUS wmi_unified_process_dhcp_ind(void *wmi_hdl, wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind); QDF_STATUS wmi_unified_get_link_speed_cmd(void *wmi_hdl, - wmi_mac_addr peer_macaddr); + wmi_mac_addr peer_macaddr); QDF_STATUS wmi_unified_egap_conf_params_cmd(void *wmi_hdl, - wmi_ap_ps_egap_param_cmd_fixed_param *egap_params); + wmi_ap_ps_egap_param_cmd_fixed_param *egap_params); +#endif QDF_STATUS wmi_unified_fw_profiling_data_cmd(void *wmi_hdl, uint32_t cmd, uint32_t value1, uint32_t value2); @@ -571,9 +626,11 @@ QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl, bool dfs_phyerr_filter_offload); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl, WMI_PKTLOG_EVENT pktlog_event, WMI_CMD_ID cmd_id); +#endif QDF_STATUS wmi_unified_add_wow_wakeup_event_cmd(void *wmi_hdl, uint32_t vdev_id, @@ -608,9 +665,9 @@ QDF_STATUS wmi_unified_config_packet_filter_cmd(void *wmi_hdl, uint8_t filter_id, bool enable); QDF_STATUS wmi_unified_add_clear_mcbc_filter_cmd(void *wmi_hdl, - uint8_t vdev_id, - struct qdf_mac_addr multicast_addr, - bool clearList); + uint8_t vdev_id, + struct qdf_mac_addr multicast_addr, + bool clearList); QDF_STATUS wmi_unified_send_gtk_offload_cmd(void *wmi_hdl, uint8_t vdev_id, struct gtk_offload_params *params, @@ -740,9 +797,11 @@ QDF_STATUS wmi_unified_roam_invoke_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_roam_scan_offload_cmd(void *wmi_hdl, uint32_t command, uint32_t vdev_id); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd(void *wmi_hdl, wmi_ap_profile *ap_profile_p, uint32_t vdev_id); +#endif QDF_STATUS wmi_unified_roam_scan_offload_scan_period(void *wmi_hdl, uint32_t scan_period, @@ -763,4 +822,407 @@ QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd(void *wmi_hdl, QDF_STATUS wmi_unified_get_buf_extscan_hotlist_cmd(void *wmi_hdl, struct ext_scan_setbssi_hotlist_params * photlist, int *buf_len); + +QDF_STATUS wmi_unified_stats_request_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct stats_request_params *param); + +QDF_STATUS wmi_unified_pdev_get_tpc_config_cmd_send(void *wmi_hdl, + uint32_t param); + +QDF_STATUS wmi_unified_set_atf_cmd_send(void *wmi_hdl, + struct set_atf_params *param); + +QDF_STATUS wmi_unified_pdev_fips_cmd_send(void *wmi_hdl, + struct fips_params *param); + +QDF_STATUS wmi_unified_wlan_profile_enable_cmd_send(void *wmi_hdl, + struct wlan_profile_params *param); + +QDF_STATUS wmi_unified_wlan_profile_trigger_cmd_send(void *wmi_hdl, + struct wlan_profile_params *param); + +QDF_STATUS wmi_unified_set_chan_cmd_send(void *wmi_hdl, + struct channel_param *param); + +QDF_STATUS wmi_unified_set_ht_ie_cmd_send(void *wmi_hdl, + struct ht_ie_params *param); + +QDF_STATUS wmi_unified_set_vht_ie_cmd_send(void *wmi_hdl, + struct vht_ie_params *param); + +QDF_STATUS wmi_unified_wmm_update_cmd_send(void *wmi_hdl, + struct wmm_update_params *param); + +QDF_STATUS wmi_unified_set_ant_switch_tbl_cmd_send(void *wmi_hdl, + struct ant_switch_tbl_params *param); + +QDF_STATUS wmi_unified_set_ratepwr_table_cmd_send(void *wmi_hdl, + struct ratepwr_table_params *param); + +QDF_STATUS wmi_unified_get_ratepwr_table_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_set_ctl_table_cmd_send(void *wmi_hdl, + struct ctl_table_params *param); + +QDF_STATUS wmi_unified_set_mimogain_table_cmd_send(void *wmi_hdl, + struct mimogain_table_params *param); + +QDF_STATUS wmi_unified_set_ratepwr_chainmsk_cmd_send(void *wmi_hdl, + struct ratepwr_chainmsk_params *param); + +QDF_STATUS wmi_unified_set_macaddr_cmd_send(void *wmi_hdl, + struct macaddr_params *param); + +QDF_STATUS wmi_unified_pdev_scan_start_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_pdev_scan_end_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_set_acparams_cmd_send(void *wmi_hdl, + struct acparams_params *param); + +QDF_STATUS wmi_unified_set_vap_dscp_tid_map_cmd_send(void *wmi_hdl, + struct vap_dscp_tid_map_params *param); + +QDF_STATUS wmi_unified_proxy_ast_reserve_cmd_send(void *wmi_hdl, + struct proxy_ast_reserve_params *param); + +QDF_STATUS wmi_unified_pdev_qvit_cmd_send(void *wmi_hdl, + struct pdev_qvit_params *param); + +QDF_STATUS wmi_unified_mcast_group_update_cmd_send(void *wmi_hdl, + struct mcast_group_update_params *param); + +QDF_STATUS wmi_unified_peer_add_wds_entry_cmd_send(void *wmi_hdl, + struct peer_add_wds_entry_params *param); + +QDF_STATUS wmi_unified_peer_del_wds_entry_cmd_send(void *wmi_hdl, + struct peer_del_wds_entry_params *param); + +QDF_STATUS wmi_unified_peer_update_wds_entry_cmd_send(void *wmi_hdl, + struct peer_update_wds_entry_params *param); + +QDF_STATUS wmi_unified_phyerr_enable_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_phyerr_enable_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_phyerr_disable_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_smart_ant_enable_cmd_send(void *wmi_hdl, + struct smart_ant_enable_params *param); + +QDF_STATUS wmi_unified_smart_ant_set_rx_ant_cmd_send(void *wmi_hdl, + struct smart_ant_rx_ant_params *param); + +QDF_STATUS wmi_unified_smart_ant_set_tx_ant_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_tx_ant_params *param); + +QDF_STATUS wmi_unified_smart_ant_set_training_info_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_training_info_params *param); + +QDF_STATUS wmi_unified_smart_ant_node_config_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_node_config_params *param); + +QDF_STATUS wmi_unified_smart_ant_enable_tx_feedback_cmd_send(void *wmi_hdl, + struct smart_ant_enable_tx_feedback_params *param); + +QDF_STATUS wmi_unified_vdev_spectral_configure_cmd_send(void *wmi_hdl, + struct vdev_spectral_configure_params *param); + +QDF_STATUS wmi_unified_vdev_spectral_enable_cmd_send(void *wmi_hdl, + struct vdev_spectral_enable_params *param); + +QDF_STATUS wmi_unified_bss_chan_info_request_cmd_send(void *wmi_hdl, + struct bss_chan_info_request_params *param); + +QDF_STATUS wmi_unified_thermal_mitigation_param_cmd_send(void *wmi_hdl, + struct thermal_mitigation_params *param); + +QDF_STATUS wmi_unified_vdev_set_neighbour_rx_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct set_neighbour_rx_params *param); + +QDF_STATUS wmi_unified_vdev_set_fwtest_param_cmd_send(void *wmi_hdl, + struct set_fwtest_params *param); + +QDF_STATUS wmi_unified_vdev_config_ratemask_cmd_send(void *wmi_hdl, + struct config_ratemask_params *param); + +QDF_STATUS wmi_unified_vdev_install_key_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct vdev_install_key_params *param); + +QDF_STATUS wmi_unified_pdev_set_regdomain_cmd_send(void *wmi_hdl, + struct pdev_set_regdomain_params *param); + +QDF_STATUS wmi_unified_set_quiet_mode_cmd_send(void *wmi_hdl, + struct set_quiet_mode_params *param); + +QDF_STATUS wmi_unified_set_beacon_filter_cmd_send(void *wmi_hdl, + struct set_beacon_filter_params *param); + +QDF_STATUS wmi_unified_remove_beacon_filter_cmd_send(void *wmi_hdl, + struct remove_beacon_filter_params *param); + +QDF_STATUS wmi_unified_addba_clearresponse_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_clearresponse_params *param); + +QDF_STATUS wmi_unified_addba_send_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_send_params *param); + +QDF_STATUS wmi_unified_delba_send_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct delba_send_params *param); + +QDF_STATUS wmi_unified_addba_setresponse_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_setresponse_params *param); + +QDF_STATUS wmi_unified_singleamsdu_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct singleamsdu_params *param); + +QDF_STATUS wmi_unified_set_qboost_param_cmd_send(void *wmi_hdl, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct set_qboost_params *param); + +QDF_STATUS wmi_unified_mu_scan_cmd_send(void *wmi_hdl, + struct mu_scan_params *param); + +QDF_STATUS wmi_unified_lteu_config_cmd_send(void *wmi_hdl, + struct lteu_config_params *param); + +QDF_STATUS wmi_unified_set_psmode_cmd_send(void *wmi_hdl, + struct set_ps_mode_params *param); + +QDF_STATUS wmi_unified_init_cmd_send(void *wmi_hdl, + target_resource_config *res_cfg, + uint8_t num_mem_chunks, + struct wmi_host_mem_chunk *mem_chunk); + +bool wmi_service_enabled(void *wmi_hdl, uint32_t service_id); + +QDF_STATUS wmi_save_service_bitmap(void *wmi_hdl, void *evt_buf); + +QDF_STATUS wmi_save_fw_version(void *wmi_hdl, void *evt_buf); + +QDF_STATUS wmi_get_target_cap_from_service_ready(void *wmi_hdl, + void *evt_buf, target_capability_info *ev); + +QDF_STATUS wmi_extract_hal_reg_cap(void *wmi_hdl, void *evt_buf, + TARGET_HAL_REG_CAPABILITIES *hal_reg_cap); + +host_mem_req *wmi_extract_host_mem_req_from_service_ready(void *wmi_hdl, + void *evt_buf, uint8_t *num_entries); + +uint32_t wmi_ready_extract_init_status(void *wmi_hdl, void *ev); + +QDF_STATUS wmi_ready_extract_mac_addr(void *wmi_hdl, + void *ev, uint8_t *macaddr); + +QDF_STATUS wmi_extract_fw_version(void *wmi_hdl, + void *ev, struct wmi_host_fw_ver *fw_ver); + +QDF_STATUS wmi_extract_fw_abi_version(void *wmi_hdl, + void *ev, struct wmi_host_fw_abi_ver *fw_ver); + +QDF_STATUS wmi_check_and_update_fw_version(void *wmi_hdl, void *ev); + +uint8_t *wmi_extract_dbglog_data_len(void *wmi_hdl, + void *evt_b, uint16_t *len); + +QDF_STATUS wmi_send_ext_resource_config(void *wmi_hdl, + wmi_host_ext_resource_config *ext_cfg); + +QDF_STATUS wmi_unified_nf_dbr_dbm_info_get_cmd_send(void *wmi_hdl); + +QDF_STATUS wmi_unified_packet_power_info_get_cmd_send(void *wmi_hdl, + struct packet_power_info_params *param); + +QDF_STATUS wmi_unified_gpio_config_cmd_send(void *wmi_hdl, + struct gpio_config_params *param); + +QDF_STATUS wmi_unified_gpio_output_cmd_send(void *wmi_hdl, + struct gpio_output_params *param); + +QDF_STATUS wmi_unified_rtt_meas_req_test_cmd_send(void *wmi_hdl, + struct rtt_meas_req_test_params *param); + +QDF_STATUS wmi_unified_rtt_meas_req_cmd_send(void *wmi_hdl, + struct rtt_meas_req_params *param); + +QDF_STATUS wmi_unified_rtt_keepalive_req_cmd_send(void *wmi_hdl, + struct rtt_keepalive_req_params *param); + +QDF_STATUS wmi_unified_lci_set_cmd_send(void *wmi_hdl, + struct lci_set_params *param); + +QDF_STATUS wmi_unified_lcr_set_cmd_send(void *wmi_hdl, + struct lcr_set_params *param); + +QDF_STATUS wmi_unified_send_periodic_chan_stats_config_cmd(void *wmi_hdl, + struct periodic_chan_stats_params *param); + +QDF_STATUS +wmi_send_atf_peer_request_cmd(void *wmi_hdl, + struct atf_peer_request_params *param); + +QDF_STATUS +wmi_send_set_atf_grouping_cmd(void *wmi_hdl, + struct atf_grouping_params *param); +/* Extract APIs */ + +QDF_STATUS wmi_extract_wds_addr_event(void *wmi_hdl, + void *evt_buf, uint16_t len, wds_addr_event_t *wds_ev); + +QDF_STATUS wmi_extract_dcs_interference_type(void *wmi_hdl, + void *evt_buf, uint32_t *interference_type); + +QDF_STATUS wmi_extract_dcs_cw_int(void *wmi_hdl, void *evt_buf, + wmi_host_ath_dcs_cw_int *cw_int); + +QDF_STATUS wmi_extract_dcs_im_tgt_stats(void *wmi_hdl, void *evt_buf, + wmi_host_dcs_im_tgt_stats_t *wlan_stat); + +QDF_STATUS wmi_extract_fips_event_error_status(void *wmi_hdl, void *evt_buf, + uint32_t *err_status); + +QDF_STATUS wmi_extract_fips_event_data(void *wmi_hdl, void *evt_buf, + uint32_t *data_len, uint32_t **data); +QDF_STATUS wmi_extract_vdev_start_resp(void *wmi_hdl, void *evt_buf, + wmi_host_vdev_start_resp *vdev_rsp); +QDF_STATUS wmi_extract_tbttoffset_update_params(void *wmi_hdl, void *evt_buf, + uint32_t *vdev_map, uint32_t **tbttoffset_list); + +QDF_STATUS wmi_extract_mgmt_rx_params(void *wmi_hdl, void *evt_buf, + wmi_host_mgmt_rx_hdr *hdr, uint8_t **bufp); + +QDF_STATUS wmi_extract_vdev_stopped_param(void *wmi_hdl, void *evt_buf, + uint32_t *vdev_id); + +QDF_STATUS wmi_extract_vdev_roam_param(void *wmi_hdl, void *evt_buf, + wmi_host_roam_event *ev); + +QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf, + wmi_host_scan_event *param); + +QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf, + wmi_host_mu_report_event *param); + +QDF_STATUS wmi_extract_pdev_tpc_config_ev_param(void *wmi_hdl, void *evt_buf, + wmi_host_pdev_tpc_config_event *param); + +QDF_STATUS wmi_extract_gpio_input_ev_param(void *wmi_hdl, + void *evt_buf, uint32_t *gpio_num); + +QDF_STATUS wmi_extract_pdev_reserve_ast_ev_param(void *wmi_hdl, + void *evt_buf, uint32_t *result); + +QDF_STATUS wmi_extract_nfcal_power_ev_param(void *wmi_hdl, void *evt_buf, + wmi_host_pdev_nfcal_power_all_channels_event *param); + +QDF_STATUS wmi_extract_pdev_tpc_ev_param(void *wmi_hdl, void *evt_buf, + wmi_host_pdev_tpc_event *param); + +QDF_STATUS wmi_extract_pdev_generic_buffer_ev_param(void *wmi_hdl, + void *evt_buf, + wmi_host_pdev_generic_buffer_event *param); + +QDF_STATUS wmi_extract_mgmt_tx_compl_param(void *wmi_hdl, void *evt_buf, + wmi_host_mgmt_tx_compl_event *param); + +QDF_STATUS wmi_extract_swba_vdev_map(void *wmi_hdl, void *evt_buf, + uint32_t *vdev_map); + +QDF_STATUS wmi_extract_swba_tim_info(void *wmi_hdl, void *evt_buf, + uint32_t idx, wmi_host_tim_info *tim_info); + +QDF_STATUS wmi_extract_swba_noa_info(void *wmi_hdl, void *evt_buf, + uint32_t idx, wmi_host_p2p_noa_info *p2p_desc); + +QDF_STATUS wmi_extract_peer_sta_ps_statechange_ev(void *wmi_hdl, + void *evt_buf, wmi_host_peer_sta_ps_statechange_event *ev); + +QDF_STATUS wmi_extract_peer_sta_kickout_ev(void *wmi_hdl, void *evt_buf, + wmi_host_peer_sta_kickout_event *ev); + +QDF_STATUS wmi_extract_peer_ratecode_list_ev(void *wmi_hdl, void *evt_buf, + uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap); + +QDF_STATUS wmi_extract_rtt_hdr(void *wmi_hdl, void *evt_buf, + wmi_host_rtt_event_hdr *ev); + +QDF_STATUS wmi_extract_rtt_ev(void *wmi_hdl, void *evt_buf, + wmi_host_rtt_meas_event *ev, uint8_t *hdump, + uint16_t hdump_len); + +QDF_STATUS wmi_extract_rtt_error_report_ev(void *wmi_hdl, void *evt_buf, + wmi_host_rtt_error_report_event *ev); + +QDF_STATUS wmi_extract_thermal_stats(void *wmi_hdl, void *evt_buf, + uint32_t *temp, uint32_t *level); + +QDF_STATUS wmi_extract_thermal_level_stats(void *wmi_hdl, void *evt_buf, + uint8_t idx, uint32_t *levelcount, uint32_t *dccount); + +QDF_STATUS wmi_extract_comb_phyerr(void *wmi_hdl, void *evt_buf, + uint16_t datalen, uint16_t *buf_offset, + wmi_host_phyerr_t *phyerr); + +QDF_STATUS wmi_extract_single_phyerr(void *wmi_hdl, void *evt_buf, + uint16_t datalen, uint16_t *buf_offset, + wmi_host_phyerr_t *phyerr); + +QDF_STATUS wmi_extract_composite_phyerr(void *wmi_hdl, void *evt_buf, + uint16_t datalen, wmi_host_phyerr_t *phyerr); + +QDF_STATUS wmi_extract_profile_ctx(void *wmi_hdl, void *evt_buf, + wmi_host_wlan_profile_ctx_t *profile_ctx); + +QDF_STATUS wmi_extract_profile_data(void *wmi_hdl, void *evt_buf, + wmi_host_wlan_profile_t *profile_data); + +QDF_STATUS wmi_extract_chan_info_event(void *wmi_hdl, void *evt_buf, + wmi_host_chan_info_event *chan_info); + +QDF_STATUS wmi_extract_channel_hopping_event(void *wmi_hdl, void *evt_buf, + wmi_host_pdev_channel_hopping_event *ch_hopping); + +QDF_STATUS wmi_extract_stats_param(void *wmi_hdl, void *evt_buf, + wmi_host_stats_event *stats_param); + +QDF_STATUS wmi_extract_pdev_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, + wmi_host_pdev_stats *pdev_stats); + +QDF_STATUS wmi_extract_pdev_ext_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, + wmi_host_pdev_ext_stats *pdev_ext_stats); + +QDF_STATUS wmi_extract_peer_extd_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, + wmi_host_peer_extd_stats *peer_extd_stats); + +QDF_STATUS wmi_extract_bss_chan_info_event(void *wmi_hdl, void *evt_buf, + wmi_host_pdev_bss_chan_info_event *bss_chan_info); + +QDF_STATUS wmi_extract_inst_rssi_stats_event(void *wmi_hdl, void *evt_buf, + wmi_host_inst_stats_resp *inst_rssi_resp); + +QDF_STATUS wmi_extract_peer_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, wmi_host_peer_stats *peer_stats); + +QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf, + wmi_host_tx_data_traffic_ctrl_event *ev); + +QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, wmi_host_vdev_stats *vdev_stats); + +QDF_STATUS wmi_extract_vdev_extd_stats(void *wmi_hdl, void *evt_buf, + uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats); #endif /* _WMI_UNIFIED_API_H_ */ diff --git a/wmi_unified_non_tlv.h b/wmi_unified_non_tlv.h index 6dfaa8851d..18dc047240 100644 --- a/wmi_unified_non_tlv.h +++ b/wmi_unified_non_tlv.h @@ -108,10 +108,6 @@ QDF_STATUS send_stats_request_cmd_non_tlv(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct stats_request_params *param); -QDF_STATUS send_packet_log_enable_cmd_non_tlv(wmi_unified_t wmi_handle, - uint8_t macaddr[IEEE80211_ADDR_LEN], - struct packet_enable_params *param); - QDF_STATUS send_beacon_send_cmd_non_tlv(wmi_unified_t wmi_handle, struct beacon_params *param); diff --git a/wmi_unified_param.h b/wmi_unified_param.h index f26aeb73a4..d447ec3825 100644 --- a/wmi_unified_param.h +++ b/wmi_unified_param.h @@ -69,12 +69,12 @@ #define WMI_ROAM_SCAN_PSK_SIZE 32 #endif #define WMI_NOISE_FLOOR_DBM_DEFAULT (-96) +#define WMI_MAC_IPV6_ADDR_LEN 16 #ifdef WLAN_NS_OFFLOAD /* support only one IPv6 offload */ #define WMI_MAC_NS_OFFLOAD_SIZE 1 /* Number of target IP V6 addresses for NS offload */ #define WMI_MAC_NUM_TARGET_IPV6_NS_OFFLOAD_NA 16 -#define WMI_MAC_IPV6_ADDR_LEN 16 #define WMI_IPV6_ADDR_VALID 1 #endif /* WLAN_NS_OFFLOAD */ #define WMI_EXTSCAN_MAX_HOTLIST_SSIDS 8 @@ -89,8 +89,175 @@ #define WMI_SEC_TO_MSEC(sec) (sec * 1000) /* sec to msec */ #define WMI_MSEC_TO_USEC(msec) (msec * 1000) /* msec to usec */ #define WMI_NLO_FREQ_THRESH 1000 /* in MHz */ + +#define MAX_UTF_EVENT_LENGTH 2048 +#define MAX_WMI_UTF_LEN 252 +#define MAX_WMI_QVIT_LEN 252 +#define THERMAL_LEVELS 4 +#define WMI_HOST_BCN_FLT_MAX_SUPPORTED_IES 256 +#define WMI_HOST_BCN_FLT_MAX_ELEMS_IE_LIST \ + (WMI_HOST_BCN_FLT_MAX_SUPPORTED_IES/32) +#define LTEU_MAX_BINS 10 +#define ATF_ACTIVED_MAX_CLIENTS 50 +#define ATF_ACTIVED_MAX_ATFGROUPS 8 +#define CTL_5G_SIZE 1536 +#define CTL_2G_SIZE 684 +#define MAX_CTL_SIZE (CTL_5G_SIZE > CTL_2G_SIZE ? CTL_5G_SIZE : CTL_2G_SIZE) +#define IEEE80211_MICBUF_SIZE (8+8) +#define IEEE80211_TID_SIZE 17 +#define WME_NUM_AC 4 +#define SMART_ANT_MODE_SERIAL 0 +#define SMART_ANT_MODE_PARALLEL 1 +#define IEEE80211_WEP_NKID 4 /* number of key ids */ +#define WPI_IV_LEN 16 +#define WMI_SCAN_MAX_NUM_BSSID 10 +#define MAX_CHANS 1023 +#define TARGET_OEM_CONFIGURE_LCI 0x0A +#define RTT_LCI_ALTITUDE_MASK 0x3FFFFFFF +#define TARGET_OEM_CONFIGURE_LCR 0x09 +#define RTT_TIMEOUT_MS 180 +#define MAX_SUPPORTED_RATES 128 +#define WMI_HOST_MAX_BUFFER_SIZE 1712 + +#define WMI_HOST_F_MS(_v, _f) \ + (((_v) & (_f)) >> (_f##_S)) + +#define WMI_HOST_F_RMW(_var, _v, _f) \ + do { \ + (_var) &= ~(_f); \ + (_var) |= (((_v) << (_f##_S)) & (_f)); \ + } while (0) + +/* TXBF capabilities masks */ +#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 \ + (WMI_HOST_TXBF_CONF_SU_TX_BFEE_M << WMI_HOST_TXBF_CONF_SU_TX_BFEE_S) +#define WMI_HOST_TXBF_CONF_SU_TX_BFEE_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_SU_TX_BFEE) +#define WMI_HOST_TXBF_CONF_SU_TX_BFEE_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_SU_TX_BFEE) + +#define WMI_HOST_TXBF_CONF_MU_TX_BFEE_S 1 +#define WMI_HOST_TXBF_CONF_MU_TX_BFEE_M 0x1 +#define WMI_HOST_TXBF_CONF_MU_TX_BFEE \ + (WMI_HOST_TXBF_CONF_MU_TX_BFEE_M << WMI_HOST_TXBF_CONF_MU_TX_BFEE_S) +#define WMI_HOST_TXBF_CONF_MU_TX_BFEE_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_MU_TX_BFEE) +#define WMI_HOST_TXBF_CONF_MU_TX_BFEE_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_MU_TX_BFEE) + +#define WMI_HOST_TXBF_CONF_SU_TX_BFER_S 2 +#define WMI_HOST_TXBF_CONF_SU_TX_BFER_M 0x1 +#define WMI_HOST_TXBF_CONF_SU_TX_BFER \ + (WMI_HOST_TXBF_CONF_SU_TX_BFER_M << WMI_HOST_TXBF_CONF_SU_TX_BFER_S) +#define WMI_HOST_TXBF_CONF_SU_TX_BFER_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_SU_TX_BFER) +#define WMI_HOST_TXBF_CONF_SU_TX_BFER_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_SU_TX_BFER) + +#define WMI_HOST_TXBF_CONF_MU_TX_BFER_S 3 +#define WMI_HOST_TXBF_CONF_MU_TX_BFER_M 0x1 +#define WMI_HOST_TXBF_CONF_MU_TX_BFER \ + (WMI_HOST_TXBF_CONF_MU_TX_BFER_M << WMI_HOST_TXBF_CONF_MU_TX_BFER_S) +#define WMI_HOST_TXBF_CONF_MU_TX_BFER_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_MU_TX_BFER) +#define WMI_HOST_TXBF_CONF_MU_TX_BFER_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_MU_TX_BFER) + +#define WMI_HOST_TXBF_CONF_STS_CAP_S 4 +#define WMI_HOST_TXBF_CONF_STS_CAP_M 0x7 +#define WMI_HOST_TXBF_CONF_STS_CAP \ + (WMI_HOST_TXBF_CONF_STS_CAP_M << WMI_HOST_TXBF_CONF_STS_CAP_S) +#define WMI_HOST_TXBF_CONF_STS_CAP_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_STS_CAP); +#define WMI_HOST_TXBF_CONF_STS_CAP_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_STS_CAP) + +#define WMI_HOST_TXBF_CONF_IMPLICIT_BF_S 7 +#define WMI_HOST_TXBF_CONF_IMPLICIT_BF_M 0x1 +#define WMI_HOST_TXBF_CONF_IMPLICIT_BF \ + (WMI_HOST_TXBF_CONF_IMPLICIT_BF_M << WMI_HOST_TXBF_CONF_IMPLICIT_BF_S) +#define WMI_HOST_TXBF_CONF_IMPLICIT_BF_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_IMPLICIT_BF) +#define WMI_HOST_TXBF_CONF_IMPLICIT_BF_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_IMPLICIT_BF) + +#define WMI_HOST_TXBF_CONF_BF_SND_DIM_S 8 +#define WMI_HOST_TXBF_CONF_BF_SND_DIM_M 0x7 +#define WMI_HOST_TXBF_CONF_BF_SND_DIM \ + (WMI_HOST_TXBF_CONF_BF_SND_DIM_M << WMI_HOST_TXBF_CONF_BF_SND_DIM_S) +#define WMI_HOST_TXBF_CONF_BF_SND_DIM_GET(x) \ + WMI_HOST_F_MS(x, WMI_HOST_TXBF_CONF_BF_SND_DIM) +#define WMI_HOST_TXBF_CONF_BF_SND_DIM_SET(x, z) \ + WMI_HOST_F_RMW(x, z, WMI_HOST_TXBF_CONF_BF_SND_DIM) + +#define WMI_HOST_TPC_RATE_MAX 160 +#define WMI_HOST_TPC_TX_NUM_CHAIN 4 +#define WMI_HOST_RXG_CAL_CHAN_MAX 4 +#define WMI_HOST_MAX_NUM_CHAINS 4 + #include "qdf_atomic.h" +#ifdef BIG_ENDIAN_HOST + /* This API is used in copying in elements to WMI message, + since WMI message uses multilpes of 4 bytes, This API + converts length into multiples of 4 bytes, and performs copy + */ +#define WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(destp, srcp, len) do { \ + int j; \ + u_int32_t *src, *dest; \ + src = (u_int32_t *)srcp; \ + dest = (u_int32_t *)destp; \ + for (j = 0; j < roundup(len, sizeof(u_int32_t))/4; j++) { \ + *(dest+j) = qdf_le32_to_cpu(*(src+j)); \ + } \ +} while (0) +#else + +#define WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(destp, srcp, len) OS_MEMCPY(destp,\ + srcp, len) + +#endif + +/** macro to convert MAC address from WMI word format to char array */ +#define WMI_HOST_MAC_ADDR_TO_CHAR_ARRAY(pwmi_mac_addr, c_macaddr) do { \ + (c_macaddr)[0] = ((pwmi_mac_addr)->mac_addr31to0) & 0xff; \ + (c_macaddr)[1] = (((pwmi_mac_addr)->mac_addr31to0) >> 8) & 0xff; \ + (c_macaddr)[2] = (((pwmi_mac_addr)->mac_addr31to0) >> 16) & 0xff; \ + (c_macaddr)[3] = (((pwmi_mac_addr)->mac_addr31to0) >> 24) & 0xff; \ + (c_macaddr)[4] = ((pwmi_mac_addr)->mac_addr47to32) & 0xff; \ + (c_macaddr)[5] = (((pwmi_mac_addr)->mac_addr47to32) >> 8) & 0xff; \ + } while (0) + +#define TARGET_INIT_STATUS_SUCCESS 0x0 +#define TARGET_INIT_STATUS_GEN_FAILED 0x1 +#define TARGET_GET_INIT_STATUS_REASON(status) ((status) & 0xffff) +#define TARGET_GET_INIT_STATUS_MODULE_ID(status) (((status) >> 16) & 0xffff) +typedef uint32_t TARGET_INIT_STATUS; + +typedef enum { + WMI_HOST_MODE_11A = 0, /* 11a Mode */ + WMI_HOST_MODE_11G = 1, /* 11b/g Mode */ + WMI_HOST_MODE_11B = 2, /* 11b Mode */ + WMI_HOST_MODE_11GONLY = 3, /* 11g only Mode */ + WMI_HOST_MODE_11NA_HT20 = 4, /* 11a HT20 mode */ + WMI_HOST_MODE_11NG_HT20 = 5, /* 11g HT20 mode */ + WMI_HOST_MODE_11NA_HT40 = 6, /* 11a HT40 mode */ + WMI_HOST_MODE_11NG_HT40 = 7, /* 11g HT40 mode */ + WMI_HOST_MODE_11AC_VHT20 = 8, + WMI_HOST_MODE_11AC_VHT40 = 9, + WMI_HOST_MODE_11AC_VHT80 = 10, + WMI_HOST_MODE_11AC_VHT20_2G = 11, + WMI_HOST_MODE_11AC_VHT40_2G = 12, + WMI_HOST_MODE_11AC_VHT80_2G = 13, + WMI_HOST_MODE_11AC_VHT80_80 = 14, + WMI_HOST_MODE_11AC_VHT160 = 15, + WMI_HOST_MODE_UNKNOWN = 16, + WMI_HOST_MODE_MAX = 16 +} WMI_HOST_WLAN_PHY_MODE; + + #define MAX_NUM_CHAN 128 /** @@ -113,6 +280,50 @@ struct vdev_delete_params { uint8_t if_id; }; +/** + * struct channel_param - Channel paramters with all + * info required by target. + * @chan_id: channel id + * @pwr: channel power + * @mhz: channel frequency + * @half_rate: is half rate + * @quarter_rate: is quarter rate + * @dfs_set: is dfs channel + * @dfs_set_cfreq2: is secondary freq dfs channel + * @is_chan_passive: is this passive channel + * @allow_ht: HT allowed in chan + * @allow_vht: VHT allowed on chan + * @phy_mode: phymode (vht80 or ht40 or ...) + * @cfreq1: centre frequency on primary + * @cfreq2: centre frequency on secondary + * @maxpower: max power for channel + * @minpower: min power for channel + * @maxreqpower: Max regulatory power + * @antennamac: Max antenna + * @reg_class_id: Regulatory class id. + */ + +struct channel_param { + uint8_t chan_id; + uint8_t pwr; + uint32_t mhz; + uint32_t half_rate:1, + quarter_rate:1, + dfs_set:1, + dfs_set_cfreq2:1, + is_chan_passive:1, + allow_ht:1, + allow_vht:1; + uint32_t phy_mode; + uint32_t cfreq1; + uint32_t cfreq2; + int8_t maxpower; + int8_t minpower; + int8_t maxregpower; + uint8_t antennamax; + uint8_t reg_class_id; +}; + /** * struct vdev_stop_params - vdev stop cmd parameter * @vdev_id: vdev id @@ -175,6 +386,12 @@ struct mac_ssid { * @reg_info_1: to update min power, max power, * reg power and reg class id * @reg_info_2: to update antennamax + * @oper_mode: Operating mode + * @dfs_pri_multiplier: DFS primary multiplier + * allow pulse if they are within multiple of PRI for the radar type + * @dot11_mode: Phy mode (VHT20/VHT80...) + * @disable_hw_ack: Disable hw ack if chan is dfs channel for cac + * @channel_param: Channel params required by target. */ struct vdev_start_params { uint8_t vdev_id; @@ -198,6 +415,13 @@ struct vdev_start_params { uint32_t num_noa_descriptors; uint32_t preferred_rx_streams; uint32_t preferred_tx_streams; +#ifdef WMI_NON_TLV_SUPPORT + uint8_t oper_mode; + int32_t dfs_pri_multiplier; + uint8_t dot11_mode; + uint8_t disable_hw_ack; + struct channel_param channel; +#endif }; /** @@ -247,6 +471,44 @@ struct vdev_set_params { uint32_t param_value; }; +/** + * struct vdev_install_key_params - vdev key set cmd parameter + * @wk_keylen: key length + * @wk_flags: key flags + * @ic_cipher: cipher + * @if_id: vdev id + * @is_group_key: Group key + * @wk_keyix: key index + * @def_keyid: default key index + * @wk_keytsc: Key TSC + * @wk_keyrsc: key RSC + * @key_data: pounter to key data + * @force_none: force + * @is_host_based_crypt: Host based encrypt + * @is_xmit_or_recv_key: xmit or recieve key + * @wk_recviv: WAPI recv IV + * @wk_txiv: WAPI TX IV + */ +struct vdev_install_key_params { + uint8_t wk_keylen; + uint16_t wk_flags; + uint8_t ic_cipher; + uint8_t if_id; + bool is_group_key; + uint16_t wk_keyix; + uint8_t def_keyid; + uint64_t wk_keytsc; + uint64_t *wk_keyrsc; + uint8_t *key_data; + uint8_t force_none; + bool is_host_based_crypt; + bool is_xmit_or_recv_key; +#if ATH_SUPPORT_WAPI + uint8_t *wk_recviv; + uint32_t *wk_txiv; +#endif +}; + /** * struct peer_delete_params - peer delete cmd parameter * @vdev_id: vdev id @@ -301,14 +563,46 @@ struct peer_remove_params { bool roam_synch_in_progress; }; +/** + * Stats ID enums defined in host + */ +typedef enum { + WMI_HOST_REQUEST_PEER_STAT = 0x01, + WMI_HOST_REQUEST_AP_STAT = 0x02, + WMI_HOST_REQUEST_PDEV_STAT = 0x04, + WMI_HOST_REQUEST_VDEV_STAT = 0x08, + WMI_HOST_REQUEST_BCNFLT_STAT = 0x10, + WMI_HOST_REQUEST_VDEV_RATE_STAT = 0x20, + WMI_HOST_REQUEST_INST_STAT = 0x40, + WMI_HOST_REQUEST_PEER_EXTD_STAT = 0x80, + WMI_HOST_REQUEST_VDEV_EXTD_STAT = 0x100, +} wmi_host_stats_id; + +typedef struct { + uint16_t cfg_retry_count; + uint16_t retry_count; +} wmi_host_inst_rssi_args; + /** * struct stats_request_params - stats_request cmd parameter * @stats_id: statistics id * @vdev_id: vdev id + * @wmi_host_inst_rssi_args: Instantaneous rssi stats args */ struct stats_request_params { uint32_t stats_id; uint32_t vdev_id; +#ifdef WMI_NON_TLV_SUPPORT + wmi_host_inst_rssi_args rssi_args; +#endif +}; + +/** + * struct bss_chan_info_request_params - BSS chan info params + * @param: parameter value + */ +struct bss_chan_info_request_params { + uint32_t param; }; /** @@ -331,6 +625,41 @@ struct wow_cmd_params { uint8_t pause_iface_config; }; +/** + * struct wow_add_wakeup_params - wow wakeup parameter + * @type: param type + */ +struct wow_add_wakeup_params { + uint32_t type; +}; + +/** + * struct wow_add_wakeup_pattern_params - Add WoW pattern params + * @pattern_bytes: pointer to pattern bytes + * @mask_bytes: pointer to mask bytes + * @pattern_len: pattern length + * @pattern_id: pattern id + */ +struct wow_add_wakeup_pattern_params { + uint8_t *pattern_bytes; + uint8_t *mask_bytes; + uint32_t pattern_len; + uint32_t pattern_id; +}; + +/** + * struct wow_remove_wakeup_pattern params - WoW remove pattern param + * @pattern_bytes: pointer to pattern bytes + * @mask_bytes: Mask bytes + * @pattern_id: pattern identifier + */ +struct wow_remove_wakeup_pattern_params { + uint32_t *pattern_bytes; + uint32_t *mask_bytes; + uint32_t pattern_id; +}; + + /** * struct packet_enable_params - packet enable cmd parameter * @vdev_id: vdev id @@ -360,7 +689,24 @@ struct pdev_params { }; /** - * struct beacon_params - beacon template cmd parameter + * struct beacon_tmpl_params - beacon template cmd parameter + * @vdev_id: vdev id + * @tim_ie_offset: tim ie offset + * @tmpl_len: beacon template length + * @tmpl_len_aligned: beacon template alignment + * @frm: beacon template parameter + */ +struct beacon_tmpl_params { + uint8_t vdev_id; + uint32_t tim_ie_offset; + uint32_t tmpl_len; + uint32_t tmpl_len_aligned; + uint8_t *frm; +}; + +#ifndef WMI_NON_TLV_SUPPORT +/** + * struct beacon_params - beacon cmd parameter * @vdev_id: vdev id * @tim_ie_offset: tim ie offset * @tmpl_len: beacon template length @@ -374,6 +720,56 @@ struct beacon_params { uint32_t tmpl_len_aligned; uint8_t *frm; }; +#else +/** + * struct beacon_params - beacon cmd parameter + * @vdev_id: vdev id + * @beaconInterval: Beacon interval + * @wbuf: beacon buffer + * @frame_ctrl: frame control field + * @bcn_txant: beacon antenna + * @is_dtim_count_zero: is it dtim beacon + * @is_bitctl_reqd: is Bit control required + * @is_high_latency: Is this high latency target + */ +struct beacon_params { + uint8_t vdev_id; + uint16_t beaconInterval; + qdf_nbuf_t wbuf; + uint16_t frame_ctrl; + uint32_t bcn_txant; + bool is_dtim_count_zero; + bool is_bitctl_reqd; + bool is_high_latency; +}; +#endif + +/** + * struct bcn_prb_template_params - beacon probe template parameter + * @vdev_id: vdev id + * @buf_len: Template length + * @caps: capabilities field + * @erp: ERP field + */ +struct bcn_prb_template_params { + uint8_t vdev_id; + int buf_len; + uint16_t caps; + uint8_t erp; +}; + +#define WMI_MAX_SUPPORTED_RATES 128 +/** + * struct target_rate_set - Rate set bitmap + * @num_rate: number of rates in rates bitmap + * @rates: rates (each 8bit value) packed into a 32 bit word. + * the rates are filled from least significant byte to most + * significant byte. + */ +typedef struct { + uint32_t num_rates; + uint32_t rates[(WMI_MAX_SUPPORTED_RATES / 4) + 1]; +} target_rate_set; /** * struct peer_assoc_params - peer assoc cmd parameter @@ -398,6 +794,29 @@ struct beacon_params { * @tx_max_rate: max tx rates * @tx_mcs_set: tx mcs * @vht_capable: VHT capabalities + * @tx_max_mcs_nss: max tx MCS and NSS + * @peer_bw_rxnss_override: Peer BW RX NSS overriden or not. + * @is_pmf_enabled: PMF enabled + * @is_wme_set: WME enabled + * @qos_flag: QoS Flags + * @apsd_flag: APSD flags + * @ht_flag: HT flags + * @bw_40: 40 capabale + * @bw_80: 80 capabale + * @bw_160: 160 capabale + * @stbc_flag: STBC flag + * @ldpc_flag: LDPC flag + * @static_mimops_flag: statis MIMO PS flags + * @dynamic_mimops_flag: Dynamic MIMO PS flags + * @spatial_mux_flag: spatial MUX flags + * @vht_flag: VHT flags + * @vht_ng_flag: VHT on 11N/G flags + * @need_ptk_4_way: Needs 4 way handshake + * @need_gtk_2_way: Needs 2 way GTK + * @auth_flag: Is peer authenticated + * @safe_mode_enabled: Safe enabled for this peer + * @amsdu_disable: AMSDU disble + * @peer_mac: Peer mac address */ struct peer_assoc_params { wmi_mac_addr peer_macaddr; @@ -415,13 +834,44 @@ struct peer_assoc_params { uint32_t peer_vht_caps; uint32_t peer_phymode; uint32_t peer_ht_info[2]; +#ifndef WMI_NON_TLV_SUPPORT wmi_rate_set peer_legacy_rates; wmi_rate_set peer_ht_rates; +#else + target_rate_set peer_legacy_rates; + target_rate_set peer_ht_rates; +#endif uint32_t rx_max_rate; uint32_t rx_mcs_set; uint32_t tx_max_rate; uint32_t tx_mcs_set; uint8_t vht_capable; +#ifdef WMI_NON_TLV_SUPPORT + uint32_t tx_max_mcs_nss; + uint32_t peer_bw_rxnss_override; + bool is_pmf_enabled; + bool is_wme_set; + bool qos_flag; + bool apsd_flag; + bool ht_flag; + bool bw_40; + bool bw_80; + bool bw_160; + bool stbc_flag; + bool ldpc_flag; + bool static_mimops_flag; + bool dynamic_mimops_flag; + bool spatial_mux_flag; + bool vht_flag; + bool vht_ng_flag; + bool need_ptk_4_way; + bool need_gtk_2_way; + bool auth_flag; + bool safe_mode_enabled; + bool amsdu_disable; + /* Use common structure */ + uint8_t peer_mac[IEEE80211_ADDR_LEN]; +#endif }; /** @@ -448,6 +898,11 @@ struct ap_ps_params { uint32_t value; }; +#define WMI_HOST_SCAN_CHAN_FREQ_SHIFT 0 +#define WMI_HOST_SCAN_CHAN_FREQ_MASK 0xffff +#define WMI_HOST_SCAN_CHAN_MODE_SHIFT 16 +#define WMI_HOST_SCAN_CHAN_MODE_MASK 0xff + /** * struct scan_start_params - start scan cmd parameter * @scan_id: scan id @@ -477,6 +932,17 @@ struct ap_ps_params { * @sid: pointer to mac_ssid structure * @uie_fieldOffset: ie field offset * @mac_add_bytes: mac address bytes + * @is_strict_pscan_en: Is this a strict passive scan + * @is_promiscous_mode: Is promiscous mode + * @is_phy_error: is Phy error + * @add_cck_rates: Add cck rates + * @chan_stat_enable: channel stats enabled + * @offchan_tx_mgmt: Offchan tx scan + * @offchan_tx_data: offchan tx data + * @add_bcast_probe_reqd: Add bcast probe request + * @bssid_list: Lisst of bssid to scan + * @ie_data: IE data buffer pointer + * @passive_flag: Is this passive scan */ struct scan_start_params { uint32_t scan_id; @@ -506,6 +972,19 @@ struct scan_start_params { uint8_t *ie_base; uint16_t uie_fieldOffset; uint8_t mac_add_bytes[IEEE80211_ADDR_LEN]; +#ifdef WMI_NON_TLV_SUPPORT + bool is_strict_pscan_en; + bool is_promiscous_mode; + bool is_phy_error; + bool add_cck_rates; + bool chan_stat_enable; + bool offchan_tx_mgmt; + bool offchan_tx_data; + bool add_bcast_probe_reqd; + uint8_t bssid_list[WMI_SCAN_MAX_NUM_BSSID][IEEE80211_ADDR_LEN]; + uint8_t *ie_data; + int passive_flag; +#endif }; /** @@ -514,12 +993,24 @@ struct scan_start_params { * @scan_id: scan id * @req_type: scan request type * @vdev_id: vdev id + * @all_scans: Stop all scans + * @vap_scans: stop vap scans + * @specific_scan: specific scan + * @flags: scan flags + * @ss_scan_id: ss scan id */ struct scan_stop_params { uint32_t requestor; uint32_t scan_id; uint32_t req_type; uint32_t vdev_id; +#ifdef WMI_NON_TLV_SUPPORT + bool all_scans; + bool vap_scans; + bool specific_scan; + uint32_t flags; + uint32_t ss_scan_id; +#endif }; /** @@ -527,10 +1018,24 @@ struct scan_stop_params { * @num_scan_chans: no of scan channels * @chan_info: pointer to wmi channel info */ +#ifndef WMI_NON_TLV_SUPPORT struct scan_chan_list_params { uint8_t num_scan_chans; wmi_channel *chan_info; }; +#else +/** + * struct scan_chan_list_params - scan channel list cmd parameter + * @num_chan: no of scan channels + * @nallchans: nall chans + * @ch_param: pointer to channel_paramw + */ +struct scan_chan_list_params { + uint8_t num_chan; + uint16_t nallchans; + struct channel_param ch_param[1]; +}; +#endif /** * struct fw_hang_params - fw hang command parameters @@ -546,12 +1051,28 @@ struct fw_hang_params { * struct pdev_utf_params - pdev utf command parameters * @utf_payload: * @len: + * @is_ar900b: is it 900b target */ struct pdev_utf_params { uint8_t *utf_payload; uint32_t len; +#ifdef WMI_NON_TLV_SUPPORT + bool is_ar900b; +#endif }; +/*Adding this due to dependency on wmi_unified.h + */ +typedef struct { + uint32_t len; + uint32_t msgref; + uint32_t segmentInfo; +} QVIT_SEG_HDR_INFO_STRUCT; + +struct pdev_qvit_params { + uint8_t *utf_payload; + uint32_t len; +}; /** * struct crash_inject - crash inject command parameters * @type: crash inject type @@ -568,12 +1089,16 @@ struct crash_inject { * @val: parameter value * @module_id_bitmap: fixed length module id bitmap * @bitmap_len: module id bitmap length + * @cfgvalid: cfgvalid */ struct dbglog_params { uint32_t param; uint32_t val; uint32_t *module_id_bitmap; uint32_t bitmap_len; +#ifdef WMI_NON_TLV_SUPPORT + uint32_t cfgvalid[2]; +#endif }; /** @@ -593,24 +1118,32 @@ struct seg_hdr_info { /** * struct wmi_mgmt_params - wmi mgmt cmd paramters * @tx_frame: management tx frame - * @frmLen: frame length + * @frm_len: frame length * @vdev_id: vdev id * @tx_complete_cb: tx download callback handler * @tx_ota_post_proc_cb: OTA complition handler * @chanfreq: channel frequency * @pdata: frame data * @wmi_desc: command descriptor + * @desc_id: descriptor id relyaed back by target + * @macaddr - macaddr of peer */ struct wmi_mgmt_params { void *tx_frame; uint16_t frm_len; uint8_t vdev_id; - void *tx_complete_cb; - void *tx_ota_post_proc_cb; uint16_t chanfreq; void *pdata; + uint16_t desc_id; + uint8_t *macaddr; +#ifndef WMI_NON_TLV_SUPPORT + /* Following elements should be moved to WMA + */ + void *tx_complete_cb; + void *tx_ota_post_proc_cb; struct wmi_desc_t *wmi_desc; void *qdf_ctx; +#endif }; /** @@ -1039,7 +1572,12 @@ struct roam_offload_scan_params { #endif bool is_ese_assoc; struct mobility_domain_info mdid; +#ifndef WMI_NON_TLV_SUPPORT + /* THis is not available in non tlv target. + * please remove this and replace with a host based + * structure */ wmi_roam_offload_tlv_param roam_offload_params; +#endif }; /* struct roam_offload_scan_rssi_params - structure containing @@ -2223,6 +2761,15 @@ struct flashing_req_params { uint32_t led_x1; }; +#define MAX_MEM_CHUNKS 32 +/** + * struct wmi_host_mem_chunk - host memory chunk structure + * @vaddr: Pointer to virtual address + * @paddr: Physical address + * @memctx: qdf memory context for mapped address. + * @len: length of chunk + * @req_id: request id from target + */ struct wmi_host_mem_chunk { uint32_t *vaddr; uint32_t paddr; @@ -2231,6 +2778,11 @@ struct wmi_host_mem_chunk { uint32_t req_id; }; +/** + * struct target_resource_config - Resource config given to target + * This structure is union of wmi_resource_config defined + * by both TLV and non-TLV target. + */ struct target_resource_config { uint32_t num_vdevs; uint32_t num_peers; @@ -2478,7 +3030,7 @@ struct ssid_hotlist_request_params { */ struct wmi_unit_test_cmd { uint32_t vdev_id; - WLAN_MODULE_ID module_id; + uint32_t module_id; uint32_t num_args; uint32_t args[WMI_MAX_NUM_ARGS]; }; @@ -2511,5 +3063,3235 @@ struct ext_scan_setbssi_hotlist_params { uint32_t numAp; struct ap_threshold_params ap[WMI_WLAN_EXTSCAN_MAX_HOTLIST_APS]; }; + +/** + * struct TARGET_HAL_REG_CAPABILITIES - This is replication of REG table + * structure defined by target. This is added here to remove dependency + * on FW headers so that host can be agnostic to different defintions in + * both the targets. + */ +typedef struct { + uint32_t eeprom_rd; /* regdomain value specified in EEPROM */ + uint32_t eeprom_rd_ext; /* regdomain */ + uint32_t regcap1; /* CAP1 capabilities bit map */ + uint32_t regcap2; /* REGDMN EEPROM CAP */ + uint32_t wireless_modes; /* REGDMN MODE */ + uint32_t low_2ghz_chan; + uint32_t high_2ghz_chan; + uint32_t low_5ghz_chan; + uint32_t high_5ghz_chan; +} TARGET_HAL_REG_CAPABILITIES; + +/** + * struct host_mem_req - Host memory request paramseters request by target + * @req_id: Request id to identify the request. + * @unit_size: Size of single unit requested. + * @num_unit_info: Memory chunk info + * @num_units: number of units requested. + */ +typedef struct { + uint32_t req_id; + uint32_t unit_size; + uint32_t num_unit_info; + uint32_t num_units; +} host_mem_req; + +#define WMI_HOST_DSCP_MAP_MAX (64) + +/** + * struct wmi_host_ext_resource_config - Extended resource config + * @host_platform_config: Host plaform configuration. + * @fw_featuew_bitmap: FW feature requested bitmap. + */ +typedef struct { + uint32_t host_platform_config; + +#define WMI_HOST_FW_FEATURE_LTEU_SUPPORT 0x0001 +#define WMI_HOST_FW_FEATURE_COEX_GPIO_SUPPORT 0x0002 +#define WMI_HOST_FW_FEATURE_AUX_RADIO_SPECTRAL_INTF 0x0004 +#define WMI_HOST_FW_FEATURE_AUX_RADIO_CHAN_LOAD_INTF 0x0008 +#define WMI_HOST_FW_FEATURE_BSS_CHANNEL_INFO_64 0x0010 +#define WMI_HOST_FW_FEATURE_PEER_STATS 0x0020 +#define WMI_HOST_FW_FEATURE_VDEV_STATS 0x0040 + /** + * @brief fw_feature_bitmask - Enable/Disable features in FW + * @details + * The bits in fw_feature_bitmask are used as shown by the masks below: + * 0x0001 - LTEU Config enable/disable + * 0x0002 - COEX GPIO Config enable/disable + * 0x0004 - Aux Radio enhancement for spectral scan enable/disable + * 0x0008 - Aux Radio enhancement for chan load scan enable/disable + * 0x0010 - BSS channel info stats enable/disable + * The features in question are enabled by setting + * the feature's bit to 1, + * or disabled by setting the feature's bit to 0. + */ + uint32_t fw_feature_bitmap; + + /* add new members here */ +} wmi_host_ext_resource_config; + +/** + * struct set_neighbour_rx_params - Neighbour RX params + * @vdev_id: vdev id + * @idx: index of param + * @action: action + * @type: Type of param + */ +struct set_neighbour_rx_params { + uint8_t vdev_id; + uint32_t idx; + uint32_t action; + uint32_t type; +}; + +/** + * struct set_fwtest_params - FW test params + * @arg: FW param id + * @value: value + */ +struct set_fwtest_params { + uint32_t arg; + uint32_t value; +}; + +/** + * struct config_ratemask_params - ratemask config parameters + * @vdev_id: vdev id + * @type: Type + * @lower32: Lower 32 bits + * @higher32: Hogher 32 bits + */ +struct config_ratemask_params { + uint8_t vdev_id; + uint8_t type; + uint32_t lower32; + uint32_t higher32; +}; + +/** + * struct peer_add_wds_entry_params - WDS peer entry add params + * @dest_addr: Pointer to destination macaddr + * @peer_addr: Pointer to peer mac addr + * @flags: flags + */ +struct peer_add_wds_entry_params { + const uint8_t *dest_addr; + uint8_t *peer_addr; + uint32_t flags; +}; + +/** + * struct peer_del_wds_entry_params - WDS peer entry del params + * @dest_addr: Pointer to destination macaddr + */ +struct peer_del_wds_entry_params { + uint8_t *dest_addr; +}; + +/** + * struct peer_updatewds_entry_params - WDS peer entry update params + * @wds_macaddr: Pointer to destination macaddr + * @peer_add: Pointer to peer mac addr + * @flags: flags + */ +struct peer_update_wds_entry_params { + uint8_t *wds_macaddr; + uint8_t *peer_macaddr; + uint32_t flags; +}; + +/** + * struct set_ps_mode_params - PS mode params + * @vdev_id: vdev id + * @psmode: PS mode + */ +struct set_ps_mode_params { + uint8_t vdev_id; + uint8_t psmode; +}; + +/** + * @struct tt_level_config - Set Thermal throttlling config + * @tmplwm: Temperature low water mark + * @tmphwm: Temperature high water mark + * @dcoffpercent: dc off percentage + * @priority: priority + */ +typedef struct { + uint32_t tmplwm; + uint32_t tmphwm; + uint32_t dcoffpercent; + uint32_t priority; +} tt_level_config; + +/** + * struct thermal_mitigation_params - Thermal mitigation params + * @enable: Enable/Disable Thermal mitigation + * @dc: DC + * @dc_per_event: DC per event + * @tt_level_config: TT level config params + */ +struct thermal_mitigation_params { + uint32_t enable; + uint32_t dc; + uint32_t dc_per_event; + tt_level_config levelconf[THERMAL_LEVELS]; +}; + +/** + * struct smart_ant_enable_params - Smart antenna params + * @enable: Enable/Disable + * @mode: SA mode + * @rx_antenna: RX antenna config + * @is_ar900b: Is target ar900b + */ +struct smart_ant_enable_params { + uint32_t enable; + uint32_t mode; + uint32_t rx_antenna; + bool is_ar900b; +}; + +/** + * struct smart_ant_rx_ant_params - RX antenna params + * @antenna: RX antenna + */ +struct smart_ant_rx_ant_params { + uint32_t antenna; +}; + +/** + * struct smart_ant_tx_ant_params - TX antenna param + * @antenna_array: Antenna arry + * @vdev_id: VDEV id + */ +struct smart_ant_tx_ant_params { + uint32_t *antenna_array; + uint8_t vdev_id; +}; + +/** + * struct smart_ant_training_info_params - SA training params + * @vdev_id: VDEV id + * @rate_array: Rates array + * @antenna_array: Antenna array + * @numpkts: num packets for training + */ +struct smart_ant_training_info_params { + uint8_t vdev_id; + uint32_t *rate_array; + uint32_t *antenna_array; + uint32_t numpkts; +}; + +/** + * struct smart_ant_node_config_params - SA node config params + * @vdev_id: VDEV id + * @cmd_id: Command id + * @args_count: Arguments count + */ +struct smart_ant_node_config_params { + uint8_t vdev_id; + uint32_t cmd_id; + uint16_t args_count; + uint32_t *args_arr; +}; +/** + * struct smart_ant_enable_tx_feedback_params - SA tx feeback params + * @enable: Enable TX feedback for SA + */ +struct smart_ant_enable_tx_feedback_params { + int enable; +}; + +/** + * struct vdev_spectral_configure_params - SPectral config params + * @vdev_id: VDEV id + * @count: count + * @period: period + * @spectral_pri: Spectral priority + * @fft_size: FFT size + * @gc_enable: GC enable + * @restart_enable: restart enabled + * @noise_floor_ref: Noise floor reference + * @init_delay: Init delays + * @nb_tone_thr: NB tone threshold + * @str_bin_thr: STR BIN threshold + * @wb_rpt_mode: WB BIN threshold + * @rssi_rpt_mode: RSSI report mode + * @rssi_thr: RSSI threshold + * @pwr_format: Power format + * @rpt_mode: Report mdoe + * @bin_scale: BIN scale + * @dBm_adj: DBM adjust + * @chn_mask: chain mask + */ +struct vdev_spectral_configure_params { + uint8_t vdev_id; + uint16_t count; + uint16_t period; + uint16_t spectral_pri; + uint16_t fft_size; + uint16_t gc_enable; + uint16_t restart_enable; + uint16_t noise_floor_ref; + uint16_t init_delay; + uint16_t nb_tone_thr; + uint16_t str_bin_thr; + uint16_t wb_rpt_mode; + uint16_t rssi_rpt_mode; + uint16_t rssi_thr; + uint16_t pwr_format; + uint16_t rpt_mode; + uint16_t bin_scale; + uint16_t dBm_adj; + uint16_t chn_mask; +}; + +/** + * struct vdev_spectral_enable_params - Spectral enabled params + * @vdev_id: VDEV id + * @active_valid: Active valid + * @active: active + * @enabled_valid: Enabled valid + * @enabled: enabled + */ +struct vdev_spectral_enable_params { + uint8_t vdev_id; + uint8_t active_valid; + uint8_t active; + uint8_t enabled_valid; + uint8_t enabled; +}; + +/** + * struct pdev_set_regdomain_params - PDEV set reg domain params + * @currentRDinuse: Current Reg domain + * @currentRD2G: Current Reg domain 2G + * @currentRD5G: Current Reg domain 5G + * @ctl_2G: CTL 2G + * @ctl_5G: CTL 5G + * @dfsDomain: DFS domain + */ +struct pdev_set_regdomain_params { + uint16_t currentRDinuse; + uint16_t currentRD2G; + uint16_t currentRD5G; + uint32_t ctl_2G; + uint32_t ctl_5G; + uint8_t dfsDomain; +}; + +/** + * struct set_quiet_mode_params - Set quiet mode params + * @enabled: Enabled + * @period: Quite period + * @intval: Quite interval + * @duration: Quite duration + * @offset: offset + */ +struct set_quiet_mode_params { + uint8_t enabled; + uint8_t period; + uint16_t intval; + uint16_t duration; + uint16_t offset; +}; + +/** + * struct set_beacon_filter_params - Set beacon filter params + * @vdev_id: VDEV id + * @ie: Pointer to IE fields + */ +struct set_beacon_filter_params { + uint8_t vdev_id; + uint32_t *ie; +}; + +/** + * struct remove_beacon_filter_params - Remove beacon filter params + * @vdev_id: VDEV id + */ +struct remove_beacon_filter_params { + uint8_t vdev_id; +}; + +/** + * struct mgmt_params - Mgmt params + * @vdev_id: vdev id + * @buf_len: lenght of frame buffer + * @wbuf: frame buffer + */ +struct mgmt_params { + int vdev_id; + uint32_t buf_len; + qdf_nbuf_t wbuf; +}; + +/** + * struct addba_clearresponse_params - Addba clear response params + * @vdev_id: VDEV id + */ +struct addba_clearresponse_params { + uint8_t vdev_id; +}; + +/** + * struct addba_send_params - ADDBA send params + * @vdev_id: vdev id + * @tidno: TID + * @buffersize: buffer size + */ +struct addba_send_params { + uint8_t vdev_id; + uint8_t tidno; + uint16_t buffersize; +}; + +/** + * struct delba_send_params - DELBA send params + * @vdev_id: vdev id + * @tidno: TID + * @initiator: initiator + * @reasoncode: reason code + */ +struct delba_send_params { + uint8_t vdev_id; + uint8_t tidno; + uint8_t initiator; + uint16_t reasoncode; +}; +/** + * struct addba_setresponse_arams - Set ADDBA response params + * @vdev_id: vdev id + * @tidno: TID + * @statuscode: status code in response + */ +struct addba_setresponse_params { + uint8_t vdev_id; + uint8_t tidno; + uint16_t statuscode; +}; + +/** + * struct singleamsdu_params - Single AMSDU params + * @vdev_id: vdev is + * @tidno: TID + */ +struct singleamsdu_params { + uint8_t vdev_id; + uint8_t tidno; +}; + +/** + * struct set_qbosst_params - Set QBOOST params + * @vdev_id: vdev id + * @value: value + */ +struct set_qboost_params { + uint8_t vdev_id; + uint32_t value; +}; + +/** + * struct mu_scan_params - MU scan params + * @id: id + * @type: type + * @duration: Duration + * @lteu_tx_power: LTEU tx power + */ +struct mu_scan_params { + uint8_t id; + uint8_t type; + uint32_t duration; + uint32_t lteu_tx_power; +}; + +/** + * struct lteu_config_params - LTEU config params + * @lteu_gpio_start: start MU/AP scan after GPIO toggle + * @lteu_num_bins: no. of elements in the following arrays + * @use_actual_nf: whether to use the actual NF obtained or a hardcoded one + * @lteu_weight: weights for MU algo + * @lteu_thresh: thresholds for MU algo + * @lteu_gamma: gamma's for MU algo + * @lteu_scan_timeout: timeout in ms to gpio toggle + * @alpha_num_ssid: alpha for num active bssid calculation + * @wifi_tx_power: Wifi Tx power + */ +struct lteu_config_params { + uint8_t lteu_gpio_start; + uint8_t lteu_num_bins; + uint8_t use_actual_nf; + uint32_t lteu_weight[LTEU_MAX_BINS]; + uint32_t lteu_thresh[LTEU_MAX_BINS]; + uint32_t lteu_gamma[LTEU_MAX_BINS]; + uint32_t lteu_scan_timeout; + uint32_t alpha_num_bssid; + uint32_t wifi_tx_power; +}; + +struct wmi_macaddr_t { + /** upper 4 bytes of MAC address */ + uint32_t mac_addr31to0; + /** lower 2 bytes of MAC address */ + uint32_t mac_addr47to32; +}; + +/** + * struct atf_peer_info - ATF peer info params + * @peer_macaddr: peer mac addr + * @percentage_peer: percentage of air time for this peer + */ +typedef struct { + struct wmi_macaddr_t peer_macaddr; + uint32_t percentage_peer; +} atf_peer_info; + +/** + * struct set_atf_params - ATF params + * @num_peers: number of peers + * @atf_peer_info: ATF peer info + */ +struct set_atf_params { + uint32_t num_peers; + atf_peer_info peer_info[ATF_ACTIVED_MAX_CLIENTS]; +}; + +/** + * struct atf_peer_ext_info - ATF peer ext info params + * @peer_macaddr: peer mac address + * @group_index: group index + * @atf_index_reserved: ATF index rsvd + */ +typedef struct { + struct wmi_macaddr_t peer_macaddr; + uint32_t group_index; + uint32_t atf_index_reserved; +} atf_peer_ext_info; + +/** + * struct atf_peer_request_params - ATF peer req params + * @num_peers: number of peers + * @atf_peer_ext_info: ATF peer ext info + */ +struct atf_peer_request_params { + uint32_t num_peers; + atf_peer_ext_info peer_ext_info[ATF_ACTIVED_MAX_CLIENTS]; +}; + +/** + * struct atf_group_info - ATF group info params + * @percentage_group: Percentage AT for group + * @atf_group_units_reserved: ATF group information + */ +typedef struct { + uint32_t percentage_group; + uint32_t atf_group_units_reserved; +} atf_group_info; + +/** + * struct atf_grouping_params - ATF grouping params + * @num_groups: number of groups + * @group_inf: Group informaition + */ +struct atf_grouping_params { + uint32_t num_groups; + atf_group_info group_info[ATF_ACTIVED_MAX_ATFGROUPS]; +}; + +/** + * struct wlan_profile_params - WLAN profile params + * @param_id: param id + * @profile_id: profile id + * @enable: enable + */ +struct wlan_profile_params { + uint32_t param_id; + uint32_t profile_id; + uint32_t enable; +}; + +/* struct ht_ie_params - HT IE params + * @ie_len: IE length + * @ie_data: pointer to IE data + */ +struct ht_ie_params { + uint32_t ie_len; + uint8_t *ie_data; +}; + +/* struct vht_ie_params - VHT IE params + * @ie_len: IE length + * @ie_data: pointer to IE data + */ +struct vht_ie_params { + uint32_t ie_len; + uint8_t *ie_data; +}; + +/** + * struct wmi_host_wmeParams - WME params + * @wmep_acm: ACM paramete + * @wmep_aifsn: AIFSN parameters + * @wmep_logcwmin: cwmin in exponential form + * @wmep_logcwmax: cwmax in exponential form + * @wmep_txopLimit: txopLimit + * @wmep_noackPolicy: No-Ack Policy: 0=ack, 1=no-ack + */ +struct wmi_host_wmeParams { + u_int8_t wmep_acm; + u_int8_t wmep_aifsn; + u_int8_t wmep_logcwmin; + u_int8_t wmep_logcwmax; + u_int16_t wmep_txopLimit; + u_int8_t wmep_noackPolicy; +}; + +/** + * struct wmm_update_params - WMM update params + * @wmep_array: WME params for each AC + */ +struct wmm_update_params { + struct wmi_host_wmeParams *wmep_array; +}; + +/** + * struct ant_switch_tbl_params - Antenna switch table params + * @ant_ctrl_common1: ANtenna control common param 1 + * @ant_ctrl_common2: Antenna control commn param 2 + */ +struct ant_switch_tbl_params { + uint32_t ant_ctrl_common1; + uint32_t ant_ctrl_common2; +}; + +/** + * struct ratepwr_table_params - Rate power table params + * @ratepwr_tbl: pointer to rate power table + * @ratepwr_len: rate power table len + */ +struct ratepwr_table_params { + uint8_t *ratepwr_tbl; + uint16_t ratepwr_len; +}; + +/** + * struct ctl_table_params - Ctl table params + * @ctl_array: pointer to ctl array + * @ctl_len: ctl length + * @is_acfg_ctl: is acfg_ctl table + */ +struct ctl_table_params { + uint8_t *ctl_array; + uint16_t ctl_len; + bool is_acfg_ctl; +}; + +/** + * struct mimogain_table_params - MIMO gain table params + * @array_gain: pointer to array gain table + * @tbl_len: table length + * @multichain_gain_bypass: bypass multichain gain + */ +struct mimogain_table_params { + uint8_t *array_gain; + uint16_t tbl_len; + bool multichain_gain_bypass; +}; + +/** + * struct ratepwr_chainmask_params - Rate power chainmask params + * @ratepwr_chain_tbl: pointer to ratepwr chain table + * @num_rate: number of rate in table + * @pream_type: preamble type + * @ops: ops + */ +struct ratepwr_chainmsk_params { + uint32_t *ratepwr_chain_tbl; + uint16_t num_rate; + uint8_t pream_type; + uint8_t ops; +}; + +struct macaddr_params { + uint8_t *macaddr; +}; + +/** + * struct acparams_params - acparams config structure + * @ac: AC to configure + * @use_rts: Use rts for this AC + * @aggrsize_scaling: Aggregrate size scaling for the AC + * @min_kbps: min kbps req + */ +struct acparams_params { + uint8_t ac; + uint8_t use_rts; + uint8_t aggrsize_scaling; + uint32_t min_kbps; +}; + +/** + * struct vap_dscp_tid_map_params - DSCP tid map params + * @vdev_id: vdev id + * @dscp_to_tid_map: pointer to arry of tid to dscp map table + */ +struct vap_dscp_tid_map_params { + uint8_t vdev_id; + uint32_t *dscp_to_tid_map; +}; + +/** + * struct proxy_ast_reserve_params - Proxy AST reserve params + * @macaddr: macaddr for proxy ast entry + */ +struct proxy_ast_reserve_params { + uint8_t *macaddr; +}; + +/** + * struct fips_params - FIPS params config + * @key: pointer to key + * @key_len: length of key + * @data: pointer data buf + * @data_len: lenght of sata buf + * @mode: mode + * @op: operation + */ +struct fips_params { + uint8_t *key; + uint32_t key_len; + uint8_t *data; + uint32_t data_len; + uint32_t mode; + uint32_t op; +}; + +/** + * struct mcast_group_update_param - Mcast group table update to target + * @action: Addition/deletion + * @wildcard: iwldcard table entry? + * @mcast_ip_addr: mcast ip address to be updated + * @mcast_ip_addr_bytes: mcast ip addr bytes + * @ucast_mac_addr: ucast peer mac subscribed to mcast ip + * @filter_mode: filter mode + * @nsrcs: number of entries in source list + * @srcs: source mac accpted + * @mask: mask + * @vap_id: vdev id + * @is_action_delete: is delete + * @is_filter_mode_snoop: + * @is_mcast_addr_len: + */ +struct mcast_group_update_params { + int action; + int wildcard; + uint8_t *mcast_ip_addr; + int mcast_ip_addr_bytes; + uint8_t *ucast_mac_addr; + uint8_t filter_mode; + uint8_t nsrcs; + uint8_t *srcs; + uint8_t *mask; + uint8_t vap_id; + bool is_action_delete; + bool is_filter_mode_snoop; + bool is_mcast_addr_len; +}; + +/** + * struct periodic_chan_stats_param - periodic channel stats req param + * @stats_period: stats period update + * @enable: enable/disable + */ +struct periodic_chan_stats_params { + uint32_t stats_period; + bool enable; +}; + +/** + * struct packet_power_info_params - packet power info params + * @rate_flags: rate flags + * @nss: number of spatial streams + * @preamble: preamble + * @hw_rate: + */ +struct packet_power_info_params { + uint16_t rate_flags; + uint16_t nss; + uint16_t preamble; + uint16_t hw_rate; +}; + +/** + * WMI_GPIO_CONFIG_CMDID + */ +enum { + WMI_HOST_GPIO_PULL_NONE, + WMI_HOST_GPIO_PULL_UP, + WMI_HOST_GPIO_PULL_DOWN, +}; + +/** + * WMI_GPIO_INTTYPE + */ +enum { + WMI_HOST_GPIO_INTTYPE_DISABLE, + WMI_HOST_GPIO_INTTYPE_RISING_EDGE, + WMI_HOST_GPIO_INTTYPE_FALLING_EDGE, + WMI_HOST_GPIO_INTTYPE_BOTH_EDGE, + WMI_HOST_GPIO_INTTYPE_LEVEL_LOW, + WMI_HOST_GPIO_INTTYPE_LEVEL_HIGH +}; + +/** + * struct wmi_host_gpio_input_event - GPIO input event structure + * @gpio_num: GPIO number which changed state + */ +typedef struct { + uint32_t gpio_num; /* GPIO number which changed state */ +} wmi_host_gpio_input_event; + +/** + * struct gpio_config_params - GPIO config params + * @gpio_num: GPIO number to config + * @input: input/output + * @pull_type: pull type + * @intr_mode: int mode + */ +struct gpio_config_params { + uint32_t gpio_num; + uint32_t input; + uint32_t pull_type; + uint32_t intr_mode; +}; + +/** + * struct gpio_output_params - GPIO output params + * @gpio_num: GPIO number to configure + * @set: set/reset + */ +struct gpio_output_params { + uint32_t gpio_num; + uint32_t set; +}; + +#define WMI_HOST_RTT_REPORT_CFR 0 +#define WMI_HOST_RTT_NO_REPORT_CFR 1 +#define WMI_HOST_RTT_AGGREGATE_REPORT_NON_CFR 2 +/** + * struct rtt_meas_req_test_params + * @peer: peer mac address + * @req_frame_type: RTT request frame type + * @req_bw: requested bandwidth + * @req_preamble: Preamble + * @req_num_req: num of requests + * @req_report_type: report type + * @num_measurements: number of measurements + * @asap_mode: priority + * @lci_requested: LCI requested + * @loc_civ_requested: + * @channel_param: channel param + * @req_id: requested id + */ +struct rtt_meas_req_test_params { + uint8_t peer[IEEE80211_ADDR_LEN]; + int req_frame_type; + int req_bw; + int req_preamble; + int req_num_req; + int req_report_type; + uint32_t num_measurements; + uint32_t asap_mode; + uint32_t lci_requested; + uint32_t loc_civ_requested; + struct channel_param channel; + uint8_t req_id; +}; + +/** + * struct rtt_meas_req_params - RTT measurement request params + * @req_id: Request id + * @vdev_id: vdev id + * @sta_mac_addr: pointer to station mac address + * @spoof_mac_addr: pointer to spoof mac address + * @is_mode_na: 11NA + * @is_mode_ac: AC + * @is_bw_20: 20 + * @is_bw_40: 40 + * @is_bw_80: 80 + * @num_probe_rqst: number of probe request + * @channel_param: channel param + */ +struct rtt_meas_req_params { + uint8_t req_id; + uint8_t vdev_id; + uint8_t *sta_mac_addr; + uint8_t *spoof_mac_addr; + bool is_mode_na; + bool is_mode_ac; + bool is_bw_20; + bool is_bw_40; + bool is_bw_80; + uint32_t num_probe_rqst; + struct channel_param channel; +}; + +/** + * struct lci_set_params - LCI params + * @lci_data: pointer to LCI data + * @latitude_unc: latitude + * @latitude_0_12: bits 0 to 1 of latitude + * @latitude_2_33: bits 2 to 33 of latitude + * @longitude_unc: longitude + * @longitude_0_1: bits 0 to 1 of longitude + * @longitude_2_33: bits 2 to 33 of longitude + * @altitude_type: altitude type + * @altitude_unc_0_3: altitude bits 0 - 3 + * @altitude_unc_4_5: altitude bits 4 - 5 + * @altitude: altitude + * @datum: dataum + * @reg_loc_agmt: + * @reg_loc_dse: + * @dep_sta: + * @version: version + */ +struct lci_set_params { + void *lci_data; + uint8_t latitude_unc:6, + latitude_0_1:2; + uint32_t latitude_2_33; + uint8_t longitude_unc:6, + longitude_0_1:2; + uint32_t longitude_2_33; + uint8_t altitude_type:4, + altitude_unc_0_3:4; + uint32_t altitude_unc_4_5:2, + altitude:30; + uint8_t datum:3, + reg_loc_agmt:1, + reg_loc_dse:1, + dep_sta:1, + version:2; +}; + +/** + * struct lcr_set_params - LCR params + * @lcr_data: pointer to lcr data + */ +struct lcr_set_params { + void *lcr_data; +}; + +/** + * struct rtt_keepalive_req_params - RTT keepalive params + * @macaddr: pointer to macaddress + * @req_id: Request id + * @vdev_id: vdev id + * @stop: start/stop + */ +struct rtt_keepalive_req_params { + uint8_t *macaddr; + uint8_t req_id; + uint8_t vdev_id; + bool stop; +}; + +/** + * struct wmi_host_stats_event - Stats event params + * @stats_id: stats id of type wmi_host_stats_event + * @num_pdev_stats: number of pdev stats event structures 0 or 1 + * @num_pdev_ext_stats: number of pdev ext stats event structures + * @num_vdev_stats: number of vdev stats + * @num_peer_stats: number of peer stats event structures 0 or max peers + * @num_bcnflt_stats: number of beacon filter stats + * @num_chan_stats: number of channel stats + */ +typedef struct { + wmi_host_stats_id stats_id; + uint32_t num_pdev_stats; + uint32_t num_pdev_ext_stats; + uint32_t num_vdev_stats; + uint32_t num_peer_stats; + uint32_t num_bcnflt_stats; + uint32_t num_chan_stats; +} wmi_host_stats_event; + +/** + * struct wmi_host_mac_addr - host mac addr 2 word representation of MAC addr + * @mac_addr31to0: upper 4 bytes of MAC address + * @mac_addr47to32: lower 2 bytes of MAC address + */ +typedef struct { + uint32_t mac_addr31to0; + uint32_t mac_addr47to32; +} wmi_host_mac_addr; + +/** + * struct wmi_host_peer_extd_stats - peer extd stats event structure + * @peer_macaddr: Peer mac address + * @inactive_time: inactive time in secs + * @peer_chain_rssi: peer rssi + * @rx_duration: RX duration + * @peer_tx_bytes: TX bytes + * @peer_rx_bytes: RX bytes + * @last_tx_rate_code: Tx rate code of last frame + * @last_tx_power: Tx power latest + * @atf_tokens_allocated: atf tokens allocated + * @atf_tokens_utilized: atf tokens utilized + * @reserved: for future use + */ +typedef struct { + wmi_host_mac_addr peer_macaddr; + uint32_t inactive_time; + uint32_t peer_chain_rssi; + uint32_t rx_duration; + uint32_t peer_tx_bytes; + uint32_t peer_rx_bytes; + uint32_t last_tx_rate_code; + uint32_t last_tx_power; + uint32_t atf_tokens_allocated; + uint32_t atf_tokens_utilized; + uint32_t reserved[4]; +} wmi_host_peer_extd_stats; + +/** + * struct wmi_host_pdev_ext_stats - peer ext stats structure + * @rx_rssi_comb: RX rssi + * @rx_rssi_chain0: RX rssi chain 0 + * @rx_rssi_chain1: RX rssi chain 1 + * @rx_rssi_chain2: RX rssi chain 2 + * @rx_rssi_chain3: RX rssi chain 3 + * @rx_mcs: RX MCS array + * @tx_mcs: TX MCS array + * @ack_rssi: Ack rssi + */ +typedef struct { + uint32_t rx_rssi_comb; + uint32_t rx_rssi_chain0; + uint32_t rx_rssi_chain1; + uint32_t rx_rssi_chain2; + uint32_t rx_rssi_chain3; + uint32_t rx_mcs[10]; + uint32_t tx_mcs[10]; + uint32_t ack_rssi; +} wmi_host_pdev_ext_stats; + +/** + * struct wmi_host_dbg_tx_stats - Debug stats + * @comp_queued: Num HTT cookies queued to dispatch list + * @comp_delivered: Num HTT cookies dispatched + * @msdu_enqued: Num MSDU queued to WAL + * @mpdu_enqued: Num MPDU queue to WAL + * @wmm_drop: Num MSDUs dropped by WMM limit + * @local_enqued: Num Local frames queued + * @local_freed: Num Local frames done + * @hw_queued: Num queued to HW + * @hw_reaped: Num PPDU reaped from HW + * @underrun: Num underruns + * @hw_paused: HW Paused. + * @tx_abort: Num PPDUs cleaned up in TX abort + * @mpdus_requed: Num MPDUs requed by SW + * @tx_ko: excessive retries + * @tx_xretry: + * @data_rc: data hw rate code + * @self_triggers: Scheduler self triggers + * @sw_retry_failure: frames dropped due to excessive sw retries + * @illgl_rate_phy_err: illegal rate phy errors + * @pdev_cont_xretry: wal pdev continous xretry + * @pdev_tx_timeout: wal pdev continous xretry + * @pdev_resets: wal pdev resets + * @stateless_tid_alloc_failure: frames dropped due to non-availability of + * stateless TIDs + * @phy_underrun: PhY/BB underrun + * @txop_ovf: MPDU is more than txop limit + * @seq_posted: Number of Sequences posted + * @seq_failed_queueing: Number of Sequences failed queueing + * @seq_completed: Number of Sequences completed + * @seq_restarted: Number of Sequences restarted + * @mu_seq_posted: Number of MU Sequences posted + * @mpdus_sw_flush: Num MPDUs flushed by SW, HWPAUSED, SW TXABORT + * (Reset,channel change) + * @mpdus_hw_filter: Num MPDUs filtered by HW, all filter condition + * (TTL expired) + * @mpdus_truncated: Num MPDUs truncated by PDG (TXOP, TBTT, + * PPDU_duration based on rate, dyn_bw) + * @mpdus_ack_failed: Num MPDUs that was tried but didn't receive ACK or BA + * @mpdus_expired: Num MPDUs that was dropped du to expiry. + * @mc_dropr: Num mc drops + */ +typedef struct { + int32_t comp_queued; + int32_t comp_delivered; + int32_t msdu_enqued; + int32_t mpdu_enqued; + int32_t wmm_drop; + int32_t local_enqued; + int32_t local_freed; + int32_t hw_queued; + int32_t hw_reaped; + int32_t underrun; + uint32_t hw_paused; + int32_t tx_abort; + int32_t mpdus_requed; + uint32_t tx_ko; + uint32_t tx_xretry; + uint32_t data_rc; + uint32_t self_triggers; + uint32_t sw_retry_failure; + uint32_t illgl_rate_phy_err; + uint32_t pdev_cont_xretry; + uint32_t pdev_tx_timeout; + uint32_t pdev_resets; + uint32_t stateless_tid_alloc_failure; + uint32_t phy_underrun; + uint32_t txop_ovf; + uint32_t seq_posted; + uint32_t seq_failed_queueing; + uint32_t seq_completed; + uint32_t seq_restarted; + uint32_t mu_seq_posted; + int32_t mpdus_sw_flush; + int32_t mpdus_hw_filter; + int32_t mpdus_truncated; + int32_t mpdus_ack_failed; + int32_t mpdus_expired; + uint32_t mc_drop; +} wmi_host_dbg_tx_stats; + +/** + * struct wmi_host_dbg_rx_stats - RX Debug stats + * @mid_ppdu_route_change: Cnts any change in ring routing mid-ppdu + * @status_rcvd: Total number of statuses processed + * @r0_frags: Extra frags on rings 0 + * @r1_frags: Extra frags on rings 1 + * @r2_frags: Extra frags on rings 2 + * @r3_frags: Extra frags on rings 3 + * @htt_msdus: MSDUs delivered to HTT + * @htt_mpdus: MPDUs delivered to HTT + * @loc_msdus: MSDUs delivered to local stack + * @loc_mpdus: MPDUS delivered to local stack + * @oversize_amsdu: AMSDUs that have more MSDUs than the status ring size + * @phy_errs: Number of PHY errors + * @phy_err_drop: Number of PHY errors drops + * @mpdu_errs: Number of mpdu errors - FCS, MIC, ENC etc. + * @pdev_rx_timeout: Number of rx inactivity timeouts + * @rx_ovfl_errs: Number of rx overflow errors. + */ +typedef struct { + int32_t mid_ppdu_route_change; + int32_t status_rcvd; + int32_t r0_frags; + int32_t r1_frags; + int32_t r2_frags; + int32_t r3_frags; + int32_t htt_msdus; + int32_t htt_mpdus; + int32_t loc_msdus; + int32_t loc_mpdus; + int32_t oversize_amsdu; + int32_t phy_errs; + int32_t phy_err_drop; + int32_t mpdu_errs; + uint32_t pdev_rx_timeout; + int32_t rx_ovfl_errs; +} wmi_host_dbg_rx_stats; + +/** struct wmi_host_dbg_mem_stats - memory stats + * @iram_free_size: IRAM free size on target + * @dram_free_size: DRAM free size on target + * @sram_free_size: SRAM free size on target + */ +typedef struct { + uint32_t iram_free_size; + uint32_t dram_free_size; + /* Only Non-TLV */ + uint32_t sram_free_size; +} wmi_host_dbg_mem_stats; + +typedef struct { + /* Only TLV */ + int32_t dummy;/* REMOVE THIS ONCE REAL PEER STAT COUNTERS ARE ADDED */ +} wmi_host_dbg_peer_stats; + +/** + * struct wmi_host_dbg_stats - host debug stats + * @tx: TX stats of type wmi_host_dbg_tx_stats + * @rx: RX stats of type wmi_host_dbg_rx_stats + * @mem: Memory stats of type wmi_host_dbg_mem_stats + * @peer: peer stats of type wmi_host_dbg_peer_stats + */ +typedef struct { + wmi_host_dbg_tx_stats tx; + wmi_host_dbg_rx_stats rx; + wmi_host_dbg_mem_stats mem; + wmi_host_dbg_peer_stats peer; +} wmi_host_dbg_stats; + +/** + * struct wmi_host_pdev_stats - PDEV stats + * @chan_nf: Channel noise floor + * @tx_frame_count: TX frame count + * @rx_frame_count: RX frame count + * @rx_clear_count: rx clear count + * @cycle_count: cycle count + * @phy_err_count: Phy error count + * @chan_tx_pwr: Channel Tx Power + * @pdev_stats: WAL dbg stats + * @ackRcvBad: + * @rtsBad: + * @rtsGood: + * @fcsBad: + * @noBeacons: + * @mib_int_count: + */ +typedef struct { + int32_t chan_nf; + uint32_t tx_frame_count; + uint32_t rx_frame_count; + uint32_t rx_clear_count; + uint32_t cycle_count; + uint32_t phy_err_count; + uint32_t chan_tx_pwr; + wmi_host_dbg_stats pdev_stats; + uint32_t ackRcvBad; + uint32_t rtsBad; + uint32_t rtsGood; + uint32_t fcsBad; + uint32_t noBeacons; + uint32_t mib_int_count; +} wmi_host_pdev_stats; + +/** + * struct wmi_host_snr_info - WMI host Signal to noise ration info + * @bcn_snr: beacon SNR + * @dat_snr: Data frames SNR + */ +typedef struct { + int32_t bcn_snr; + int32_t dat_snr; +} wmi_host_snr_info; + +#define WMI_HOST_MAX_TX_RATE_VALUES 10 /*Max Tx Rates */ +#define WMI_HOST_MAX_RSSI_VALUES 10 /*Max Rssi values */ + +/* The WLAN_MAX_AC macro cannot be changed without breaking + * * WMI compatibility. + * * The maximum value of access category + * */ +#define WMI_HOST_WLAN_MAX_AC 4 + +/** + * struct wmi_host_vdev_stats - vdev stats structure + * @vdev_id: unique id identifying the VDEV, generated by the caller + * Rest all Only TLV + * @vdev_snr: wmi_host_snr_info + * @tx_frm_cnt: Total number of packets(per AC) that were successfully + * transmitted (with and without retries, + * including multi-cast, broadcast) + * @rx_frm_cnt: Total number of packets that were successfully received + * (after appropriate filter rules including multi-cast, broadcast) + * @multiple_retry_cnt: The number of MSDU packets and MMPDU frames per AC + * that the 802.11 station successfully transmitted after + * more than one retransmission attempt + * @fail_cnt: Total number packets(per AC) failed to transmit + * @rts_fail_cnt: Total number of RTS/CTS sequence failures for transmission + * of a packet + * @rts_succ_cnt: Total number of RTS/CTS sequence success for transmission + * of a packet + * @rx_err_cnt: The receive error count. HAL will provide the + * RxP FCS error global + * @rx_discard_cnt: The sum of the receive error count and + * dropped-receive-buffer error count (FCS error) + * @ack_fail_cnt: Total number packets failed transmit because of no + * ACK from the remote entity + * @tx_rate_history:History of last ten transmit rate, in units of 500 kbit/sec + * @bcn_rssi_history: History of last ten Beacon rssi of the connected Bss + */ +typedef struct { + uint32_t vdev_id; + /* Rest all Only TLV */ + wmi_host_snr_info vdev_snr; + uint32_t tx_frm_cnt[WMI_HOST_WLAN_MAX_AC]; + uint32_t rx_frm_cnt; + uint32_t multiple_retry_cnt[WMI_HOST_WLAN_MAX_AC]; + uint32_t fail_cnt[WMI_HOST_WLAN_MAX_AC]; + uint32_t rts_fail_cnt; + uint32_t rts_succ_cnt; + uint32_t rx_err_cnt; + uint32_t rx_discard_cnt; + uint32_t ack_fail_cnt; + uint32_t tx_rate_history[WMI_HOST_MAX_TX_RATE_VALUES]; + uint32_t bcn_rssi_history[WMI_HOST_MAX_RSSI_VALUES]; +} wmi_host_vdev_stats; + +/** + * struct wmi_host_vdev_extd_stats - VDEV extended stats + * @vdev_id: unique id identifying the VDEV, generated by the caller + * @ppdu_aggr_cnt: No of Aggrs Queued to HW + * @ppdu_noack: No of PPDU's not Acked includes both aggr and nonaggr's + * @mpdu_queued: No of MPDU/Subframes's queued to HW in Aggregates + * @ppdu_nonaggr_cnt: No of NonAggr/MPDU/Subframes's queued to HW + * in Legacy NonAggregates + * @mpdu_sw_requed: No of MPDU/Subframes's SW requeued includes + * both Aggr and NonAggr + * @mpdu_suc_retry: No of MPDU/Subframes's transmitted Successfully + * after Single/mul HW retry + * @mpdu_suc_multitry: No of MPDU/Subframes's transmitted Success + * after Multiple HW retry + * @mpdu_fail_retry: No of MPDU/Subframes's failed transmission + * after Multiple HW retry + * @reserved[13]: for future extensions set to 0x0 + */ +typedef struct { + uint32_t vdev_id; + uint32_t ppdu_aggr_cnt; + uint32_t ppdu_noack; + uint32_t mpdu_queued; + uint32_t ppdu_nonaggr_cnt; + uint32_t mpdu_sw_requed; + uint32_t mpdu_suc_retry; + uint32_t mpdu_suc_multitry; + uint32_t mpdu_fail_retry; + uint32_t reserved[13]; +} wmi_host_vdev_extd_stats; + +/** + * struct wmi_host_peer_stats - peer stats + * @peer_macaddr: peer MAC address + * @peer_rssi: rssi + * @peer_rssi_seq_num: rssi sequence number + * @peer_tx_rate: last tx data rate used for peer + * @peer_rx_rate: last rx data rate used for peer + * @currentper: Current PER + * @retries: Retries happend during transmission + * @txratecount: Maximum Aggregation Size + * @max4msframelen: Max4msframelen of tx rates used + * @totalsubframes: Total no of subframes + * @txbytes: No of bytes transmitted to the client + * @nobuffs[4]: Packet Loss due to buffer overflows + * @excretries[4]: Packet Loss due to excessive retries + * @peer_rssi_changed: how many times peer's RSSI changed by a + * non-negligible amount + */ +typedef struct { + wmi_host_mac_addr peer_macaddr; + uint32_t peer_rssi; + uint32_t peer_rssi_seq_num; + uint32_t peer_tx_rate; + uint32_t peer_rx_rate; + uint32_t currentper; + uint32_t retries; + uint32_t txratecount; + uint32_t max4msframelen; + uint32_t totalsubframes; + uint32_t txbytes; + uint32_t nobuffs[4]; + uint32_t excretries[4]; + uint32_t peer_rssi_changed; +} wmi_host_peer_stats; + +typedef struct { + uint32_t dummy; +} wmi_host_bcnflt_stats; + +/** + * struct wmi_host_chan_stats - WMI chan stats + * @chan_mhz: Primary channel freq of the channel for which stats are sent + * @sampling_period_us: Time spent on the channel + * @rx_clear_count: Aggregate duration over a sampling period for + * which channel activity was observed + * @tx_duration_us: Accumalation of the TX PPDU duration over a sampling period + * @rx_duration_us: Accumalation of the RX PPDU duration over a sampling period + */ +typedef struct { + uint32_t chan_mhz; + uint32_t sampling_period_us; + uint32_t rx_clear_count; + uint32_t tx_duration_us; + uint32_t rx_duration_us; +} wmi_host_chan_stats; + +#define WMI_EVENT_ID_INVALID 0 +/** + * Host based ENUM IDs for events to abstract target enums for event_id + */ +typedef enum { + wmi_service_ready_event_id = 0, + wmi_ready_event_id, + wmi_dbg_msg_event_id, + wmi_scan_event_id, + wmi_echo_event_id, + wmi_update_stats_event_id, + wmi_inst_rssi_stats_event_id, + wmi_vdev_start_resp_event_id, + wmi_vdev_standby_req_event_id, + wmi_vdev_resume_req_event_id, + wmi_vdev_stopped_event_id, + wmi_peer_sta_kickout_event_id, + wmi_host_swba_event_id, + wmi_tbttoffset_update_event_id, + wmi_mgmt_rx_event_id, + wmi_chan_info_event_id, + wmi_phyerr_event_id, + wmi_roam_event_id, + wmi_profile_match, + wmi_debug_print_event_id, + wmi_pdev_qvit_event_id, + wmi_wlan_profile_data_event_id, + wmi_rtt_meas_report_event_id, + wmi_tsf_meas_report_event_id, + wmi_rtt_error_report_event_id, + wmi_rtt_keepalive_event_id, + wmi_oem_cap_event_id, + wmi_oem_meas_report_event_id, + wmi_oem_report_event_id, + wmi_nan_event_id, + wmi_wow_wakeup_host_event_id, + wmi_gtk_offload_status_event_id, + wmi_gtk_rekey_fail_event_id, + wmi_dcs_interference_event_id, + wmi_pdev_tpc_config_event_id, + wmi_csa_handling_event_id, + wmi_gpio_input_event_id, + wmi_peer_ratecode_list_event_id, + wmi_generic_buffer_event_id, + wmi_mcast_buf_release_event_id, + wmi_mcast_list_ageout_event_id, + wmi_vdev_get_keepalive_event_id, + wmi_wds_peer_event_id, + wmi_peer_sta_ps_statechg_event_id, + wmi_pdev_fips_event_id, + wmi_tt_stats_event_id, + wmi_pdev_channel_hopping_event_id, + wmi_pdev_ani_cck_level_event_id, + wmi_pdev_ani_ofdm_level_event_id, + wmi_pdev_reserve_ast_entry_event_id, + wmi_pdev_nfcal_power_event_id, + wmi_pdev_tpc_event_id, + wmi_pdev_get_ast_info_event_id, + wmi_pdev_temperature_event_id, + wmi_pdev_nfcal_power_all_channels_event_id, + wmi_pdev_bss_chan_info_event_id, + wmi_mu_report_event_id, + wmi_pdev_utf_event_id, + wmi_pdev_dump_event_id, + wmi_tx_pause_event_id, + wmi_dfs_radar_event_id, + wmi_pdev_l1ss_track_event_id, + wmi_service_ready_ext_event_id, + wmi_vdev_install_key_complete_event_id, + wmi_vdev_mcc_bcn_intvl_change_req_event_id, + wmi_vdev_tsf_report_event_id, + wmi_peer_info_event_id, + wmi_peer_tx_fail_cnt_thr_event_id, + wmi_peer_estimated_linkspeed_event_id, + wmi_peer_state_event_id, + wmi_offload_bcn_tx_status_event_id, + wmi_offload_prob_resp_tx_status_event_id, + wmi_mgmt_tx_completion_event_id, + wmi_tx_delba_complete_event_id, + wmi_tx_addba_complete_event_id, + wmi_ba_rsp_ssn_event_id, + wmi_aggr_state_trig_event_id, + wmi_roam_synch_event_id, + wmi_p2p_disc_event_id, + wmi_p2p_noa_event_id, + wmi_pdev_resume_event_id, + wmi_do_wow_disable_ack_event_id, + wmi_wow_initial_wakeup_event_id, + wmi_stats_ext_event_id, + wmi_iface_link_stats_event_id, + wmi_peer_link_stats_event_id, + wmi_radio_link_stats_link, + wmi_update_fw_mem_dump_event_id, + wmi_diag_event_id_log_supported_event_id, + wmi_nlo_match_event_id, + wmi_nlo_scan_complete_event_id, + wmi_apfind_event_id, + wmi_passpoint_match_event_id, + wmi_chatter_pc_query_event_id, + wmi_pdev_ftm_intg_event_id, + wmi_wlan_freq_avoid_event_id, + wmi_thermal_mgmt_event_id, + wmi_diag_container_event_id, + wmi_host_auto_shutdown_event_id, + wmi_update_whal_mib_stats_event_id, + wmi_update_vdev_rate_stats_event_id, + wmi_diag_event_id, + wmi_ocb_set_sched_event_id, + wmi_dbg_mesg_flush_complete_event_id, + wmi_rssi_breach_event_id, + wmi_uploadh_event_id, + wmi_captureh_event_id, + wmi_rfkill_state_change_event_id, + wmi_tdls_peer_event_id, + wmi_batch_scan_enabled_event_id, + wmi_batch_scan_result_event_id, + wmi_lpi_result_event_id, + wmi_lpi_status_event_id, + wmi_lpi_handoff_event_id, + wmi_extscan_start_stop_event_id, + wmi_extscan_operation_event_id, + wmi_extscan_table_usage_event_id, + wmi_extscan_cached_results_event_id, + wmi_extscan_wlan_change_results_event_id, + wmi_extscan_hotlist_match_event_id, + wmi_extscan_capabilities_event_id, + wmi_extscan_hotlist_ssid_match_event_id, + wmi_mdns_stats_event_id, + wmi_sap_ofl_add_sta_event_id, + wmi_sap_ofl_del_sta_event_id, + wmi_ocb_set_config_resp_event_id, + wmi_ocb_get_tsf_timer_resp_event_id, + wmi_dcc_get_stats_resp_event_id, + wmi_dcc_update_ndl_resp_event_id, + wmi_dcc_stats_event_id, + wmi_soc_set_hw_mode_resp_event_id, + wmi_soc_hw_mode_transition_event_id, + wmi_soc_set_dual_mac_config_resp_event_id, + wmi_tx_data_traffic_ctrl_event_id, + + wmi_events_max, +} wmi_conv_event_id; + +#define WMI_UNAVAILABLE_PARAM 0 +/** + * Host based ENUM IDs for PDEV params to abstract target enums + */ +typedef enum { + wmi_pdev_param_tx_chain_mask = 0, + wmi_pdev_param_rx_chain_mask, + wmi_pdev_param_txpower_limit2g, + wmi_pdev_param_txpower_limit5g, + wmi_pdev_param_txpower_scale, + wmi_pdev_param_beacon_gen_mode, + wmi_pdev_param_beacon_tx_mode, + wmi_pdev_param_resmgr_offchan_mode, + wmi_pdev_param_protection_mode, + wmi_pdev_param_dynamic_bw, + wmi_pdev_param_non_agg_sw_retry_th, + wmi_pdev_param_agg_sw_retry_th, + wmi_pdev_param_sta_kickout_th, + wmi_pdev_param_ac_aggrsize_scaling, + wmi_pdev_param_ltr_enable, + wmi_pdev_param_ltr_ac_latency_be, + wmi_pdev_param_ltr_ac_latency_bk, + wmi_pdev_param_ltr_ac_latency_vi, + wmi_pdev_param_ltr_ac_latency_vo, + wmi_pdev_param_ltr_ac_latency_timeout, + wmi_pdev_param_ltr_sleep_override, + wmi_pdev_param_ltr_rx_override, + wmi_pdev_param_ltr_tx_activity_timeout, + wmi_pdev_param_l1ss_enable, + wmi_pdev_param_dsleep_enable, + wmi_pdev_param_pcielp_txbuf_flush, + wmi_pdev_param_pcielp_txbuf_watermark, + wmi_pdev_param_pcielp_txbuf_tmo_en, + wmi_pdev_param_pcielp_txbuf_tmo_value, + wmi_pdev_param_pdev_stats_update_period, + wmi_pdev_param_vdev_stats_update_period, + wmi_pdev_param_peer_stats_update_period, + wmi_pdev_param_bcnflt_stats_update_period, + wmi_pdev_param_pmf_qos, + wmi_pdev_param_arp_ac_override, + wmi_pdev_param_dcs, + wmi_pdev_param_ani_enable, + wmi_pdev_param_ani_poll_period, + wmi_pdev_param_ani_listen_period, + wmi_pdev_param_ani_ofdm_level, + wmi_pdev_param_ani_cck_level, + wmi_pdev_param_dyntxchain, + wmi_pdev_param_proxy_sta, + wmi_pdev_param_idle_ps_config, + wmi_pdev_param_power_gating_sleep, + wmi_pdev_param_aggr_burst, + wmi_pdev_param_rx_decap_mode, + wmi_pdev_param_fast_channel_reset, + wmi_pdev_param_burst_dur, + wmi_pdev_param_burst_enable, + wmi_pdev_param_smart_antenna_default_antenna, + wmi_pdev_param_igmpmld_override, + wmi_pdev_param_igmpmld_tid, + wmi_pdev_param_antenna_gain, + wmi_pdev_param_rx_filter, + wmi_pdev_set_mcast_to_ucast_tid, + wmi_pdev_param_proxy_sta_mode, + wmi_pdev_param_set_mcast2ucast_mode, + wmi_pdev_param_set_mcast2ucast_buffer, + wmi_pdev_param_remove_mcast2ucast_buffer, + wmi_pdev_peer_sta_ps_statechg_enable, + wmi_pdev_param_igmpmld_ac_override, + wmi_pdev_param_block_interbss, + wmi_pdev_param_set_disable_reset_cmdid, + wmi_pdev_param_set_msdu_ttl_cmdid, + wmi_pdev_param_set_ppdu_duration_cmdid, + wmi_pdev_param_txbf_sound_period_cmdid, + wmi_pdev_param_set_promisc_mode_cmdid, + wmi_pdev_param_set_burst_mode_cmdid, + wmi_pdev_param_en_stats, + wmi_pdev_param_mu_group_policy, + wmi_pdev_param_noise_detection, + wmi_pdev_param_noise_threshold, + wmi_pdev_param_dpd_enable, + wmi_pdev_param_set_mcast_bcast_echo, + wmi_pdev_param_atf_strict_sch, + wmi_pdev_param_atf_sched_duration, + wmi_pdev_param_ant_plzn, + wmi_pdev_param_mgmt_retry_limit, + wmi_pdev_param_sensitivity_level, + wmi_pdev_param_signed_txpower_2g, + wmi_pdev_param_signed_txpower_5g, + wmi_pdev_param_enable_per_tid_amsdu, + wmi_pdev_param_enable_per_tid_ampdu, + wmi_pdev_param_cca_threshold, + wmi_pdev_param_rts_fixed_rate, + wmi_pdev_param_cal_period, + wmi_pdev_param_pdev_reset, + wmi_pdev_param_wapi_mbssid_offset, + wmi_pdev_param_arp_srcaddr, + wmi_pdev_param_arp_dstaddr, + wmi_pdev_param_txpower_decr_db, + wmi_pdev_param_rx_batchmode, + wmi_pdev_param_packet_aggr_delay, + wmi_pdev_param_atf_obss_noise_sch, + wmi_pdev_param_atf_obss_noise_scaling_factor, + wmi_pdev_param_cust_txpower_scale, + wmi_pdev_param_atf_dynamic_enable, + wmi_pdev_param_atf_ssid_group_policy, + wmi_pdev_param_rfkill_enable, + wmi_pdev_param_hw_rfkill_config, + wmi_pdev_param_low_power_rf_enable, + wmi_pdev_param_l1ss_track, + wmi_pdev_param_hyst_en, + wmi_pdev_param_power_collapse_enable, + wmi_pdev_param_led_sys_state, + wmi_pdev_param_led_enable, + wmi_pdev_param_audio_over_wlan_latency, + wmi_pdev_param_audio_over_wlan_enable, + wmi_pdev_param_whal_mib_stats_update_enable, + wmi_pdev_param_vdev_rate_stats_update_period, + wmi_pdev_param_cts_cbw, + wmi_pdev_param_wnts_config, + wmi_pdev_param_adaptive_early_rx_enable, + wmi_pdev_param_adaptive_early_rx_min_sleep_slop, + wmi_pdev_param_adaptive_early_rx_inc_dec_step, + wmi_pdev_param_early_rx_fix_sleep_slop, + wmi_pdev_param_bmiss_based_adaptive_bto_enable, + wmi_pdev_param_bmiss_bto_min_bcn_timeout, + wmi_pdev_param_bmiss_bto_inc_dec_step, + wmi_pdev_param_bto_fix_bcn_timeout, + wmi_pdev_param_ce_based_adaptive_bto_enable, + wmi_pdev_param_ce_bto_combo_ce_value, + wmi_pdev_param_tx_chain_mask_2g, + wmi_pdev_param_rx_chain_mask_2g, + wmi_pdev_param_tx_chain_mask_5g, + wmi_pdev_param_rx_chain_mask_5g, + wmi_pdev_param_tx_chain_mask_cck, + wmi_pdev_param_tx_chain_mask_1ss, + + wmi_pdev_param_max, +} wmi_conv_pdev_params_id; + + +/** + * Host based ENUM IDs for VDEV params to abstract target enums + */ +typedef enum { + wmi_vdev_param_rts_threshold = 0, + wmi_vdev_param_fragmentation_threshold, + wmi_vdev_param_beacon_interval, + wmi_vdev_param_listen_interval, + wmi_vdev_param_multicast_rate, + wmi_vdev_param_mgmt_tx_rate, + wmi_vdev_param_slot_time, + wmi_vdev_param_preamble, + wmi_vdev_param_swba_time, + wmi_vdev_stats_update_period, + wmi_vdev_pwrsave_ageout_time, + wmi_vdev_host_swba_interval, + wmi_vdev_param_dtim_period, + wmi_vdev_oc_scheduler_air_time_limit, + wmi_vdev_param_wds, + wmi_vdev_param_atim_window, + wmi_vdev_param_bmiss_count_max, + wmi_vdev_param_bmiss_first_bcnt, + wmi_vdev_param_bmiss_final_bcnt, + wmi_vdev_param_feature_wmm, + wmi_vdev_param_chwidth, + wmi_vdev_param_chextoffset, + wmi_vdev_param_disable_htprotection, + wmi_vdev_param_sta_quickkickout, + wmi_vdev_param_mgmt_rate, + wmi_vdev_param_protection_mode, + wmi_vdev_param_fixed_rate, + wmi_vdev_param_sgi, + wmi_vdev_param_ldpc, + wmi_vdev_param_tx_stbc, + wmi_vdev_param_rx_stbc, + wmi_vdev_param_intra_bss_fwd, + wmi_vdev_param_def_keyid, + wmi_vdev_param_nss, + wmi_vdev_param_bcast_data_rate, + wmi_vdev_param_mcast_data_rate, + wmi_vdev_param_mcast_indicate, + wmi_vdev_param_dhcp_indicate, + wmi_vdev_param_unknown_dest_indicate, + wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs, + wmi_vdev_param_ap_keepalive_max_idle_inactive_time_secs, + wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs, + wmi_vdev_param_ap_enable_nawds, + wmi_vdev_param_mcast2ucast_set, + wmi_vdev_param_enable_rtscts, + wmi_vdev_param_rc_num_retries, + wmi_vdev_param_txbf, + wmi_vdev_param_packet_powersave, + wmi_vdev_param_drop_unencry, + wmi_vdev_param_tx_encap_type, + wmi_vdev_param_ap_detect_out_of_sync_sleeping_sta_time_secs, + wmi_vdev_param_cabq_maxdur, + wmi_vdev_param_mfptest_set, + wmi_vdev_param_rts_fixed_rate, + wmi_vdev_param_vht_sgimask, + wmi_vdev_param_vht80_ratemask, + wmi_vdev_param_early_rx_adjust_enable, + wmi_vdev_param_early_rx_tgt_bmiss_num, + wmi_vdev_param_early_rx_bmiss_sample_cycle, + wmi_vdev_param_early_rx_slop_step, + wmi_vdev_param_early_rx_init_slop, + wmi_vdev_param_early_rx_adjust_pause, + wmi_vdev_param_proxy_sta, + wmi_vdev_param_meru_vc, + wmi_vdev_param_rx_decap_type, + wmi_vdev_param_bw_nss_ratemask, + wmi_vdev_param_sensor_ap, + wmi_vdev_param_beacon_rate, + wmi_vdev_param_dtim_enable_cts, + wmi_vdev_param_sta_kickout, + wmi_vdev_param_tx_pwrlimit, + wmi_vdev_param_snr_num_for_cal, + wmi_vdev_param_roam_fw_offload, + wmi_vdev_param_enable_rmc, + wmi_vdev_param_ibss_max_bcn_lost_ms, + wmi_vdev_param_max_rate, + wmi_vdev_param_early_rx_drift_sample, + wmi_vdev_param_set_ibss_tx_fail_cnt_thr, + wmi_vdev_param_ebt_resync_timeout, + wmi_vdev_param_aggr_trig_event_enable, + wmi_vdev_param_is_ibss_power_save_allowed, + wmi_vdev_param_is_power_collapse_allowed, + wmi_vdev_param_is_awake_on_txrx_enabled, + wmi_vdev_param_inactivity_cnt, + wmi_vdev_param_txsp_end_inactivity_time_ms, + wmi_vdev_param_dtim_policy, + wmi_vdev_param_ibss_ps_warmup_time_secs, + wmi_vdev_param_ibss_ps_1rx_chain_in_atim_window_enable, + wmi_vdev_param_rx_leak_window, + wmi_vdev_param_stats_avg_factor, + wmi_vdev_param_disconnect_th, + wmi_vdev_param_rtscts_rate, + wmi_vdev_param_mcc_rtscts_protection_enable, + wmi_vdev_param_mcc_broadcast_probe_enable, + + wmi_vdev_param_max, +} wmi_conv_vdev_param_id; + +/** + * Host based ENUM IDs for service bits to abstract target enums + */ +typedef enum { + wmi_service_beacon_offload = 0, + wmi_service_scan_offload, + wmi_service_roam_offload, + wmi_service_bcn_miss_offload, + wmi_service_sta_pwrsave, + wmi_service_sta_advanced_pwrsave, + wmi_service_ap_uapsd, + wmi_service_ap_dfs, + wmi_service_11ac, + wmi_service_blockack, + wmi_service_phyerr, + wmi_service_bcn_filter, + wmi_service_rtt, + wmi_service_ratectrl, + wmi_service_wow, + wmi_service_ratectrl_cache, + wmi_service_iram_tids, + wmi_service_burst, + wmi_service_smart_antenna_sw_support, + wmi_service_gtk_offload, + wmi_service_scan_sch, + wmi_service_csa_offload, + wmi_service_chatter, + wmi_service_coex_freqavoid, + wmi_service_packet_power_save, + wmi_service_force_fw_hang, + wmi_service_smart_antenna_hw_support, + wmi_service_gpio, + wmi_sta_uapsd_basic_auto_trig, + wmi_sta_uapsd_var_auto_trig, + wmi_service_sta_keep_alive, + wmi_service_tx_encap, + wmi_service_ap_ps_detect_out_of_sync, + wmi_service_early_rx, + wmi_service_enhanced_proxy_sta, + wmi_service_tt, + wmi_service_atf, + wmi_service_peer_caching, + wmi_service_coex_gpio, + wmi_service_aux_spectral_intf, + wmi_service_aux_chan_load_intf, + wmi_service_bss_channel_info_64, + wmi_service_ext_res_cfg_support, + wmi_service_mesh, + wmi_service_restrt_chnl_support, + wmi_service_roam_scan_offload, + wmi_service_arpns_offload, + wmi_service_nlo, + wmi_service_sta_dtim_ps_modulated_dtim, + wmi_service_sta_smps, + wmi_service_fwtest, + wmi_service_sta_wmmac, + wmi_service_tdls, + wmi_service_mcc_bcn_interval_change, + wmi_service_adaptive_ocs, + wmi_service_ba_ssn_support, + wmi_service_filter_ipsec_natkeepalive, + wmi_service_wlan_hb, + wmi_service_lte_ant_share_support, + wmi_service_batch_scan, + wmi_service_qpower, + wmi_service_plmreq, + wmi_service_thermal_mgmt, + wmi_service_rmc, + wmi_service_mhf_offload, + wmi_service_coex_sar, + wmi_service_bcn_txrate_override, + wmi_service_nan, + wmi_service_l1ss_stat, + wmi_service_estimate_linkspeed, + wmi_service_obss_scan, + wmi_service_tdls_offchan, + wmi_service_tdls_uapsd_buffer_sta, + wmi_service_tdls_uapsd_sleep_sta, + wmi_service_ibss_pwrsave, + wmi_service_lpass, + wmi_service_extscan, + wmi_service_d0wow, + wmi_service_hsoffload, + wmi_service_roam_ho_offload, + wmi_service_rx_full_reorder, + wmi_service_dhcp_offload, + wmi_service_sta_rx_ipa_offload_support, + wmi_service_mdns_offload, + wmi_service_sap_auth_offload, + wmi_service_dual_band_simultaneous_support, + wmi_service_ocb, + wmi_service_ap_arpns_offload, + wmi_service_per_band_chainmask_support, + wmi_service_packet_filter_offload, + wmi_service_mgmt_tx_htt, + wmi_service_mgmt_tx_wmi, + wmi_service_ext_msg, + wmi_service_mawc, + + wmi_service_peer_stats, + wmi_service_mesh_11s, + wmi_service_periodic_chan_stat_support, + wmi_service_tx_mode_push_only, + wmi_service_tx_mode_push_pull, + wmi_service_tx_mode_dynamic, + + wmi_services_max, +} wmi_conv_service_ids; +#define WMI_SERVICE_UNAVAILABLE 0xFFFF + +/** + * struct target_capability_info - Target capabilities in service ready + * @phy_capability: PHY capabilities + * @max_frag_entry: Maximum frag entries + * @num_rf_chains: Number of RF chains supported + * @ht_cap_info: HT cap info + * @vht_cap_info: VHT cap info + * @vht_supp_mcs: VHT Supported MCS + * @hw_min_tx_power: HW minimum tx power + * @hw_max_tx_power: HW maximum tx power + * @sys_cap_info: sys capability info + * @min_pkt_size_enable: Enterprise mode short pkt enable + * @max_bcn_ie_size: Max beacon and probe rsp IE offload size + * @max_num_scan_channels: Max scan channels + * @max_supported_macs: max supported MCS + * @wmi_fw_sub_feat_caps: FW sub feature capabilities + * @txrx_chainmask: TXRX chain mask + * @default_dbs_hw_mode_index: DBS hw mode index + * @num_msdu_desc: number of msdu desc + */ +typedef struct { + uint32_t phy_capability; + uint32_t max_frag_entry; + uint32_t num_rf_chains; + uint32_t ht_cap_info; + uint32_t vht_cap_info; + uint32_t vht_supp_mcs; + uint32_t hw_min_tx_power; + uint32_t hw_max_tx_power; + uint32_t sys_cap_info; + uint32_t min_pkt_size_enable; + uint32_t max_bcn_ie_size; + uint32_t max_num_scan_channels; + uint32_t max_supported_macs; + uint32_t wmi_fw_sub_feat_caps; + uint32_t txrx_chainmask; + uint32_t default_dbs_hw_mode_index; + uint32_t num_msdu_desc; +} target_capability_info; + +/** + * struct wmi_host_fw_ver - FW version in non-tlv target + * @sw_version: Versin info + * @sw_version_1: Second dword of version + */ +struct wmi_host_fw_ver { + uint32_t sw_version; + uint32_t sw_version_1; +}; + +/** + * struct wmi_host_fw_abi_ver - FW version in non-tlv target + * @sw_version: Versin info + * @abi_version: ABI version + */ +struct wmi_host_fw_abi_ver { + uint32_t sw_version; + uint32_t abi_version; +}; + +/** + * struct target_resource_config - Resource config sent from host to target + * abstracted out to include union of both configs + * @num_vdevs: Number vdevs configured + * @num_peers: Number of peers + * @num_active_peers: Number of active peers for peer cache + * @num_offload_peers: Number of offload peers + * @num_offload_reorder_buffs: number of offload reorder buffs + * @num_peer_keys: number of peer keys + * @num_tids: number of tids + * @ast_skid_limit: AST skid limit + * @tx_chain_mask: TX chain mask + * @rx_chain_mask: RX chain mask + * @rx_timeout_pri: RX reorder timeout per AC + * @rx_decap_mode: RX decap mode + * @scan_max_pending_req: Scan mac pending req + * @bmiss_offload_max_vdev: Beacom miss offload max vdevs + * @roam_offload_max_vdev: Roam offload max vdevs + * @roam_offload_max_ap_profiles: roam offload max ap profiles + * @num_mcast_groups: num mcast groups + * @num_mcast_table_elems: number of macst table elems + * @mcast2ucast_mode: mcast enhance mode + * @tx_dbg_log_size: DBG log buf size + * @num_wds_entries: number of WDS entries + * @dma_burst_size: DMA burst size. + * @mac_aggr_delim: Mac aggr delim + * @rx_skip_defrag_timeout_dup_detection_check: Defrag dup check in host? + * @vow_config: vow configuration + * @gtk_offload_max_vdev: Max vdevs for GTK offload + * @num_msdu_desc: Number of msdu desc + * @max_frag_entries: Max frag entries + * End common + * @max_peer_ext_stats: Max peer EXT stats + * @smart_ant_cap: Smart antenna capabilities + * @BK_Minfree: BIN configuration for BK traffic + * @BE_Minfree: BIN configuration for BE traffic + * @VI_Minfree: BIN configuration for VI traffic + * @VO_Minfree: BIN configuration for VO traffic + * @rx_batchmode: RX batch mode + * @tt_support: Thermal throttling support + * @atf_config: ATF config + * @iphdr_pad_config: ipheader pad config + * @qwrap_config: Qwrap configuration + * @alloc_frag_desc_for_data_pkt: Frag desc for data + * Added in MCL + * @num_tdls_vdevs: + * @num_tdls_conn_table_entries: + * @beacon_tx_offload_max_vdev: + * @num_multicast_filter_entries: + * @num_wow_filters: + * @num_keep_alive_pattern: + * @keep_alive_pattern_size: + * @max_tdls_concurrent_sleep_sta: + * @max_tdls_concurrent_buffer_sta: + * @wmi_send_separate: + * @num_ocb_vdevs: + * @num_ocb_channels: + * @num_ocb_schedules: + */ +typedef struct { + uint32_t num_vdevs; + uint32_t num_peers; + uint32_t num_active_peers; + uint32_t num_offload_peers; + uint32_t num_offload_reorder_buffs; + uint32_t num_peer_keys; + uint32_t num_tids; + uint32_t ast_skid_limit; + uint32_t tx_chain_mask; + uint32_t rx_chain_mask; + uint32_t rx_timeout_pri[4]; + uint32_t rx_decap_mode; + uint32_t scan_max_pending_req; + uint32_t bmiss_offload_max_vdev; + uint32_t roam_offload_max_vdev; + uint32_t roam_offload_max_ap_profiles; + uint32_t num_mcast_groups; + uint32_t num_mcast_table_elems; + uint32_t mcast2ucast_mode; + uint32_t tx_dbg_log_size; + uint32_t num_wds_entries; + uint32_t dma_burst_size; + uint32_t mac_aggr_delim; + uint32_t rx_skip_defrag_timeout_dup_detection_check; + uint32_t vow_config; + uint32_t gtk_offload_max_vdev; + uint32_t num_msdu_desc; /* Number of msdu desc */ + uint32_t max_frag_entries; + /* End common */ + + /* Added for Beeliner */ + uint32_t max_peer_ext_stats; + uint32_t smart_ant_cap; + uint32_t BK_Minfree; + uint32_t BE_Minfree; + uint32_t VI_Minfree; + uint32_t VO_Minfree; + uint32_t rx_batchmode; + uint32_t tt_support; + uint32_t atf_config; + uint32_t iphdr_pad_config; + uint32_t + qwrap_config:16, + alloc_frag_desc_for_data_pkt:16; + + /* Added in MCL */ + uint32_t num_tdls_vdevs; + uint32_t num_tdls_conn_table_entries; + uint32_t beacon_tx_offload_max_vdev; + uint32_t num_multicast_filter_entries; + uint32_t num_wow_filters; + uint32_t num_keep_alive_pattern; + uint32_t keep_alive_pattern_size; + uint32_t max_tdls_concurrent_sleep_sta; + uint32_t max_tdls_concurrent_buffer_sta; + uint32_t wmi_send_separate; + uint32_t num_ocb_vdevs; + uint32_t num_ocb_channels; + uint32_t num_ocb_schedules; +} target_resource_config; + +/** + * struct wds_addr_event - WDS addr event structure + * @event_type: event type add/delete + * @peer_mac: peer mac + * @dest_mac: destination mac address + */ +typedef struct { + uint32_t event_type[4]; + u_int8_t peer_mac[IEEE80211_ADDR_LEN]; + u_int8_t dest_mac[IEEE80211_ADDR_LEN]; +} wds_addr_event_t; +/** + * Enum replicated for host abstraction with FW + */ +typedef enum { + /* Event respose of START CMD */ + WMI_HOST_VDEV_START_RESP_EVENT = 0, + /* Event respose of RESTART CMD */ + WMI_HOST_VDEV_RESTART_RESP_EVENT, +} WMI_HOST_START_EVENT_PARAM; + +/** + * struct wmi_host_vdev_start_resp - VDEV start response + * @vdev_id: vdev id + * @requestor_id: requestor id that requested the VDEV start request + * @resp_type: Respose of Event type START/RESTART + * @status: status of the response + * @chain_mask: Vdev chain mask + * @smps_mode: Vdev mimo power save mode + * @mac_id: mac_id field contains the MAC identifier that the + * VDEV is bound to. The valid range is 0 to (num_macs-1). + * @cfgd_tx_streams: Configured Transmit Streams + * @cfgd_rx_streams: Configured Receive Streams + */ +typedef struct { + uint32_t vdev_id; + uint32_t requestor_id; + WMI_HOST_START_EVENT_PARAM resp_type; + uint32_t status; + uint32_t chain_mask; + uint32_t smps_mode; + uint32_t mac_id; + uint32_t cfgd_tx_streams; + uint32_t cfgd_rx_streams; +} wmi_host_vdev_start_resp; + +#define WMI_HOST_ATH_MAX_ANTENNA 4 +/** + * struct wmi_host_mgmt_rx_hdr - host mgmt header params + * @channel: channel on which this frame is received + * @snr: snr information used to cal rssi + * @rssi_ctl[WMI_HOST_ATH_MAX_ANTENNA]: RSSI of PRI 20MHz for each chain. + * @rate: Rate kbps + * @phy_mode: rx phy mode WLAN_PHY_MODE + * @buf_len: length of the frame + * @status: rx status + * @flags: information about the management frame e.g. can give a + * scan source for a scan result mgmt frame + * @rssi: combined RSSI, i.e. the sum of the snr + noise floor (dBm units) + * @tsf_delta: + */ +typedef struct { + uint32_t channel; + uint32_t snr; + uint8_t rssi_ctl[WMI_HOST_ATH_MAX_ANTENNA]; + uint32_t rate; + uint32_t phy_mode; + uint32_t buf_len; + uint32_t status; + uint32_t flags; + int32_t rssi; + uint32_t tsf_delta; +} wmi_host_mgmt_rx_hdr; + +/** + * struct wmi_host_roam_event - host roam event param + * @vdev_id: vdev id + * @reason: roam reason + * @rssi: RSSI + */ +typedef struct { + uint32_t vdev_id; + uint32_t reason; + uint32_t rssi; +} wmi_host_roam_event; + +/** + * ENUM wmi_host_scan_event_type - Scan event type + */ +enum wmi_host_scan_event_type { + WMI_HOST_SCAN_EVENT_STARTED = 0x1, + WMI_HOST_SCAN_EVENT_COMPLETED = 0x2, + WMI_HOST_SCAN_EVENT_BSS_CHANNEL = 0x4, + WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL = 0x8, + WMI_HOST_SCAN_EVENT_DEQUEUED = 0x10, + WMI_HOST_SCAN_EVENT_PREEMPTED = 0x20, + WMI_HOST_SCAN_EVENT_START_FAILED = 0x40, + WMI_HOST_SCAN_EVENT_RESTARTED = 0x80, + WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT = 0x100, + WMI_HOST_SCAN_EVENT_INVALID = 0x200, + WMI_HOST_SCAN_EVENT_MAX = 0x8000 +}; + +/** + * ENUM wmi_host_scan_completion_reason - Scan completion event type + */ +enum wmi_host_scan_completion_reason { + /** scan related events */ + WMI_HOST_SCAN_REASON_NONE = 0xFF, + WMI_HOST_SCAN_REASON_COMPLETED = 0, + WMI_HOST_SCAN_REASON_CANCELLED = 1, + WMI_HOST_SCAN_REASON_PREEMPTED = 2, + WMI_HOST_SCAN_REASON_TIMEDOUT = 3, + WMI_HOST_SCAN_REASON_INTERNAL_FAILURE = 4, + WMI_HOST_SCAN_REASON_MAX, +}; + +/** + * struct wmi_host_scan_event - Scan event response from target + * @event: event type + * @reason: Reason for event + * @channel_freq: channel frequency + * @requestor: requestor id + * @scan_id: scan id + * @vdev_id: vdev id + */ +typedef struct { + uint32_t event; + uint32_t reason; + uint32_t channel_freq; + uint32_t requestor; + uint32_t scan_id; + uint32_t vdev_id; +} wmi_host_scan_event; + +/** + * struct wmi_host_pdev_reserve_ast_entry_event - Reserve AST entry + * @result: result + */ +typedef struct { + uint32_t result; +} wmi_host_pdev_reserve_ast_entry_event; + +/** + * struct wmi_host_mcast_ageout_entry - mcast aged-out entry + * @grp_addr: IPv4/6 mcast group addr + * @vdev_id: vdev id + */ +typedef struct { + uint8_t grp_addr[16]; + uint32_t vdev_id; +} wmi_host_mcast_ageout_entry; + +/** + * struct wmi_host_mcast_list_ageout_event - List of mcast entry aged-out + * @num_entry: Number of mcast entries timed-out + * @entry: List of wmi_host_mcast_ageout_entry + */ +typedef struct { + uint32_t num_entry; + wmi_host_mcast_ageout_entry entry[1]; +} wmi_host_mcast_list_ageout_event; + +/** + * struct wmi_host_pdev_nfcal_power_all_channels_event - NF cal event data + * @nfdBr: + * chan0: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan1: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan2: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan3: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * @nfdBr: + * chan0: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan1: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan2: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * chan3: {NFCalPower_chain0, NFCalPower_chain1, + * NFCalPower_chain2, NFCalPower_chain3}, + * @freqNum: frequency number + */ +typedef struct { + int8_t nfdBr[WMI_HOST_RXG_CAL_CHAN_MAX * WMI_HOST_MAX_NUM_CHAINS]; + int8_t nfdBm[WMI_HOST_RXG_CAL_CHAN_MAX * WMI_HOST_MAX_NUM_CHAINS]; + uint32_t freqNum[WMI_HOST_RXG_CAL_CHAN_MAX]; +} wmi_host_pdev_nfcal_power_all_channels_event; + +/** + * struct wmi_host_pdev_tpc_event - WMI host pdev TPC event + * @tpc: + */ +typedef struct { + uint32_t tpc[1]; +} wmi_host_pdev_tpc_event; + +/** + * struct wmi_host_pdev_generic_buffer_event + * @buf_type: Buffer type + * @frag_id: Frag id + * @more_frag: more frags pending + * @buf_len: buffer length + * @buf_info: variable length buffer + */ +typedef struct { + uint32_t buf_type; + uint32_t frag_id; + uint32_t more_frag; + uint32_t buf_len; + uint32_t buf_info[1]; +} wmi_host_pdev_generic_buffer_event; +/** + * Enum for host buffer event + */ +enum { + WMI_HOST_BUFFER_TYPE_RATEPWR_TABLE, + WMI_HOST_BUFFER_TYPE_CTL_TABLE, +}; + +/** + * struct wmi_host_pdev_tpc_config_event - host pdev tpc config event + * @regDomain: + * @chanFreq: + * @phyMode: + * @twiceAntennaReduction: + * @twiceMaxRDPower: + * @twiceAntennaGain: + * @powerLimit: + * @rateMax: + * @numTxChain: + * @ctl: + * @flags: + * @maxRegAllowedPower: + * @maxRegAllowedPowerAGCDD: + * @maxRegAllowedPowerAGSTBC: + * @maxRegAllowedPowerAGTXBF: + * @ratesArray: + */ +typedef struct { + uint32_t regDomain; + uint32_t chanFreq; + uint32_t phyMode; + uint32_t twiceAntennaReduction; + uint32_t twiceMaxRDPower; + int32_t twiceAntennaGain; + uint32_t powerLimit; + uint32_t rateMax; + uint32_t numTxChain; + uint32_t ctl; + uint32_t flags; + int8_t maxRegAllowedPower[WMI_HOST_TPC_TX_NUM_CHAIN]; + int8_t maxRegAllowedPowerAGCDD[WMI_HOST_TPC_TX_NUM_CHAIN][WMI_HOST_TPC_TX_NUM_CHAIN]; + int8_t maxRegAllowedPowerAGSTBC[WMI_HOST_TPC_TX_NUM_CHAIN][WMI_HOST_TPC_TX_NUM_CHAIN]; + int8_t maxRegAllowedPowerAGTXBF[WMI_HOST_TPC_TX_NUM_CHAIN][WMI_HOST_TPC_TX_NUM_CHAIN]; + uint8_t ratesArray[WMI_HOST_TPC_RATE_MAX]; +} wmi_host_pdev_tpc_config_event; +/** + * Enums for TPC event + */ +typedef enum { + WMI_HOST_TPC_CONFIG_EVENT_FLAG_TABLE_CDD = 0x1, + WMI_HOST_TPC_CONFIG_EVENT_FLAG_TABLE_STBC = 0x2, + WMI_HOST_TPC_CONFIG_EVENT_FLAG_TABLE_TXBF = 0x4, +} WMI_HOST_TPC_CONFIG_EVENT_FLAG; + +/** + * Medium Utilization evaluation algorithms + * These algorithms can be complementary rather than exclusive. + */ +typedef enum { + WMI_HOST_MU_BASIC_ALGO = 0x1, + WMI_HOST_MU_PER_BSSID_ALGO = 0x2, + WMI_HOST_MU_HIDDEN_NODE_ALGO = 0x4, +} WMI_HOST_MU_ALGO_TYPE; +/* max MU alg combinations supported by target */ +#define WMI_HOST_MU_MAX_ALGO_TYPE 3 + +/** + * struct wmi_host_mu_report_event - WMI_MU_REPORT_EVENTID + * @mu_request_id: request id + * @status_reason: MU_STATUS_REASON + * @total_mu: MU_ALG_TYPE combinations + * @num_active_bssid: number of active bssid + */ +typedef struct { + uint32_t mu_request_id; + uint32_t status_reason; + uint32_t total_mu[WMI_HOST_MU_MAX_ALGO_TYPE]; + uint32_t num_active_bssid; +} wmi_host_mu_report_event; + +/** + * struct wmi_host_mgmt_tx_compl_event - TX completion event + * @desc_id: from tx_send_cmd + * @status: WMI_MGMT_TX_COMP_STATUS_TYPE + */ +typedef struct { + uint32_t desc_id; + uint32_t status; +} wmi_host_mgmt_tx_compl_event; + +#define WMI_HOST_TIM_BITMAP_ARRAY_SIZE 17 + +/** + * struct wmi_host_tim_info - TIM info in SWBA event + * @tim_len: TIM length + * @tim_mcast: + * @tim_bitmap: TIM bitmap + * @tim_changed: TIM changed + * @tim_num_ps_pending: TIM num PS sta pending + */ +typedef struct { + uint32_t tim_len; + uint32_t tim_mcast; + uint32_t tim_bitmap[WMI_HOST_TIM_BITMAP_ARRAY_SIZE]; + uint32_t tim_changed; + uint32_t tim_num_ps_pending; +} wmi_host_tim_info; + +/** + * struct wmi_host_p2p_noa_descriptor - NoA desc in SWBA event + * @type_count: Absence count + * @duration: NoA duration + * @interval: NoA interval + * @start_time: start time + */ +typedef struct { + uint32_t type_count; + uint32_t duration; + uint32_t interval; + uint32_t start_time; +} wmi_host_p2p_noa_descriptor; +/* Maximum number of NOA Descriptors supported */ +#define WMI_HOST_P2P_MAX_NOA_DESCRIPTORS 4 +/** + * struct wmi_host_p2p_noa_info - p2p noa information + * @modified: NoA modified + * @index: Index + * @oppPS: Oppurtunstic ps + * @ctwindow: CT window + * @num_descriptors: number of descriptors + * @noa_descriptors: noa descriptors + */ +typedef struct { + uint8_t modified; + uint8_t index; + uint8_t oppPS; + uint8_t ctwindow; + uint8_t num_descriptors; + wmi_host_p2p_noa_descriptor + noa_descriptors[WMI_HOST_P2P_MAX_NOA_DESCRIPTORS]; +} wmi_host_p2p_noa_info; + +/** + * struct wmi_host_peer_sta_kickout_event + * @peer_macaddr: peer mac address + * @reason: kickout reason + * @rssi: rssi + */ +typedef struct { + uint8_t peer_macaddr[IEEE80211_ADDR_LEN]; + uint32_t reason; + uint32_t rssi; +} wmi_host_peer_sta_kickout_event; + +/** + * struct wmi_host_peer_sta_ps_statechange_event - ST ps state change event + * @peer_macaddr: peer mac address + * @peer_ps_stats: peer PS state + */ +typedef struct { + uint8_t peer_macaddr[IEEE80211_ADDR_LEN]; + uint32_t peer_ps_state; +} wmi_host_peer_sta_ps_statechange_event; + +/* Maximum CCK, OFDM rates supported */ +#define WMI_SA_MAX_CCK_OFDM_RATES 12 +/* Maximum MCS rates supported; 4 rates in each dword */ +#define WMI_SA_MAX_MCS_RATES 40 +#define WMI_SA_MAX_RATE_COUNTERS 4 +/* Maximum rate series used for transmission */ +#define SA_MAX_RATE_SERIES 2 + +#define SA_MAX_LEGACY_RATE_DWORDS 3 +#define SA_MAX_HT_RATE_DWORDS 10 +#define SA_BYTES_IN_DWORD 4 +#define SA_MASK_BYTE 0xff +/* TODO: ratecode_160 needs to add for future chips */ +/** + * struct wmi_sa_rate_cap - smart antenna rat capabilities + * @ratecode_legacy: Rate code array for CCK OFDM + * @ratecode_20: Rate code array for 20MHz BW + * @ratecode_40: Rate code array for 40MHz BW + * @ratecode_80: Rate code array for 80MHz BW + * @ratecount: Max Rate count for each mode + */ +typedef struct { + uint8_t ratecode_legacy[WMI_SA_MAX_CCK_OFDM_RATES]; + uint8_t ratecode_20[WMI_SA_MAX_MCS_RATES]; + uint8_t ratecode_40[WMI_SA_MAX_MCS_RATES]; + uint8_t ratecode_80[WMI_SA_MAX_MCS_RATES]; + uint8_t ratecount[WMI_SA_MAX_RATE_COUNTERS]; +} wmi_sa_rate_cap; + +/** Preamble types to be used with VDEV fixed rate configuration */ +typedef enum { + WMI_HOST_RATE_PREAMBLE_OFDM, + WMI_HOST_RATE_PREAMBLE_CCK, + WMI_HOST_RATE_PREAMBLE_HT, + WMI_HOST_RATE_PREAMBLE_VHT, +} WMI_HOST_RATE_PREAMBLE; + +#define WMI_HOST_FIXED_RATE_NONE (0xff) + +/** slot time long */ +#define WMI_HOST_VDEV_SLOT_TIME_LONG 0x1 +/** slot time short */ +#define WMI_HOST_VDEV_SLOT_TIME_SHORT 0x2 +/** preablbe long */ +#define WMI_HOST_VDEV_PREAMBLE_LONG 0x1 +/** preablbe short */ +#define WMI_HOST_VDEV_PREAMBLE_SHORT 0x2 +/** found a better AP */ +#define WMI_HOST_ROAM_REASON_BETTER_AP 0x1 +/** beacon miss detected */ +#define WMI_HOST_ROAM_REASON_BMISS 0x2 +/** deauth/disassoc received */ +#define WMI_HOST_ROAM_REASON_DEAUTH 0x2 +/** connected AP's low rssi condition detected */ +#define WMI_HOST_ROAM_REASON_LOW_RSSI 0x3 +/** found another AP that matches SSID and Security profile in + * WMI_ROAM_AP_PROFILE, found during scan triggered upon FINAL_BMISS + */ +#define WMI_HOST_ROAM_REASON_SUITABLE_AP 0x4 +/** LFR3.0 roaming failed, indicate the disconnection to host */ +#define WMI_HOST_ROAM_REASON_HO_FAILED 0x5 + +/** values for vdev_type */ +#define WMI_HOST_VDEV_TYPE_AP 0x1 +#define WMI_HOST_VDEV_TYPE_STA 0x2 +#define WMI_HOST_VDEV_TYPE_IBSS 0x3 +#define WMI_HOST_VDEV_TYPE_MONITOR 0x4 + +/** values for vdev_subtype */ +#define WMI_HOST_VDEV_SUBTYPE_P2P_DEVICE 0x1 +#define WMI_HOST_VDEV_SUBTYPE_P2P_CLIENT 0x2 +#define WMI_HOST_VDEV_SUBTYPE_P2P_GO 0x3 +#define WMI_HOST_VDEV_SUBTYPE_PROXY_STA 0x4 +#define WMI_HOST_VDEV_SUBTYPE_MESH 0x5 + +#define WMI_HOST_MGMT_TID 17 +/* Disable aging & learning */ +#define WMI_HOST_WDS_FLAG_STATIC 0x1 + +/** + * Peer param enum abstracted from target + */ +typedef enum { + /** mimo powersave state */ + WMI_HOST_PEER_MIMO_PS_STATE = 0x1, + /** enable/disable AMPDU . initial value (enabled) */ + WMI_HOST_PEER_AMPDU = 0x2, + /** authorize/unauthorize peer. initial value is unauthorized (0) */ + WMI_HOST_PEER_AUTHORIZE = 0x3, + /** peer channel bandwidth */ + WMI_HOST_PEER_CHWIDTH = 0x4, + /** peer NSS */ + WMI_HOST_PEER_NSS = 0x5, + /** USE 4 ADDR */ + WMI_HOST_PEER_USE_4ADDR = 0x6, + /** Enable extended peer stats */ + WMI_HOST_PEER_EXT_STATS_ENABLE = 0x7, + /*Use FIXED Pwr */ + WMI_HOST_PEER_USE_FIXED_PWR = 0x8, + /* Set peer fixed rate */ + WMI_HOST_PEER_PARAM_FIXED_RATE = 0x9, + /* Whitelist peer TIDs */ + WMI_HOST_PEER_SET_MU_WHITELIST = 0xa, + /* set group membership status */ + WMI_HOST_PEER_MEMBERSHIP = 0xb, + WMI_HOST_PEER_USERPOS = 0xc, +} PEER_PARAM_ENUM; +#define WMI_HOST_PEER_MIMO_PS_NONE 0x0 +#define WMI_HOST_PEER_MIMO_PS_STATIC 0x1 +#define WMI_HOST_PEER_MIMO_PS_DYNAMIC 0x2 +typedef enum { + HOST_PLATFORM_HIGH_PERF, + HOST_PLATFORM_LOW_PERF, +} HOST_PLATFORM_TYPE; + +enum wmi_host_sta_ps_mode { + /** enable power save for the given STA VDEV */ + WMI_HOST_STA_PS_MODE_DISABLED = 0, + /** disable power save for a given STA VDEV */ + WMI_HOST_STA_PS_MODE_ENABLED = 1, +}; +enum wmi_host_sta_powersave_param { + /** + * Controls how frames are retrievd from AP while STA is sleeping + * + * (see enum wmi_sta_ps_param_rx_wake_policy) + */ + WMI_HOST_STA_PS_PARAM_RX_WAKE_POLICY = 0, + + /** + * The STA will go active after this many TX + * + * (see enum wmi_sta_ps_param_tx_wake_threshold) + */ + WMI_HOST_STA_PS_PARAM_TX_WAKE_THRESHOLD = 1, + + /** + * Number of PS-Poll to send before STA wakes up + * + * (see enum wmi_sta_ps_param_pspoll_count) + * + */ + WMI_HOST_STA_PS_PARAM_PSPOLL_COUNT = 2, + + /** + * TX/RX inactivity time in msec before going to sleep. + * + * The power save SM will monitor tx/rx activity on the VDEV, if no + * activity for the specified msec of the parameter + * the Power save SM will go to sleep. + */ + WMI_HOST_STA_PS_PARAM_INACTIVITY_TIME = 3, + + /** + * Set uapsd configuration. + * + * (see enum wmi_sta_ps_param_uapsd) + */ + WMI_HOST_STA_PS_PARAM_UAPSD = 4, +}; +/* prefix used by scan requestor ids on the host + * replicated here form wmi_unified.h*/ +#define WMI_HOST_P_SCAN_REQUESTOR_ID_PREFIX 0xA000 +/* prefix used by scan request ids generated on the host */ +/* host cycles through the lower 12 bits to generate ids */ +#define WMI_HOST_P_SCAN_REQ_ID_PREFIX 0xA000 + +#define WMI_HOST_RC_DS_FLAG 0x01 /* Dual stream flag */ +#define WMI_HOST_RC_CW40_FLAG 0x02 /* CW 40 */ +#define WMI_HOST_RC_SGI_FLAG 0x04 /* Short Guard Interval */ +#define WMI_HOST_RC_HT_FLAG 0x08 /* HT */ +#define WMI_HOST_RC_RTSCTS_FLAG 0x10 /* RTS-CTS */ +#define WMI_HOST_RC_TX_STBC_FLAG 0x20 /* TX STBC */ +#define WMI_HOST_RC_RX_STBC_FLAG 0xC0 /* RX STBC ,2 bits */ +#define WMI_HOST_RC_RX_STBC_FLAG_S 6 /* RX STBC ,2 bits */ +#define WMI_HOST_RC_WEP_TKIP_FLAG 0x100 /* WEP/TKIP encryption */ +#define WMI_HOST_RC_TS_FLAG 0x200 /* Three stream flag */ +#define WMI_HOST_RC_UAPSD_FLAG 0x400 /* UAPSD Rate Control */ + +/** HT Capabilities*/ +#define WMI_HOST_HT_CAP_ENABLED 0x0001 /* HT Enabled/ disabled */ +/* Short Guard Interval with HT20 */ +#define WMI_HOST_HT_CAP_HT20_SGI 0x0002 +#define WMI_HOST_HT_CAP_DYNAMIC_SMPS 0x0004 /* Dynamic MIMO powersave */ +#define WMI_HOST_HT_CAP_TX_STBC 0x0008 /* B3 TX STBC */ +#define WMI_HOST_HT_CAP_TX_STBC_MASK_SHIFT 3 +#define WMI_HOST_HT_CAP_RX_STBC 0x0030 /* B4-B5 RX STBC */ +#define WMI_HOST_HT_CAP_RX_STBC_MASK_SHIFT 4 +#define WMI_HOST_HT_CAP_LDPC 0x0040 /* LDPC supported */ +#define WMI_HOST_HT_CAP_L_SIG_TXOP_PROT 0x0080 /* L-SIG TXOP Protection */ +#define WMI_HOST_HT_CAP_MPDU_DENSITY 0x0700 /* MPDU Density */ +#define WMI_HOST_HT_CAP_MPDU_DENSITY_MASK_SHIFT 8 +#define WMI_HOST_HT_CAP_HT40_SGI 0x0800 +#define WMI_HOST_HT_CAP_IBF_BFER 0x1000 + +/* These macros should be used when we wish to advertise STBC support for + * only 1SS or 2SS or 3SS. */ +#define WMI_HOST_HT_CAP_RX_STBC_1SS 0x0010 /* B4-B5 RX STBC */ +#define WMI_HOST_HT_CAP_RX_STBC_2SS 0x0020 /* B4-B5 RX STBC */ +#define WMI_HOST_HT_CAP_RX_STBC_3SS 0x0030 /* B4-B5 RX STBC */ + + +#define WMI_HOST_HT_CAP_DEFAULT_ALL (WMI_HOST_HT_CAP_ENABLED | \ + WMI_HOST_HT_CAP_HT20_SGI | \ + WMI_HOST_HT_CAP_HT40_SGI | \ + WMI_HOST_HT_CAP_TX_STBC | \ + WMI_HOST_HT_CAP_RX_STBC | \ + WMI_HOST_HT_CAP_LDPC) + +/* WMI_HOST_VHT_CAP_* these maps to ieee 802.11ac vht capability information + field. The fields not defined here are not supported, or reserved. + Do not change these masks and if you have to add new one follow the + bitmask as specified by 802.11ac draft. +*/ + +#define WMI_HOST_VHT_CAP_MAX_MPDU_LEN_MASK 0x00000003 +#define WMI_HOST_VHT_CAP_RX_LDPC 0x00000010 +#define WMI_HOST_VHT_CAP_SGI_80MHZ 0x00000020 +#define WMI_HOST_VHT_CAP_SGI_160MHZ 0x00000040 +#define WMI_HOST_VHT_CAP_TX_STBC 0x00000080 +#define WMI_HOST_VHT_CAP_RX_STBC_MASK 0x00000300 +#define WMI_HOST_VHT_CAP_RX_STBC_MASK_SHIFT 8 +#define WMI_HOST_VHT_CAP_SU_BFER 0x00000800 +#define WMI_HOST_VHT_CAP_SU_BFEE 0x00001000 +#define WMI_HOST_VHT_CAP_MAX_CS_ANT_MASK 0x0000E000 +#define WMI_HOST_VHT_CAP_MAX_CS_ANT_MASK_SHIFT 13 +#define WMI_HOST_VHT_CAP_MAX_SND_DIM_MASK 0x00070000 +#define WMI_HOST_VHT_CAP_MAX_SND_DIM_MASK_SHIFT 16 +#define WMI_HOST_VHT_CAP_MU_BFER 0x00080000 +#define WMI_HOST_VHT_CAP_MU_BFEE 0x00100000 +#define WMI_HOST_VHT_CAP_MAX_AMPDU_LEN_EXP 0x03800000 +#define WMI_HOST_VHT_CAP_MAX_AMPDU_LEN_EXP_SHIT 23 +#define WMI_HOST_VHT_CAP_RX_FIXED_ANT 0x10000000 +#define WMI_HOST_VHT_CAP_TX_FIXED_ANT 0x20000000 + +#define WMI_HOST_VHT_CAP_MAX_MPDU_LEN_11454 0x00000002 + +/* These macros should be used when we wish to advertise STBC support for + * only 1SS or 2SS or 3SS. */ +#define WMI_HOST_VHT_CAP_RX_STBC_1SS 0x00000100 +#define WMI_HOST_VHT_CAP_RX_STBC_2SS 0x00000200 +#define WMI_HOST_VHT_CAP_RX_STBC_3SS 0x00000300 + +#define WMI_HOST_VHT_CAP_DEFAULT_ALL (WMI_HOST_VHT_CAP_MAX_MPDU_LEN_11454 | \ + WMI_HOST_VHT_CAP_SGI_80MHZ | \ + WMI_HOST_VHT_CAP_TX_STBC | \ + WMI_HOST_VHT_CAP_RX_STBC_MASK | \ + WMI_HOST_VHT_CAP_RX_LDPC | \ + WMI_HOST_VHT_CAP_MAX_AMPDU_LEN_EXP | \ + WMI_HOST_VHT_CAP_RX_FIXED_ANT | \ + WMI_HOST_VHT_CAP_TX_FIXED_ANT) + +/* Interested readers refer to Rx/Tx MCS Map definition as defined in + 802.11ac +*/ +#define WMI_HOST_VHT_MAX_MCS_4_SS_MASK(r, ss) ((3 & (r)) << (((ss) - 1) << 1)) +#define WMI_HOST_VHT_MAX_SUPP_RATE_MASK 0x1fff0000 +#define WMI_HOST_VHT_MAX_SUPP_RATE_MASK_SHIFT 16 + +/** U-APSD configuration of peer station from (re)assoc request and TSPECs */ +enum wmi_host_ap_ps_param_uapsd { + WMI_HOST_AP_PS_UAPSD_AC0_DELIVERY_EN = (1 << 0), + WMI_HOST_AP_PS_UAPSD_AC0_TRIGGER_EN = (1 << 1), + WMI_HOST_AP_PS_UAPSD_AC1_DELIVERY_EN = (1 << 2), + WMI_HOST_AP_PS_UAPSD_AC1_TRIGGER_EN = (1 << 3), + WMI_HOST_AP_PS_UAPSD_AC2_DELIVERY_EN = (1 << 4), + WMI_HOST_AP_PS_UAPSD_AC2_TRIGGER_EN = (1 << 5), + WMI_HOST_AP_PS_UAPSD_AC3_DELIVERY_EN = (1 << 6), + WMI_HOST_AP_PS_UAPSD_AC3_TRIGGER_EN = (1 << 7), +}; +/** U-APSD maximum service period of peer station */ +enum wmi_host_ap_ps_peer_param_max_sp { + WMI_HOST_AP_PS_PEER_PARAM_MAX_SP_UNLIMITED = 0, + WMI_HOST_AP_PS_PEER_PARAM_MAX_SP_2 = 1, + WMI_HOST_AP_PS_PEER_PARAM_MAX_SP_4 = 2, + WMI_HOST_AP_PS_PEER_PARAM_MAX_SP_6 = 3, + + /* keep last! */ + MAX_HOST_WMI_AP_PS_PEER_PARAM_MAX_SP, +}; + +#define WMI_HOST_UAPSD_AC_TYPE_DELI 0 +#define WMI_HOST_UAPSD_AC_TYPE_TRIG 1 + +#define WMI_HOST_UAPSD_AC_BIT_MASK(ac, type) \ + ((type == WMI_HOST_UAPSD_AC_TYPE_DELI) ? (1<<(ac<<1)) :\ + (1<<((ac<<1)+1))) + +enum wmi_host_ap_ps_peer_param_wnm_sleep { + WMI_HOST_AP_PS_PEER_PARAM_WNM_SLEEP_ENABLE, + WMI_HOST_AP_PS_PEER_PARAM_WNM_SLEEP_DISABLE, +}; + +enum wmi_host_ap_ps_peer_param { + /** Set uapsd configuration for a given peer. + * + * This will include the delivery and trigger enabled state for every AC. + * The host MLME needs to set this based on AP capability and stations + * request Set in the association request received from the station. + * + * Lower 8 bits of the value specify the UAPSD configuration. + * + * (see enum wmi_ap_ps_param_uapsd) + * The default value is 0. + */ + WMI_HOST_AP_PS_PEER_PARAM_UAPSD = 0, + + /** + * Set the service period for a UAPSD capable station + * + * The service period from wme ie in the (re)assoc request frame. + * + * (see enum wmi_ap_ps_peer_param_max_sp) + */ + WMI_HOST_AP_PS_PEER_PARAM_MAX_SP = 1, + + /** Time in seconds for aging out buffered frames + * for STA in power save */ + WMI_HOST_AP_PS_PEER_PARAM_AGEOUT_TIME = 2, + + /** Specify frame types that are considered SIFS + * RESP trigger frame */ + WMI_HOST_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE = 3, + + /** Specifies the trigger state of TID. + * Valid only for UAPSD frame type */ + WMI_HOST_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD = 4, + + /** Specifies the WNM sleep state of a STA */ + WMI_HOST_AP_PS_PEER_PARAM_WNM_SLEEP = 5, +}; +#define WMI_HOST_RXERR_CRC 0x01 /* CRC error on frame */ +#define WMI_HOST_RXERR_DECRYPT 0x08 /* non-Michael decrypt error */ +#define WMI_HOST_RXERR_MIC 0x10 /* Michael MIC decrypt error */ +#define WMI_HOST_RXERR_KEY_CACHE_MISS 0x20 /* No/incorrect key matter in h/w */ + +enum wmi_host_sta_ps_param_uapsd { + WMI_HOST_STA_PS_UAPSD_AC0_DELIVERY_EN = (1 << 0), + WMI_HOST_STA_PS_UAPSD_AC0_TRIGGER_EN = (1 << 1), + WMI_HOST_STA_PS_UAPSD_AC1_DELIVERY_EN = (1 << 2), + WMI_HOST_STA_PS_UAPSD_AC1_TRIGGER_EN = (1 << 3), + WMI_HOST_STA_PS_UAPSD_AC2_DELIVERY_EN = (1 << 4), + WMI_HOST_STA_PS_UAPSD_AC2_TRIGGER_EN = (1 << 5), + WMI_HOST_STA_PS_UAPSD_AC3_DELIVERY_EN = (1 << 6), + WMI_HOST_STA_PS_UAPSD_AC3_TRIGGER_EN = (1 << 7), +}; + +enum wmi_host_sta_ps_param_rx_wake_policy { + /* Wake up when ever there is an RX activity on the VDEV. In this mode + * the Power save SM(state machine) will come out of sleep by either + * sending null frame (or) a data frame (with PS==0) in response to TIM + * bit set in the received beacon frame from AP. + */ + WMI_HOST_STA_PS_RX_WAKE_POLICY_WAKE = 0, + + /* Here the power save state machine will not wakeup in response to TIM + * bit, instead it will send a PSPOLL (or) UASPD trigger based on UAPSD + * configuration setup by WMISET_PS_SET_UAPSD WMI command. When all + * access categories are delivery-enabled, the station will send a UAPSD + * trigger frame, otherwise it will send a PS-Poll. + */ + WMI_HOST_STA_PS_RX_WAKE_POLICY_POLL_UAPSD = 1, +}; +enum wmi_host_sta_ps_param_pspoll_count { + WMI_HOST_STA_PS_PSPOLL_COUNT_NO_MAX = 0, + /* Values greater than 0 indicate the maximum numer of PS-Poll frames FW + * will send before waking up. + */ +}; +/** Number of tx frames/beacon that cause the power save SM to wake up. + * + * Value 1 causes the SM to wake up for every TX. Value 0 has a special + * meaning, It will cause the SM to never wake up. This is useful if you want + * to keep the system to sleep all the time for some kind of test mode . host + * can change this parameter any time. It will affect at the next tx frame. + */ +enum wmi_host_sta_ps_param_tx_wake_threshold { + WMI_HOST_STA_PS_TX_WAKE_THRESHOLD_NEVER = 0, + WMI_HOST_STA_PS_TX_WAKE_THRESHOLD_ALWAYS = 1, + + /* Values greater than one indicate that many TX attempts per beacon + * interval before the STA will wake up + */ +}; +/* + * Transmit power scale factor. + * + */ +typedef enum { + WMI_HOST_TP_SCALE_MAX = 0, /* no scaling (default) */ + WMI_HOST_TP_SCALE_50 = 1, /* 50% of max (-3 dBm) */ + WMI_HOST_TP_SCALE_25 = 2, /* 25% of max (-6 dBm) */ + WMI_HOST_TP_SCALE_12 = 3, /* 12% of max (-9 dBm) */ + WMI_HOST_TP_SCALE_MIN = 4, /* min, but still on */ + WMI_HOST_TP_SCALE_SIZE = 5, /* max num of enum */ +} WMI_HOST_TP_SCALE; +enum { + WMI_HOST_RATEPWR_TABLE_OPS_SET, + WMI_HOST_RATEPWR_TABLE_OPS_GET, +}; +/* reserved up through 0xF */ +/** + * struct wmi_host_dcs_mib_stats - WLAN IM stats from target to host + * Below statistics are sent from target to host periodically. + * These are collected at target as long as target is running + * and target chip is not in sleep. + * @listen_time: + * @reg_tx_frame_cnt: + * @reg_rx_frame_cnt: + * @reg_rxclr_cnt: + * @reg_cycle_cnt: delta cycle count + * @reg_rxclr_ext_cnt: + * @reg_ofdm_phyerr_cnt: + * @reg_cck_phyerr_cnt: CCK err count since last reset, read from register + */ +typedef struct _hp_dcs_mib_stats { + int32_t listen_time; + uint32_t reg_tx_frame_cnt; + uint32_t reg_rx_frame_cnt; + uint32_t reg_rxclr_cnt; + uint32_t reg_cycle_cnt; + uint32_t reg_rxclr_ext_cnt; + uint32_t reg_ofdm_phyerr_cnt; + uint32_t reg_cck_phyerr_cnt; +} wmi_host_dcs_mib_stats_t; + +/** + * struct wmi_host_dcs_im_tgt_stats - DCS IM target stats + * @reg_tsf32: current running TSF from the TSF-1 + * @last_ack_rssi: Known last frame rssi, in case of multiple stations, if + * and at different ranges, this would not gaurantee that + * this is the least rssi. + * @tx_waste_time: Sum of all the failed durations in the last + * one second interval. + * @rx_time: count how many times the hal_rxerr_phy is marked, in this + * time period + * @phyerr_cnt: + * @mib_stats: wmi_host_dcs_mib_stats_t - collected mib stats as explained + * in mib structure + */ +typedef struct _wmi_host_dcs_im_tgt_stats { + uint32_t reg_tsf32; + uint32_t last_ack_rssi; + uint32_t tx_waste_time; + uint32_t rx_time; + uint32_t phyerr_cnt; + wmi_host_dcs_mib_stats_t mib_stats; +} wmi_host_dcs_im_tgt_stats_t; + +/** + * Enum for pktlog req + */ +typedef enum { + WMI_HOST_PKTLOG_EVENT_RX = 0x1, + WMI_HOST_PKTLOG_EVENT_TX = 0x2, + WMI_HOST_PKTLOG_EVENT_RCF = 0x4, /* Rate Control Find */ + WMI_HOST_PKTLOG_EVENT_RCU = 0x8, /* Rate Control Update */ + WMI_HOST_PKTLOG_EVENT_DBG_PRINT = 0x10, /* DEBUG prints */ + /* To support Smart Antenna */ + WMI_HOST_PKTLOG_EVENT_SMART_ANTENNA = 0x20, + WMI_HOST_PKTLOG_EVENT_H_INFO = 0x40, + WMI_HOST_PKTLOG_EVENT_STEERING = 0x80, +} WMI_HOST_PKTLOG_EVENT; + +/** + * wmi_host_phyerr + * + */ +#define WMI_HOST_PHY_ERROR_SPECTRAL_SCAN 0x26 +#define WMI_HOST_PHY_ERROR_FALSE_RADAR_EXT 0x24 + +#define WMI_HOST_AR900B_DFS_PHYERR_MASK 0x4 +#define WMI_HOST_AR900B_SPECTRAL_PHYERR_MASK 0x4000000 + +/** + * struct wmi_host_perchain_rssi_info - per chain RSSI info + * @rssi_pri20: RSSI on primary 20 + * @rssi_sec20: RSSI on secomdary 20 + * @rssi_sec40: RSSI secondary 40 + * @rssi_sec80: RSSI secondary 80 + */ +typedef struct wmi_host_perchain_rssi_info { + int8_t rssi_pri20; + int8_t rssi_sec20; + int8_t rssi_sec40; + int8_t rssi_sec80; +} wmi_host_perchain_rssi_info_t; + +/** + * struct _wmi_host_rf_info - RF measurement information + * @rssi_comb: RSSI Information + * @pc_rssi_info[4]: For now, we know we are getting information + * for only 4 chains at max. For future extensions + * use a define + * @noise_floor: Noise floor information + */ +typedef struct _wmi_host_rf_info { + int8_t rssi_comb; + wmi_host_perchain_rssi_info_t pc_rssi_info[4]; + int16_t noise_floor[4]; +} wmi_host_rf_info_t; + +/** + * struct _wmi_host_chan_info + * @center_freq1: center frequency 1 in MHz + * @center_freq2: center frequency 2 in MHz -valid only for + * 11ACVHT 80PLUS80 mode + * @chan_width: channel width in MHz + */ +typedef struct _wmi_host_chan_info { + u_int16_t center_freq1; + u_int16_t center_freq2; + u_int8_t chan_width; +} wmi_host_chan_info_t; + +/** + * struct wmi_host_phyerr + * @rf_info: + * @chan_info: + * @tsf64: + * @phy_err_code: + * @tsf_timestamp: + * @bufp: + * @buf_len: + * @phy_err_mask0: + * @phy_err_mask1: + */ +typedef struct _wmi_host_phyerr { + wmi_host_rf_info_t rf_info; + wmi_host_chan_info_t chan_info; + uint64_t tsf64; + int32_t phy_err_code; + uint32_t tsf_timestamp; + uint8_t *bufp; + uint32_t buf_len; + uint32_t phy_err_mask0; + uint32_t phy_err_mask1; +} wmi_host_phyerr_t; + +/** + * struct wmi_host_rtt_event_hdr + * @req_id: request id + * @status: status + * @meas_done: measurement done flag + * @meas_type: measurement type + * @report_type: report type + * @v3_status: v2 status + * @v3_finish: + * @v3_tm_start: + * @num_ap: number of AP + * @result: resuult + * @dest_mac: destination mac + */ +typedef struct { + uint16_t req_id; + uint16_t status:1, + meas_done:1, + meas_type:3, + report_type:3, + v3_status:2, + v3_finish:1, + v3_tm_start:1, + num_ap:4; + uint16_t result; + uint8_t dest_mac[IEEE80211_ADDR_LEN]; +} wmi_host_rtt_event_hdr; + +/** + * struct wmi_host_rtt_meas_event - RTT measurement event + * @chain_mask: + * @bw: + * @rsvd: + * @txrxchain_mask: Bit:0-3:chain mask + * Bit 4-5: band width info + * 00 --Legacy 20, 01 --HT/VHT20 + * 10 --HT/VHT40, 11 -- VHT80 + * @tod: resolution of 0.1ns + * @toa: resolution of 0.1ns + * @t3: + * @t4: + * @rssi0: + * @rssi1: + * @rssi2: + * @rssi3: + */ +typedef struct { + uint32_t chain_mask:3, + bw:2, + rsvd:27; + uint32_t txrxchain_mask; + uint64_t tod; + uint64_t toa; + uint64_t t3; + uint64_t t4; + uint32_t rssi0; + uint32_t rssi1; + uint32_t rssi2; + uint32_t rssi3; +} wmi_host_rtt_meas_event; + +/*----RTT Report event definition ----*/ +typedef enum { + /* rtt cmd header parsing error --terminate */ + WMI_HOST_RTT_COMMAND_HEADER_ERROR = 0, + /* rtt body parsing error -- skip current STA REQ */ + WMI_HOST_RTT_COMMAND_ERROR, + /* rtt no resource -- terminate */ + WMI_HOST_RTT_MODULE_BUSY, + /* STA exceed the support limit -- only server the first n STA */ + WMI_HOST_RTT_TOO_MANY_STA, + /* any allocate failure */ + WMI_HOST_RTT_NO_RESOURCE, + /* can not find vdev with vdev ID - skip current STA REQ */ + WMI_HOST_RTT_VDEV_ERROR, + /* Tx failure -- continiue and measure number */ + WMI_HOST_RTT_TRANSIMISSION_ERROR, + /* wait for first TM timer expire-terminate current STA measurement */ + WMI_HOST_RTT_TM_TIMER_EXPIRE, + /* we do not support RTT measurement with this type of frame */ + WMI_HOST_RTT_FRAME_TYPE_NOSUPPORT, + /* whole RTT measurement timer expire-terminate + ** current STA measurement */ + WMI_HOST_RTT_TIMER_EXPIRE, + /* channel swicth failed */ + WMI_HOST_RTT_CHAN_SWITCH_ERROR, + /* TMR trans error, this dest peer will be skipped */ + WMI_HOST_RTT_TMR_TRANS_ERROR, + /* V3 only. If both CFR and Token mismatch, do not report */ + WMI_HOST_RTT_NO_REPORT_BAD_CFR_TOKEN, + /* For First TM, if CFR is bad, then do not report */ + WMI_HOST_RTT_NO_REPORT_FIRST_TM_BAD_CFR, + /* do not allow report type2 mix with type 0, 1 */ + WMI_HOST_RTT_REPORT_TYPE2_MIX, + /* LCI Configuration OK. - Responder only */ + WMI_HOST_RTT_LCI_CFG_OK, + /* LCR configuration OK. - Responder only */ + WMI_HOST_RTT_LCR_CFG_OK, + /* Bad configuration LCI (or) LCR request - Responder only */ + WMI_HOST_RTT_CFG_ERROR, + WMI_HOST_WMI_RTT_REJECT_MAX, +} WMI_HOST_RTT_ERROR_INDICATOR; +typedef struct { + wmi_host_rtt_event_hdr hdr; + WMI_HOST_RTT_ERROR_INDICATOR reject_reason; +} wmi_host_rtt_error_report_event; + +#if defined(AR9888) +typedef enum { + WMI_HOST_PROF_CPU_IDLE, + WMI_HOST_PROF_PPDU_PROC, + WMI_HOST_PROF_PPDU_POST, + WMI_HOST_PROF_HTT_TX_INPUT, + WMI_HOST_PROF_MSDU_ENQ, + WMI_HOST_PROF_PPDU_POST_HAL, + WMI_HOST_PROF_COMPUTE_TX_TIME, + + /* Add new ID's above this. */ + WMI_HOST_PROF_MAX_ID, +} wmi_host_profile_id_t; +#endif + +#define WMI_HOST_WLAN_PROFILE_MAX_HIST 3 +#define WMI_HOST_WLAN_PROFILE_MAX_BIN_CNT 32 + +#if defined(AR9888) +#define WMI_HOST_MAX_PROFILE WMI_HOST_PROF_MAX_ID +#else +#define WMI_HOST_MAX_PROFILE WMI_HOST_WLAN_PROFILE_MAX_BIN_CNT +#endif + +/** + * struct wmi_host_wlan_profile - Host profile param + * @id: profile id + * @cnt: Count + * @tot: + * @min: minimum + * @max: Mac + * @hist_intvl: history interval + * @hist: profile data history + */ +typedef struct { + uint32_t id; + uint32_t cnt; + uint32_t tot; + uint32_t min; + uint32_t max; + uint32_t hist_intvl; + uint32_t hist[WMI_HOST_WLAN_PROFILE_MAX_HIST]; +} wmi_host_wlan_profile_t; + +/** + * struct wmi_host_wlan_profile_ctx_t - profile context + * @tot: time in us + * @tx_msdu_cnt: MSDU TX count + * @tx_mpdu_cnt: MPDU tx count + * @tx_ppdu_cnt: PPDU tx count + * @rx_msdu_cnt: MSDU RX count + * @rx_mpdu_cnt: MPDU RXcount + * @bin_count: Bin count + */ +typedef struct { + uint32_t tot; + uint32_t tx_msdu_cnt; + uint32_t tx_mpdu_cnt; + uint32_t tx_ppdu_cnt; + uint32_t rx_msdu_cnt; + uint32_t rx_mpdu_cnt; + uint32_t bin_count; +} wmi_host_wlan_profile_ctx_t; + +/** + * struct wmi_host_profile_stats_event - Profile stats event + * @profile_ctx: wmi_host_wlan_profile_ctx_t + * @profile_data: wmi_host_wlan_profile_t + */ +typedef struct { + wmi_host_wlan_profile_ctx_t profile_ctx; + wmi_host_wlan_profile_t profile_data[WMI_HOST_MAX_PROFILE]; +} wmi_host_profile_stats_event; + +/** + * struct wmi_host_chan_info_event - Channel info WMI event + * @err_code: Error code + * @freq: Channel freq + * @cmd_flags: Read flags + * @noise_floor: Noise Floor value + * @rx_clear_count: rx clear count + * @cycle_count: cycle count + * @chan_tx_pwr_range: channel tx power per range + * @chan_tx_pwr_tp: channel tx power per throughput + * @rx_frame_count: rx frame count + * @rx_11b_mode_data_duration: 11b mode data duration + */ +typedef struct { + uint32_t err_code; + uint32_t freq; + uint32_t cmd_flags; + uint32_t noise_floor; + uint32_t rx_clear_count; + uint32_t cycle_count; + uint32_t chan_tx_pwr_range; + uint32_t chan_tx_pwr_tp; + uint32_t rx_frame_count; + uint32_t rx_11b_mode_data_duration; +} wmi_host_chan_info_event; + +/** + * struct wmi_host_pdev_channel_hopping_event + * @noise_floor_report_iter: Noise threshold iterations with high values + * @noise_floor_total_iter: Total noise threshold iterations + */ +typedef struct { + uint32_t noise_floor_report_iter; + uint32_t noise_floor_total_iter; +} wmi_host_pdev_channel_hopping_event; + +/** + * struct wmi_host_pdev_bss_chan_info_event + * @freq: Units in MHz + * @noise_floor: units are dBm + * @rx_clear_count_low: + * @rx_clear_count_high: + * @cycle_count_low: + * @cycle_count_high: + * @tx_cycle_count_low: + * @tx_cycle_count_high: + * @rx_cycle_count_low: + * @rx_cycle_count_high: + * @rx_bss_cycle_count_low: + * @rx_bss_cycle_count_high: + * @reserved: + */ +typedef struct { + uint32_t freq; + uint32_t noise_floor; + uint32_t rx_clear_count_low; + uint32_t rx_clear_count_high; + uint32_t cycle_count_low; + uint32_t cycle_count_high; + uint32_t tx_cycle_count_low; + uint32_t tx_cycle_count_high; + uint32_t rx_cycle_count_low; + uint32_t rx_cycle_count_high; + uint32_t rx_bss_cycle_count_low; + uint32_t rx_bss_cycle_count_high; + uint32_t reserved; +} wmi_host_pdev_bss_chan_info_event; + +#define WMI_HOST_INST_STATS_INVALID_RSSI 0 +/** + * struct wmi_host_inst_stats_resp + * @iRSSI: Instantaneous RSSI + * @peer_macaddr: peer mac address + */ +typedef struct { + uint32_t iRSSI; + wmi_host_mac_addr peer_macaddr; +} wmi_host_inst_stats_resp; + +/* Event definition and new structure addition to send event + * to host to block/unblock tx data traffic based on peer_ast_idx or vdev id + */ +#define WMI_HOST_INVALID_PEER_AST_INDEX 0xffff +#define WMI_HOST_TX_DATA_TRAFFIC_CTRL_BLOCK 0x1 +#define WMI_HOST_TX_DATA_TRAFFIC_CTRL_UNBLOCK 0x2 +/** + * struct wmi_host_tx_data_traffic_ctrl_event + * @peer_ast_idx: For vdev based control, peer_ast_idx will be + * WMI_INVALID_PEER_AST_INDEX + * @vdev_id: only applies if peer_ast_idx == INVALID + * @ctrl_cmd: WMI_TX_DATA_TRAFFIC_CTRL_BLOCK or + * WMI_TX_DATA_TRAFFIC_CTRL_UNBLOCK + */ +typedef struct { + uint32_t peer_ast_idx; + uint32_t vdev_id; + uint32_t ctrl_cmd; +} wmi_host_tx_data_traffic_ctrl_event; + +/** + * struct wmi_host_ath_dcs_cw_int + * @channel: either number or freq in mhz + */ +typedef struct { + uint32_t channel; +} wmi_host_ath_dcs_cw_int; #endif /* _WMI_UNIFIED_PARAM_H_ */ diff --git a/wmi_unified_priv.h b/wmi_unified_priv.h index 267b68785c..6957008a9f 100644 --- a/wmi_unified_priv.h +++ b/wmi_unified_priv.h @@ -35,6 +35,7 @@ #include "a_types.h" #include "wmi.h" #include "wmi_unified.h" +#include "wmi_unified_param.h" #include "qdf_atomic.h" #define WMI_UNIFIED_MAX_EVENT 0x100 @@ -152,13 +153,23 @@ QDF_STATUS (*send_stats_request_cmd)(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct stats_request_params *param); +#ifdef WMI_NON_TLV_SUPPORT +QDF_STATUS (*send_packet_log_enable_cmd)(wmi_unified_t wmi_handle, + WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT); +#else QDF_STATUS (*send_packet_log_enable_cmd)(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct packet_enable_params *param); +#endif + +QDF_STATUS (*send_packet_log_disable_cmd)(wmi_unified_t wmi_handle); QDF_STATUS (*send_beacon_send_cmd)(wmi_unified_t wmi_handle, struct beacon_params *param); +QDF_STATUS (*send_beacon_tmpl_send_cmd)(wmi_unified_t wmi_handle, + struct beacon_tmpl_params *param); + QDF_STATUS (*send_peer_assoc_cmd)(wmi_unified_t wmi_handle, struct peer_assoc_params *param); @@ -251,9 +262,11 @@ QDF_STATUS (*send_probe_rsp_tmpl_send_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_setup_install_key_cmd)(wmi_unified_t wmi_handle, struct set_key_params *key_params); +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_process_update_edca_param_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id, wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC]); +#endif QDF_STATUS (*send_vdev_set_gtx_cfg_cmd)(wmi_unified_t wmi_handle, uint32_t if_id, @@ -265,9 +278,10 @@ QDF_STATUS (*send_set_sta_keep_alive_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_set_sta_sa_query_param_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id, uint32_t max_retries, uint32_t retry_interval); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_bcn_buf_ll_cmd)(wmi_unified_t wmi_handle, wmi_bcn_send_from_host_cmd_fixed_param *param); +#endif QDF_STATUS (*send_set_gateway_params_cmd)(wmi_unified_t wmi_handle, struct gateway_update_req_param *req); @@ -280,10 +294,11 @@ QDF_STATUS (*send_scan_probe_setoui_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_reset_passpoint_network_list_cmd)(wmi_unified_t wmi_handle, struct wifi_passpoint_req_param *req); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_roam_scan_offload_mode_cmd)(wmi_unified_t wmi_handle, wmi_start_scan_cmd_fixed_param *scan_cmd_fp, struct roam_offload_scan_params *roam_req); +#endif QDF_STATUS (*send_roam_scan_offload_rssi_thresh_cmd)(wmi_unified_t wmi_handle, struct roam_offload_scan_rssi_params *roam_req); @@ -322,6 +337,7 @@ QDF_STATUS (*send_start_extscan_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_plm_stop_cmd)(wmi_unified_t wmi_handle, const struct plm_req_params *plm); + QDF_STATUS (*send_plm_start_cmd)(wmi_unified_t wmi_handle, const struct plm_req_params *plm, uint32_t *gchannel_list); @@ -331,9 +347,11 @@ QDF_STATUS (*send_csa_offload_enable_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_pno_stop_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id); +#ifdef FEATURE_WLAN_SCAN_PNO QDF_STATUS (*send_pno_start_cmd)(wmi_unified_t wmi_handle, struct pno_scan_req_params *pno, uint32_t *gchannel_freq_list); +#endif QDF_STATUS (*send_ipa_offload_control_cmd)(wmi_unified_t wmi_handle, struct ipa_offload_control_params *ipa_offload); @@ -363,7 +381,7 @@ QDF_STATUS (*send_snr_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id); QDF_STATUS (*send_link_status_req_cmd)(wmi_unified_t wmi_handle, struct link_status_params *link_status); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_lphb_config_hbenable_cmd)(wmi_unified_t wmi_handle, wmi_hb_set_enable_cmd_fixed_param *params); @@ -387,6 +405,7 @@ QDF_STATUS (*send_get_link_speed_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_egap_conf_params_cmd)(wmi_unified_t wmi_handle, wmi_ap_ps_egap_param_cmd_fixed_param *egap_params); +#endif QDF_STATUS (*send_fw_profiling_cmd)(wmi_unified_t wmi_handle, uint32_t cmd, uint32_t value1, uint32_t value2); @@ -404,10 +423,11 @@ QDF_STATUS (*send_start_oem_data_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_dfs_phyerr_filter_offload_en_cmd)(wmi_unified_t wmi_handle, bool dfs_phyerr_filter_offload); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_pktlog_wmi_send_cmd)(wmi_unified_t wmi_handle, WMI_PKTLOG_EVENT pktlog_event, WMI_CMD_ID cmd_id); +#endif QDF_STATUS (*send_add_wow_wakeup_event_cmd)(wmi_unified_t wmi_handle, uint32_t vdev_id, @@ -564,10 +584,11 @@ QDF_STATUS (*send_roam_invoke_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_roam_scan_offload_cmd)(wmi_unified_t wmi_handle, uint32_t command, uint32_t vdev_id); - +#ifndef WMI_NON_TLV_SUPPORT QDF_STATUS (*send_roam_scan_offload_ap_profile_cmd)(wmi_unified_t wmi_handle, wmi_ap_profile *ap_profile_p, uint32_t vdev_id); +#endif QDF_STATUS (*send_roam_scan_offload_scan_period_cmd)(wmi_unified_t wmi_handle, uint32_t scan_period, @@ -588,6 +609,431 @@ QDF_STATUS (*send_roam_scan_offload_rssi_change_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_get_buf_extscan_hotlist_cmd)(wmi_unified_t wmi_handle, struct ext_scan_setbssi_hotlist_params * photlist, int *buf_len); + +QDF_STATUS (*send_pdev_get_tpc_config_cmd)(wmi_unified_t wmi_handle, + uint32_t param); + +QDF_STATUS (*send_set_atf_cmd)(wmi_unified_t wmi_handle, + struct set_atf_params *param); + +QDF_STATUS (*send_pdev_fips_cmd)(wmi_unified_t wmi_handle, + struct fips_params *param); + +QDF_STATUS (*send_wlan_profile_enable_cmd)(wmi_unified_t wmi_handle, + struct wlan_profile_params *param); + +QDF_STATUS (*send_wlan_profile_trigger_cmd)(wmi_unified_t wmi_handle, + struct wlan_profile_params *param); + +QDF_STATUS (*send_pdev_set_chan_cmd)(wmi_unified_t wmi_handle, + struct channel_param *param); + +QDF_STATUS (*send_set_ht_ie_cmd)(wmi_unified_t wmi_handle, + struct ht_ie_params *param); + +QDF_STATUS (*send_set_vht_ie_cmd)(wmi_unified_t wmi_handle, + struct vht_ie_params *param); + +QDF_STATUS (*send_wmm_update_cmd)(wmi_unified_t wmi_handle, + struct wmm_update_params *param); + +QDF_STATUS (*send_set_ant_switch_tbl_cmd)(wmi_unified_t wmi_handle, + struct ant_switch_tbl_params *param); + +QDF_STATUS (*send_set_ratepwr_table_cmd)(wmi_unified_t wmi_handle, + struct ratepwr_table_params *param); + +QDF_STATUS (*send_get_ratepwr_table_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_set_ctl_table_cmd)(wmi_unified_t wmi_handle, + struct ctl_table_params *param); + +QDF_STATUS (*send_set_mimogain_table_cmd)(wmi_unified_t wmi_handle, + struct mimogain_table_params *param); + +QDF_STATUS (*send_set_ratepwr_chainmsk_cmd)(wmi_unified_t wmi_handle, + struct ratepwr_chainmsk_params *param); + +QDF_STATUS (*send_set_macaddr_cmd)(wmi_unified_t wmi_handle, + struct macaddr_params *param); + +QDF_STATUS (*send_pdev_scan_start_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_pdev_scan_end_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_set_acparams_cmd)(wmi_unified_t wmi_handle, + struct acparams_params *param); + +QDF_STATUS (*send_set_vap_dscp_tid_map_cmd)(wmi_unified_t wmi_handle, + struct vap_dscp_tid_map_params *param); + +QDF_STATUS (*send_proxy_ast_reserve_cmd)(wmi_unified_t wmi_handle, + struct proxy_ast_reserve_params *param); + +QDF_STATUS (*send_pdev_qvit_cmd)(wmi_unified_t wmi_handle, + struct pdev_qvit_params *param); + +QDF_STATUS (*send_mcast_group_update_cmd)(wmi_unified_t wmi_handle, + struct mcast_group_update_params *param); + +QDF_STATUS (*send_peer_add_wds_entry_cmd)(wmi_unified_t wmi_handle, + struct peer_add_wds_entry_params *param); + +QDF_STATUS (*send_peer_del_wds_entry_cmd)(wmi_unified_t wmi_handle, + struct peer_del_wds_entry_params *param); + +QDF_STATUS (*send_peer_update_wds_entry_cmd)(wmi_unified_t wmi_handle, + struct peer_update_wds_entry_params *param); + +QDF_STATUS (*send_phyerr_enable_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_phyerr_disable_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_smart_ant_enable_cmd)(wmi_unified_t wmi_handle, + struct smart_ant_enable_params *param); + +QDF_STATUS (*send_smart_ant_set_rx_ant_cmd)(wmi_unified_t wmi_handle, + struct smart_ant_rx_ant_params *param); + +QDF_STATUS (*send_smart_ant_set_tx_ant_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_tx_ant_params *param); + +QDF_STATUS (*send_smart_ant_set_training_info_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_training_info_params *param); + +QDF_STATUS (*send_smart_ant_set_node_config_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct smart_ant_node_config_params *param); + +QDF_STATUS (*send_smart_ant_enable_tx_feedback_cmd)(wmi_unified_t wmi_handle, + struct smart_ant_enable_tx_feedback_params *param); + +QDF_STATUS (*send_vdev_spectral_configure_cmd)(wmi_unified_t wmi_handle, + struct vdev_spectral_configure_params *param); + +QDF_STATUS (*send_vdev_spectral_enable_cmd)(wmi_unified_t wmi_handle, + struct vdev_spectral_enable_params *param); + +QDF_STATUS (*send_bss_chan_info_request_cmd)(wmi_unified_t wmi_handle, + struct bss_chan_info_request_params *param); + +QDF_STATUS (*send_thermal_mitigation_param_cmd)(wmi_unified_t wmi_handle, + struct thermal_mitigation_params *param); + +QDF_STATUS (*send_vdev_set_neighbour_rx_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct set_neighbour_rx_params *param); + +QDF_STATUS (*send_vdev_set_fwtest_param_cmd)(wmi_unified_t wmi_handle, + struct set_fwtest_params *param); + +QDF_STATUS (*send_vdev_config_ratemask_cmd)(wmi_unified_t wmi_handle, + struct config_ratemask_params *param); + +QDF_STATUS (*send_vdev_install_key_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct vdev_install_key_params *param); + +QDF_STATUS (*send_wow_wakeup_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_wow_add_wakeup_event_cmd)(wmi_unified_t wmi_handle, + struct wow_add_wakeup_params *param); + +QDF_STATUS (*send_wow_add_wakeup_pattern_cmd)(wmi_unified_t wmi_handle, + struct wow_add_wakeup_pattern_params *param); + +QDF_STATUS (*send_wow_remove_wakeup_pattern_cmd)(wmi_unified_t wmi_handle, + struct wow_remove_wakeup_pattern_params *param); + +QDF_STATUS (*send_pdev_set_regdomain_cmd)(wmi_unified_t wmi_handle, + struct pdev_set_regdomain_params *param); + +QDF_STATUS (*send_set_quiet_mode_cmd)(wmi_unified_t wmi_handle, + struct set_quiet_mode_params *param); + +QDF_STATUS (*send_set_beacon_filter_cmd)(wmi_unified_t wmi_handle, + struct set_beacon_filter_params *param); + +QDF_STATUS (*send_remove_beacon_filter_cmd)(wmi_unified_t wmi_handle, + struct remove_beacon_filter_params *param); +/* +QDF_STATUS (*send_mgmt_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct mgmt_params *param); + */ + +QDF_STATUS (*send_addba_clearresponse_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_clearresponse_params *param); + +QDF_STATUS (*send_addba_send_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_send_params *param); + +QDF_STATUS (*send_delba_send_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct delba_send_params *param); + +QDF_STATUS (*send_addba_setresponse_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct addba_setresponse_params *param); + +QDF_STATUS (*send_singleamsdu_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct singleamsdu_params *param); + +QDF_STATUS (*send_set_qboost_param_cmd)(wmi_unified_t wmi_handle, + uint8_t macaddr[IEEE80211_ADDR_LEN], + struct set_qboost_params *param); + +QDF_STATUS (*send_mu_scan_cmd)(wmi_unified_t wmi_handle, + struct mu_scan_params *param); + +QDF_STATUS (*send_lteu_config_cmd)(wmi_unified_t wmi_handle, + struct lteu_config_params *param); + +QDF_STATUS (*send_set_ps_mode_cmd)(wmi_unified_t wmi_handle, + struct set_ps_mode_params *param); +void (*save_service_bitmap)(wmi_unified_t wmi_handle, + void *evt_buf); +bool (*is_service_enabled)(wmi_unified_t wmi_handle, + uint32_t service_id); +QDF_STATUS (*get_target_cap_from_service_ready)(wmi_unified_t wmi_handle, + void *evt_buf, target_capability_info *ev); + +QDF_STATUS (*extract_fw_version)(wmi_unified_t wmi_handle, + void *ev, struct wmi_host_fw_ver *fw_ver); + +QDF_STATUS (*extract_fw_abi_version)(wmi_unified_t wmi_handle, + void *ev, struct wmi_host_fw_abi_ver *fw_ver); + +QDF_STATUS (*extract_hal_reg_cap)(wmi_unified_t wmi_handle, void *evt_buf, + TARGET_HAL_REG_CAPABILITIES *hal_reg_cap); + +host_mem_req * (*extract_host_mem_req)(wmi_unified_t wmi_handle, + void *evt_buf, uint8_t *num_entries); + +QDF_STATUS (*init_cmd_send)(wmi_unified_t wmi_handle, + target_resource_config *res_cfg, + uint8_t num_mem_chunks, + struct wmi_host_mem_chunk *mem_chunk); + +QDF_STATUS (*save_fw_version)(wmi_unified_t wmi_handle, void *evt_buf); +uint32_t (*ready_extract_init_status)(wmi_unified_t wmi_hdl, void *ev); +QDF_STATUS (*ready_extract_mac_addr)(wmi_unified_t wmi_hdl, void *ev, + uint8_t *macaddr); +QDF_STATUS (*check_and_update_fw_version)(wmi_unified_t wmi_hdl, void *ev); +uint8_t* (*extract_dbglog_data_len)(wmi_unified_t wmi_handle, void *evt_buf, + uint16_t *len); +QDF_STATUS (*send_ext_resource_config)(wmi_unified_t wmi_handle, + wmi_host_ext_resource_config *ext_cfg); + +QDF_STATUS (*send_nf_dbr_dbm_info_get_cmd)(wmi_unified_t wmi_handle); + +QDF_STATUS (*send_packet_power_info_get_cmd)(wmi_unified_t wmi_handle, + struct packet_power_info_params *param); + +QDF_STATUS (*send_gpio_config_cmd)(wmi_unified_t wmi_handle, + struct gpio_config_params *param); + +QDF_STATUS (*send_gpio_output_cmd)(wmi_unified_t wmi_handle, + struct gpio_output_params *param); + +QDF_STATUS (*send_rtt_meas_req_test_cmd)(wmi_unified_t wmi_handle, + struct rtt_meas_req_test_params *param); + +QDF_STATUS (*send_rtt_meas_req_cmd)(wmi_unified_t wmi_handle, + struct rtt_meas_req_params *param); + +QDF_STATUS (*send_rtt_keepalive_req_cmd)(wmi_unified_t wmi_handle, + struct rtt_keepalive_req_params *param); + +QDF_STATUS (*send_lci_set_cmd)(wmi_unified_t wmi_handle, + struct lci_set_params *param); + +QDF_STATUS (*send_lcr_set_cmd)(wmi_unified_t wmi_handle, + struct lcr_set_params *param); + +QDF_STATUS (*send_periodic_chan_stats_config_cmd)(wmi_unified_t wmi_handle, + struct periodic_chan_stats_params *param); + +QDF_STATUS +(*send_atf_peer_request_cmd)(wmi_unified_t wmi_handle, + struct atf_peer_request_params *param); + +QDF_STATUS +(*send_set_atf_grouping_cmd)(wmi_unified_t wmi_handle, + struct atf_grouping_params *param); + +QDF_STATUS (*extract_wds_addr_event)(wmi_unified_t wmi_handle, + void *evt_buf, uint16_t len, wds_addr_event_t *wds_ev); + +QDF_STATUS (*extract_dcs_interference_type)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *interference_type); + +QDF_STATUS (*extract_dcs_cw_int)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_ath_dcs_cw_int *cw_int); + +QDF_STATUS (*extract_dcs_im_tgt_stats)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_dcs_im_tgt_stats_t *wlan_stat); + +QDF_STATUS (*extract_fips_event_error_status)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *err_status); + +QDF_STATUS (*extract_fips_event_data)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *data_len, uint32_t **data); +QDF_STATUS (*extract_vdev_start_resp)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_vdev_start_resp *vdev_rsp); + +QDF_STATUS (*extract_tbttoffset_update_params)(void *wmi_hdl, void *evt_buf, + uint32_t *vdev_map, uint32_t **tbttoffset_list); + +QDF_STATUS (*extract_mgmt_rx_params)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_mgmt_rx_hdr *hdr, uint8_t **bufp); + +QDF_STATUS (*extract_vdev_stopped_param)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *vdev_id); + +QDF_STATUS (*extract_vdev_roam_param)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_roam_event *param); + +QDF_STATUS (*extract_vdev_scan_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_scan_event *param); + +QDF_STATUS (*extract_mu_ev_param)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_mu_report_event *param); + +QDF_STATUS (*extract_pdev_tpc_config_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_pdev_tpc_config_event *param); + +QDF_STATUS (*extract_gpio_input_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *gpio_num); + +QDF_STATUS (*extract_pdev_reserve_ast_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, uint32_t *result); + +QDF_STATUS (*extract_nfcal_power_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, + wmi_host_pdev_nfcal_power_all_channels_event *param); + +QDF_STATUS (*extract_pdev_tpc_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_pdev_tpc_event *param); + +QDF_STATUS (*extract_pdev_generic_buffer_ev_param)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_pdev_generic_buffer_event *param); + +QDF_STATUS (*extract_mgmt_tx_compl_param)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_mgmt_tx_compl_event *param); + +QDF_STATUS (*extract_swba_vdev_map)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t *vdev_map); + +QDF_STATUS (*extract_swba_tim_info)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t idx, wmi_host_tim_info *tim_info); + +QDF_STATUS (*extract_swba_noa_info)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t idx, wmi_host_p2p_noa_info *p2p_desc); + +QDF_STATUS (*extract_peer_sta_ps_statechange_ev)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_peer_sta_ps_statechange_event *ev); + +QDF_STATUS (*extract_peer_sta_kickout_ev)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_peer_sta_kickout_event *ev); + +QDF_STATUS (*extract_peer_ratecode_list_ev)(wmi_unified_t wmi_handle, + void *evt_buf, uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap); + +QDF_STATUS (*extract_comb_phyerr)(wmi_unified_t wmi_handle, void *evt_buf, + uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr); + +QDF_STATUS (*extract_single_phyerr)(wmi_unified_t wmi_handle, void *evt_buf, + uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr); + +QDF_STATUS (*extract_composite_phyerr)(wmi_unified_t wmi_handle, void *evt_buf, + uint16_t datalen, wmi_host_phyerr_t *phyerr); + +QDF_STATUS (*extract_rtt_hdr)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_rtt_event_hdr *ev); + +QDF_STATUS (*extract_rtt_ev)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_rtt_meas_event *ev, uint8_t *hdump, uint16_t hdump_len); + +QDF_STATUS (*extract_rtt_error_report_ev)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_rtt_error_report_event *ev); + +QDF_STATUS (*extract_all_stats_count)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_stats_event *stats_param); + +QDF_STATUS (*extract_pdev_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_pdev_stats *pdev_stats); + +QDF_STATUS (*extract_pdev_ext_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats); + +QDF_STATUS (*extract_vdev_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_vdev_stats *vdev_stats); + +QDF_STATUS (*extract_peer_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_peer_stats *peer_stats); + +QDF_STATUS (*extract_bcnflt_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats); + +QDF_STATUS (*extract_peer_extd_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_peer_extd_stats *peer_extd_stats); + +QDF_STATUS (*extract_chan_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t index, wmi_host_chan_stats *chan_stats); + +QDF_STATUS (*extract_thermal_stats)(wmi_unified_t wmi_handle, void *evt_buf, + uint32_t *temp, uint32_t *level); + +QDF_STATUS (*extract_thermal_level_stats)(wmi_unified_t wmi_handle, + void *evt_buf, uint8_t idx, uint32_t *levelcount, + uint32_t *dccount); + +QDF_STATUS (*extract_profile_ctx)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_wlan_profile_ctx_t *profile_ctx); + +QDF_STATUS (*extract_profile_data)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_wlan_profile_t *profile_data); + +QDF_STATUS (*extract_chan_info_event)(wmi_unified_t wmi_handle, void *evt_buf, + wmi_host_chan_info_event *chan_info); + +QDF_STATUS (*extract_channel_hopping_event)(wmi_unified_t wmi_handle, + void *evt_buf, + wmi_host_pdev_channel_hopping_event *ch_hopping); + +QDF_STATUS (*extract_bss_chan_info_event)(wmi_unified_t wmi_handle, + void *evt_buf, + wmi_host_pdev_bss_chan_info_event *bss_chan_info); + +QDF_STATUS (*extract_inst_rssi_stats_event)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_inst_stats_resp *inst_rssi_resp); + +QDF_STATUS (*extract_tx_data_traffic_ctrl_ev)(wmi_unified_t wmi_handle, + void *evt_buf, wmi_host_tx_data_traffic_ctrl_event *ev); + +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); +}; + +struct target_abi_version { + A_UINT32 abi_version_0; + /** WMI Major and Minor versions */ + A_UINT32 abi_version_1; + /** WMI change revision */ + A_UINT32 abi_version_ns_0; + /** ABI version namespace first four dwords */ + A_UINT32 abi_version_ns_1; + /** ABI version namespace second four dwords */ + A_UINT32 abi_version_ns_2; + /** ABI version namespace third four dwords */ + A_UINT32 abi_version_ns_3; + /** ABI version namespace fourth four dwords */ }; /** @@ -601,7 +1047,7 @@ struct wmi_cmd_init { }; struct wmi_unified { - ol_scn_t scn_handle; /* handle to device */ + void *scn_handle; /* handle to device */ osdev_t osdev; /* handle to use OS-independent services */ qdf_atomic_t pending_cmds; HTC_ENDPOINT_ID wmi_endpoint_id; @@ -615,8 +1061,10 @@ struct wmi_unified { qdf_nbuf_queue_t event_queue; struct work_struct rx_event_work; int wmi_stop_in_progress; +#ifndef WMI_NON_TLV_SUPPORT struct _wmi_abi_version fw_abi_version; struct _wmi_abi_version final_abi_vers; +#endif struct wmi_cmd_init saved_wmi_init_cmd; uint32_t num_of_diag_events_logs; uint32_t *events_logs_list; @@ -636,14 +1084,27 @@ struct wmi_unified { qdf_atomic_t runtime_pm_inprogress; #endif + enum wmi_target_type target_type; struct wmi_rx_ops rx_ops; struct wmi_ops *ops; - void *event_handler_cookie[WMI_UNIFIED_MAX_EVENT]; bool use_cookie; + bool wmi_stopinprogress; qdf_spinlock_t ctx_lock; +#ifdef WMI_TLV_AND_NON_TLV_SUPPORT + /* WMI service bitmap recieved from target */ + uint32_t wmi_service_bitmap[wmi_services_max]; + uint32_t wmi_events[wmi_events_max]; + uint32_t pdev_param[wmi_pdev_param_max]; + uint32_t vdev_param[wmi_vdev_param_max]; + uint32_t services[wmi_services_max]; +#endif }; -struct wmi_ops *wmi_get_tlv_ops(void); -struct wmi_ops *wmi_get_non_tlv_ops(void); +#ifdef WMI_NON_TLV_SUPPORT +#define wmi_tlv_attach(x) qdf_print("TLV Unavailable\n") +#else +void wmi_tlv_attach(wmi_unified_t wmi_handle); +#endif +void wmi_non_tlv_attach(wmi_unified_t wmi_handle); /** * wmi_align() - provides word aligned parameter