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 <[email protected]>
CRs-Fixed: 1005778

wmi/inc/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_ */

wmi/inc/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);
 

wmi/inc/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_ */
 

wmi/inc/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

wmi/src/wmi_unified.c

@@ -34,7 +34,9 @@
 #include "a_debug.h"
 #include "ol_if_athvar.h"
 #include "ol_defines.h"
+#ifndef WMI_NON_TLV_SUPPORT
 #include "ol_fw.h"
+#endif
 #include "htc_api.h"
 #include "htc_api.h"
 #include "dbglog_host.h"
@@ -159,7 +161,6 @@ wmi_mgmt_event_log_buffer[WMI_MGMT_EVENT_DEBUG_MAX_ENTRY];
 
 #endif /*WMI_INTERFACE_EVENT_LOGGING */
 
-static void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf);
 int wmi_get_host_credits(wmi_unified_t wmi_handle);
 /* WMI buffer APIs */
 
@@ -242,6 +243,7 @@ uint16_t wmi_get_max_msg_len(wmi_unified_t wmi_handle)
 	return wmi_handle->max_msg_len - WMI_MIN_HEAD_ROOM;
 }
 
+#ifndef WMI_NON_TLV_SUPPORT
 static uint8_t *get_wmi_cmd_string(WMI_CMD_ID wmi_command)
 {
 	switch (wmi_command) {
@@ -578,10 +580,10 @@ static uint8_t *get_wmi_cmd_string(WMI_CMD_ID wmi_command)
 		 * as we MUST have a fixed value here to maintain compatibility between
 		 * UTF and the ART2 driver
 		 */
-		/** UTF WMI commands */
+		/* UTF WMI commands */
 		CASE_RETURN_STRING(WMI_PDEV_UTF_CMDID);
 
-		/** set debug log config */
+		/* set debug log config */
 		CASE_RETURN_STRING(WMI_DBGLOG_CFG_CMDID);
 		/* QVIT specific command id */
 		CASE_RETURN_STRING(WMI_PDEV_QVIT_CMDID);
@@ -662,7 +664,7 @@ static uint8_t *get_wmi_cmd_string(WMI_CMD_ID wmi_command)
 		CASE_RETURN_STRING(WMI_RMC_CONFIG_CMDID);
 
 		/* WLAN MHF offload commands */
-		/** enable/disable MHF offload */
+		/* enable/disable MHF offload */
 		CASE_RETURN_STRING(WMI_MHF_OFFLOAD_SET_MODE_CMDID);
 		/* Plumb routing table for MHF offload */
 		CASE_RETURN_STRING(WMI_MHF_OFFLOAD_PLUMB_ROUTING_TBL_CMDID);
@@ -820,6 +822,7 @@ static inline void wma_log_cmd_id(WMI_CMD_ID cmd_id)
 		 get_wmi_cmd_string(cmd_id), cmd_id);
 }
 #endif
+#endif
 
 /**
  * wmi_is_runtime_pm_cmd() - check if a cmd is from suspend resume sequence
@@ -827,6 +830,7 @@ static inline void wma_log_cmd_id(WMI_CMD_ID cmd_id)
  *
  * Return: true if the command is part of the suspend resume sequence.
  */
+#ifndef WMI_NON_TLV_SUPPORT
 static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id)
 {
 	switch (cmd_id) {
@@ -845,6 +849,34 @@ static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id)
 	}
 }
 
+/**
+ * wmi_is_pm_resume_cmd() - check if a cmd is part of the resume sequence
+ * @cmd_id: command to check
+ *
+ * Return: true if the command is part of the resume sequence.
+ */
+static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id)
+{
+	switch (cmd_id) {
+	case WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID:
+	case WMI_PDEV_RESUME_CMDID:
+		return true;
+
+	default:
+		return false;
+	}
+}
+#else
+static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id)
+{
+	return false;
+}
+static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id)
+{
+	return false;
+}
+#endif
+
 /**
  * wmi_unified_cmd_send() - WMI command API
  * @wmi_handle: handle to wmi
@@ -865,16 +897,21 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 		if (wmi_is_runtime_pm_cmd(cmd_id))
 			htc_tag = HTC_TX_PACKET_TAG_AUTO_PM;
 	} else if (qdf_atomic_read(&wmi_handle->is_target_suspended) &&
-	    ((WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID != cmd_id) &&
-	     (WMI_PDEV_RESUME_CMDID != cmd_id))) {
+		(!wmi_is_pm_resume_cmd(cmd_id))) {
 		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
 				  "%s: Target is suspended", __func__);
 		QDF_ASSERT(0);
 		return QDF_STATUS_E_BUSY;
 	}
+	if (wmi_handle->wmi_stopinprogress) {
+		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
+			"WMI  stop in progress\n");
+		return -EINVAL;
+	}
 
 	/* Do sanity check on the TLV parameter structure */
-	{
+#ifndef WMI_NON_TLV_SUPPORT
+	if (wmi_handle->target_type == WMI_TLV_TARGET) {
 		void *buf_ptr = (void *)qdf_nbuf_data(buf);
 
 		if (wmitlv_check_command_tlv_params(NULL, buf_ptr, len, cmd_id)
@@ -885,6 +922,7 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 			return QDF_STATUS_E_INVAL;
 		}
 	}
+#endif
 
 	if (qdf_nbuf_push_head(buf, sizeof(WMI_CMD_HDR)) == NULL) {
 		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
@@ -899,7 +937,7 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 	if (qdf_atomic_read(&wmi_handle->pending_cmds) >= WMI_MAX_CMDS) {
 		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
 		    "\n%s: hostcredits = %d", __func__,
-		     wmi_get_host_credits(wmi_handle));
+		wmi_get_host_credits(wmi_handle));
 		htc_dump_counter_info(wmi_handle->htc_handle);
 		qdf_atomic_dec(&wmi_handle->pending_cmds);
 		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
@@ -923,8 +961,9 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
 			       wmi_handle->wmi_endpoint_id, htc_tag);
 
 	SET_HTC_PACKET_NET_BUF_CONTEXT(pkt, buf);
-
+#ifndef WMI_NON_TLV_SUPPORT
 	wma_log_cmd_id(cmd_id);
+#endif
 
 #ifdef WMI_INTERFACE_EVENT_LOGGING
 	qdf_spin_lock_bh(&wmi_handle->wmi_record_lock);
@@ -961,10 +1000,11 @@ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len,
  * Return: event handler's index
  */
 int wmi_unified_get_event_handler_ix(wmi_unified_t wmi_handle,
-				     WMI_EVT_ID event_id)
+				     uint32_t event_id)
 {
 	uint32_t idx = 0;
 	int32_t invalid_idx = -1;
+
 	for (idx = 0; (idx < wmi_handle->max_event_idx &&
 		       idx < WMI_UNIFIED_MAX_EVENT); ++idx) {
 		if (wmi_handle->event_id[idx] == event_id &&
@@ -986,25 +1026,37 @@ int wmi_unified_get_event_handler_ix(wmi_unified_t wmi_handle,
  * Return: 0 on success
  */
 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)
 {
 	uint32_t idx = 0;
+	uint32_t evt_id;
 
-	if (wmi_unified_get_event_handler_ix(wmi_handle, event_id) != -1) {
-		qdf_print("%s : event handler already registered 0x%x \n",
-		       __func__, event_id);
+#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+	if (event_id >= wmi_events_max ||
+		wmi_handle->wmi_events[event_id] == WMI_EVENT_ID_INVALID) {
+		qdf_print("%s: Event id %d is unavailable\n",
+				 __func__, event_id);
+		return QDF_STATUS_E_FAILURE;
+	}
+	evt_id = wmi_handle->wmi_events[event_id];
+#else
+	evt_id = event_id;
+#endif
+	if (wmi_unified_get_event_handler_ix(wmi_handle, evt_id) != -1) {
+		qdf_print("%s : event handler already registered 0x%x\n",
+		       __func__, evt_id);
 		return QDF_STATUS_E_FAILURE;
 	}
 	if (wmi_handle->max_event_idx == WMI_UNIFIED_MAX_EVENT) {
-		qdf_print("%s : no more event handlers 0x%x \n",
-		       __func__, event_id);
+		qdf_print("%s : no more event handlers 0x%x\n",
+		       __func__, evt_id);
 		return QDF_STATUS_E_FAILURE;
 	}
 	idx = wmi_handle->max_event_idx;
 	wmi_handle->event_handler[idx] = handler_func;
-	wmi_handle->event_id[idx] = event_id;
+	wmi_handle->event_id[idx] = evt_id;
 	qdf_spin_lock_bh(&wmi_handle->ctx_lock);
 	wmi_handle->ctx[idx] = rx_ctx;
 	qdf_spin_unlock_bh(&wmi_handle->ctx_lock);
@@ -1021,14 +1073,27 @@ int wmi_unified_register_event_handler(wmi_unified_t wmi_handle,
  * Return: 0 on success
  */
 int wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle,
-					 WMI_EVT_ID event_id)
+					 uint32_t event_id)
 {
 	uint32_t idx = 0;
+	uint32_t evt_id;
 
-	idx = wmi_unified_get_event_handler_ix(wmi_handle, event_id);
+#ifdef WMI_TLV_AND_NON_TLV_SUPPORT
+	if (event_id >= wmi_events_max ||
+		wmi_handle->wmi_events[event_id] == WMI_EVENT_ID_INVALID) {
+		qdf_print("%s: Event id %d is unavailable\n",
+				 __func__, event_id);
+		return QDF_STATUS_E_FAILURE;
+	}
+	evt_id = wmi_handle->wmi_events[event_id];
+#else
+	evt_id = event_id;
+#endif
+
+	idx = wmi_unified_get_event_handler_ix(wmi_handle, evt_id);
 	if (idx == -1) {
-		qdf_print("%s : event handler is not registered: event id 0x%x \n",
-		       __func__, event_id);
+		qdf_print("%s : event handler is not registered: evt id 0x%x\n",
+		       __func__, evt_id);
 		return QDF_STATUS_E_FAILURE;
 	}
 	wmi_handle->event_handler[idx] = NULL;
@@ -1046,6 +1111,7 @@ int wmi_unified_unregister_event_handler(wmi_unified_t wmi_handle,
  * wmi_process_fw_event_default_ctx() - process in default caller context
  * @wmi_handle: handle to wmi
  * @htc_packet: pointer to htc packet
+ * @exec_ctx: execution context for wmi fw event
  *
  * Event process by below function will be in default caller context.
  * wmi internally provides rx work thread processing context.
@@ -1058,8 +1124,13 @@ static void wmi_process_fw_event_default_ctx(struct wmi_unified *wmi_handle,
 	wmi_buf_t evt_buf;
 	evt_buf = (wmi_buf_t) htc_packet->pPktContext;
 
+#ifdef WMI_NON_TLV_SUPPORT
+	wmi_handle->rx_ops.wma_process_fw_event_handler_cbk
+		(wmi_handle->scn_handle, evt_buf, exec_ctx);
+#else
 	wmi_handle->rx_ops.wma_process_fw_event_handler_cbk(wmi_handle,
 					 evt_buf, exec_ctx);
+#endif
 
 	return;
 }
@@ -1086,10 +1157,12 @@ static void wmi_process_fw_event_worker_thread_ctx
 	id = WMI_GET_FIELD(qdf_nbuf_data(evt_buf), WMI_CMD_HDR, COMMANDID);
 	data = qdf_nbuf_data(evt_buf);
 
+#ifdef WMI_INTERFACE_EVENT_LOGGING
 	qdf_spin_lock_bh(&wmi_handle->wmi_record_lock);
 	/* Exclude 4 bytes of TLV header */
 	WMI_RX_EVENT_RECORD(id, ((uint8_t *) data + 4));
 	qdf_spin_unlock_bh(&wmi_handle->wmi_record_lock);
+#endif
 	qdf_spin_lock_bh(&wmi_handle->eventq_lock);
 	qdf_nbuf_queue_add(&wmi_handle->event_queue, evt_buf);
 	qdf_spin_unlock_bh(&wmi_handle->eventq_lock);
@@ -1166,7 +1239,9 @@ void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf)
 	uint8_t *data;
 	uint32_t len;
 	void *wmi_cmd_struct_ptr = NULL;
+#ifndef WMI_NON_TLV_SUPPORT
 	int tlv_ok_status = 0;
+#endif
 	uint32_t idx = 0;
 
 	id = WMI_GET_FIELD(qdf_nbuf_data(evt_buf), WMI_CMD_HDR, COMMANDID);
@@ -1177,16 +1252,21 @@ void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf)
 	data = qdf_nbuf_data(evt_buf);
 	len = qdf_nbuf_len(evt_buf);
 
-	/* Validate and pad(if necessary) the TLVs */
-	tlv_ok_status = wmitlv_check_and_pad_event_tlvs(wmi_handle->scn_handle,
+#ifndef WMI_NON_TLV_SUPPORT
+	if (wmi_handle->target_type == WMI_TLV_TARGET) {
+		/* Validate and pad(if necessary) the TLVs */
+		tlv_ok_status =
+			wmitlv_check_and_pad_event_tlvs(wmi_handle->scn_handle,
 							data, len, id,
 							&wmi_cmd_struct_ptr);
-	if (tlv_ok_status != 0) {
-		QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
-			"%s: Error: id=0x%d, wmitlv check status=%d\n",
-		       __func__, id, tlv_ok_status);
-		goto end;
+		if (tlv_ok_status != 0) {
+			QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_ERROR,
+				"%s: Error: id=0x%d, wmitlv check status=%d\n",
+				__func__, id, tlv_ok_status);
+			goto end;
+		}
 	}
+#endif
 
 	idx = wmi_unified_get_event_handler_ix(wmi_handle, id);
 	if (idx == A_ERROR) {
@@ -1206,12 +1286,19 @@ void __wmi_control_rx(struct wmi_unified *wmi_handle, wmi_buf_t evt_buf)
 	qdf_spin_unlock_bh(&wmi_handle->wmi_record_lock);
 #endif
 	/* Call the WMI registered event handler */
-	wmi_handle->event_handler[idx] (wmi_handle->scn_handle,
-					wmi_cmd_struct_ptr, len);
+	if (wmi_handle->target_type == WMI_TLV_TARGET)
+		wmi_handle->event_handler[idx] (wmi_handle->scn_handle,
+			wmi_cmd_struct_ptr, len);
+	else
+		wmi_handle->event_handler[idx] (wmi_handle->scn_handle,
+			data, len);
 
 end:
 	/* Free event buffer and allocated event tlv */
-	wmitlv_free_allocated_event_tlvs(id, &wmi_cmd_struct_ptr);
+#ifndef WMI_NON_TLV_SUPPORT
+	if (wmi_handle->target_type == WMI_TLV_TARGET)
+		wmitlv_free_allocated_event_tlvs(id, &wmi_cmd_struct_ptr);
+#endif
 	qdf_nbuf_free(evt_buf);
 
 }
@@ -1290,17 +1377,24 @@ void *wmi_unified_attach(void *scn_handle,
 			 bool use_cookie, struct wmi_rx_ops *rx_ops)
 {
 	struct wmi_unified *wmi_handle;
+
+#ifndef WMI_NON_TLV_SUPPORT
 	wmi_handle =
 		(struct wmi_unified *)os_malloc(NULL,
 				sizeof(struct wmi_unified),
 				GFP_ATOMIC);
+#else
+	wmi_handle =
+		(struct wmi_unified *) qdf_mem_malloc(
+			sizeof(struct wmi_unified));
+#endif
 	if (wmi_handle == NULL) {
 		qdf_print("allocation of wmi handle failed %zu\n",
 			sizeof(struct wmi_unified));
 		return NULL;
 	}
 	OS_MEMZERO(wmi_handle, sizeof(struct wmi_unified));
-	wmi_handle->scn_handle = (ol_scn_t *)scn_handle;
+	wmi_handle->scn_handle = scn_handle;
 	qdf_atomic_init(&wmi_handle->pending_cmds);
 	qdf_atomic_init(&wmi_handle->is_target_suspended);
 	wmi_runtime_pm_init(wmi_handle);
@@ -1317,13 +1411,15 @@ void *wmi_unified_attach(void *scn_handle,
 	/* Attach mc_thread context processing function */
 	wmi_handle->rx_ops.wma_process_fw_event_handler_cbk =
 				rx_ops->wma_process_fw_event_handler_cbk;
+	wmi_handle->target_type = target_type;
 	if (target_type == WMI_TLV_TARGET)
-		wmi_handle->ops = wmi_get_tlv_ops();
+		wmi_tlv_attach(wmi_handle);
 	else
-		wmi_handle->ops = wmi_get_non_tlv_ops();
+		wmi_non_tlv_attach(wmi_handle);
 	/* Assign target cookie capablity */
 	wmi_handle->use_cookie = use_cookie;
 	wmi_handle->osdev = osdev;
+	wmi_handle->wmi_stopinprogress = 0;
 	qdf_spinlock_create(&wmi_handle->ctx_lock);
 
 	return wmi_handle;
@@ -1385,10 +1481,19 @@ wmi_unified_remove_work(struct wmi_unified *wmi_handle)
 		"Done: %s", __func__);
 }
 
+/**
+ * wmi_htc_tx_complete() - Process htc tx completion
+ *
+ * @ctx: handle to wmi
+ * @htc_packet: pointer to htc packet
+ *
+ * @Return: none.
+ */
 void wmi_htc_tx_complete(void *ctx, HTC_PACKET *htc_pkt)
 {
 	struct wmi_unified *wmi_handle = (struct wmi_unified *)ctx;
 	wmi_buf_t wmi_cmd_buf = GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
+
 #ifdef WMI_INTERFACE_EVENT_LOGGING
 	uint32_t cmd_id;
 #endif
@@ -1481,7 +1586,7 @@ wmi_unified_connect_htc_service(struct wmi_unified *wmi_handle,
  */
 int wmi_get_host_credits(wmi_unified_t wmi_handle)
 {
-	int host_credits;
+	int host_credits = 0;
 
 	htc_get_control_endpoint_tx_host_credits(wmi_handle->htc_handle,
 						 &host_credits);
@@ -1489,7 +1594,8 @@ int wmi_get_host_credits(wmi_unified_t wmi_handle)
 }
 
 /**
- * wmi_get_pending_cmds() - WMI API to get WMI Pending Commands in the HTC queue
+ * wmi_get_pending_cmds() - WMI API to get WMI Pending Commands in the HTC
+ *                          queue
  *
  * @wmi_handle: handle to WMI.
  *
@@ -1513,3 +1619,30 @@ void wmi_set_target_suspend(wmi_unified_t wmi_handle, A_BOOL val)
 	qdf_atomic_set(&wmi_handle->is_target_suspended, val);
 }
 
+#ifdef WMI_NON_TLV_SUPPORT
+/**
+ * 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)
+{
+	htc_flush_endpoint(wmi_handle->htc_handle,
+		wmi_handle->wmi_endpoint_id, 0);
+}
+
+/**
+ * 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)
+{
+	QDF_TRACE(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_INFO,
+			"WMI Stop\n");
+	wmi_handle->wmi_stopinprogress = 1;
+	return 0;
+}
+#endif

wmi/src/wmi_unified_tlv.c

@@ -10510,12 +10510,11 @@ struct wmi_ops tlv_ops =  {
 };
 
 /**
- * wmi_get_tlv_ops() - gives pointer to wmi tlv ops
+ * wmi_tlv_attach() - Attach TLV APIs
  *
- * Return: pointer to wmi tlv ops
+ * Return: None
  */
-struct wmi_ops *wmi_get_tlv_ops(void)
+void wmi_tlv_attach(wmi_unified_t wmi_handle)
 {
-	return &tlv_ops;
+	wmi_handle->ops = &tlv_ops;
 }
-