Merge "qcacmn: Fix ppdu info release during detach"

dp/wifi3.0/dp_htt.c

@@ -110,7 +110,15 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
 	DP_STATS_UPD(peer, tx.rnd_avg_tx_rate, ppdu_tx_rate);
 
 	if (peer->vdev) {
-		if (peer->bss_peer) {
+		/*
+		 * In STA mode:
+		 *	We get ucast stats as BSS peer stats.
+		 *
+		 * In AP mode:
+		 *	We get mcast stats as BSS peer stats.
+		 *	We get ucast stats as assoc peer stats.
+		 */
+		if (peer->vdev->opmode == wlan_op_mode_ap && peer->bss_peer) {
 			peer->vdev->stats.tx.mcast_last_tx_rate = ratekbps;
 			peer->vdev->stats.tx.mcast_last_tx_rate_mcs = ppdu->mcs;
 		} else {

dp/wifi3.0/dp_main.c

@@ -1028,6 +1028,8 @@ void dp_print_ast_stats(struct dp_soc *soc)
 	DP_PRINT_STATS("	Entries Added   = %d", soc->stats.ast.added);
 	DP_PRINT_STATS("	Entries Deleted = %d", soc->stats.ast.deleted);
 	DP_PRINT_STATS("	Entries Agedout = %d", soc->stats.ast.aged_out);
+	DP_PRINT_STATS("	Entries MAP ERR  = %d", soc->stats.ast.map_err);
+
 	DP_PRINT_STATS("AST Table:");
 
 	qdf_spin_lock_bh(&soc->ast_lock);
@@ -3863,6 +3865,8 @@ static void dp_pdev_deinit(struct cdp_pdev *txrx_pdev, int force)
 
 	dp_htt_ppdu_stats_detach(pdev);
 
+	dp_tx_ppdu_stats_detach(pdev);
+
 	qdf_nbuf_free(pdev->sojourn_buf);
 
 	dp_cal_client_detach(&pdev->cal_client_ctx);
@@ -3920,8 +3924,6 @@ static void dp_pdev_detach(struct cdp_pdev *txrx_pdev, int force)
 
 	dp_mon_link_free(pdev);
 
-	dp_tx_ppdu_stats_detach(pdev);
-
 	/* Cleanup per PDEV REO rings if configured */
 	if (wlan_cfg_per_pdev_rx_ring(soc->wlan_cfg_ctx)) {
 		dp_srng_cleanup(soc, &soc->reo_dest_ring[pdev->pdev_id],
@@ -5091,6 +5093,10 @@ static void *dp_peer_create_wifi3(struct cdp_vdev *vdev_handle,
 		peer->ctrl_peer = ctrl_peer;
 
 		dp_local_peer_id_alloc(pdev, peer);
+
+		qdf_spinlock_create(&peer->peer_info_lock);
+		dp_peer_rx_bufq_resources_init(peer);
+
 		DP_STATS_INIT(peer);
 		DP_STATS_UPD(peer, rx.avg_rssi, INVALID_RSSI);
 

dp/wifi3.0/dp_peer.c

@@ -1089,10 +1089,22 @@ void dp_peer_ast_send_wds_del(struct dp_soc *soc,
 	ast_entry->delete_in_progress = true;
 }
 
-static void dp_peer_ast_free_entry(struct dp_soc *soc,
-				   struct dp_ast_entry *ast_entry)
+/**
+ * dp_peer_ast_free_entry_by_mac() - find ast entry by MAC address and delete
+ * @soc: soc handle
+ * @peer: peer handle
+ * @mac_addr: mac address of the AST entry to searc and delete
+ *
+ * find the ast entry from the peer list using the mac address and free
+ * the entry.
+ *
+ * Return: SUCCESS or NOENT
+ */
+static int dp_peer_ast_free_entry_by_mac(struct dp_soc *soc,
+					 struct dp_peer *peer,
+					 uint8_t *mac_addr)
 {
-	struct dp_peer *peer = ast_entry->peer;
+	struct dp_ast_entry *ast_entry;
 	void *cookie = NULL;
 	txrx_ast_free_cb cb = NULL;
 
@@ -1102,8 +1114,14 @@ static void dp_peer_ast_free_entry(struct dp_soc *soc,
 	 */
 
 	qdf_spin_lock_bh(&soc->ast_lock);
-	if (ast_entry->is_mapped)
+
+	ast_entry = dp_peer_ast_list_find(soc, peer, mac_addr);
+	if (!ast_entry) {
+		qdf_spin_unlock_bh(&soc->ast_lock);
+		return QDF_STATUS_E_NOENT;
+	} else if (ast_entry->is_mapped) {
 		soc->ast_table[ast_entry->ast_idx] = NULL;
+	}
 
 	TAILQ_REMOVE(&peer->ast_entry_list, ast_entry, ase_list_elem);
 	DP_STATS_INC(soc, ast.deleted, 1);
@@ -1117,6 +1135,7 @@ static void dp_peer_ast_free_entry(struct dp_soc *soc,
 	if (ast_entry == peer->self_ast_entry)
 		peer->self_ast_entry = NULL;
 
+	soc->num_ast_entries--;
 	qdf_spin_unlock_bh(&soc->ast_lock);
 
 	if (cb) {
@@ -1126,7 +1145,8 @@ static void dp_peer_ast_free_entry(struct dp_soc *soc,
 		   CDP_TXRX_AST_DELETED);
 	}
 	qdf_mem_free(ast_entry);
-	soc->num_ast_entries--;
+
+	return QDF_STATUS_SUCCESS;
 }
 
 struct dp_peer *dp_peer_find_hash_find(struct dp_soc *soc,
@@ -1448,19 +1468,51 @@ dp_rx_peer_map_handler(void *soc_handle, uint16_t peer_id,
 		  peer_mac_addr[2], peer_mac_addr[3], peer_mac_addr[4],
 		  peer_mac_addr[5], vdev_id);
 
-	if ((hw_peer_id < 0) ||
-	    (hw_peer_id >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) {
-		QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
-			"invalid hw_peer_id: %d", hw_peer_id);
-		qdf_assert_always(0);
-	}
-
 	/* Peer map event for WDS ast entry get the peer from
 	 * obj map
 	 */
 	if (is_wds) {
 		peer = soc->peer_id_to_obj_map[peer_id];
+		/*
+		 * In certain cases like Auth attack on a repeater
+		 * can result in the number of ast_entries falling
+		 * in the same hash bucket to exceed the max_skid
+		 * length supported by HW in root AP. In these cases
+		 * the FW will return the hw_peer_id (ast_index) as
+		 * 0xffff indicating HW could not add the entry in
+		 * its table. Host has to delete the entry from its
+		 * table in these cases.
+		 */
+		if (hw_peer_id == HTT_INVALID_PEER) {
+			DP_STATS_INC(soc, ast.map_err, 1);
+			if (!dp_peer_ast_free_entry_by_mac(soc,
+							   peer,
+							   peer_mac_addr))
+				return;
+
+			dp_alert("AST entry not found with peer %pK peer_id %u peer_mac %pM mac_addr %pM vdev_id %u next_hop %u",
+				 peer, peer->peer_ids[0],
+				 peer->mac_addr.raw, peer_mac_addr, vdev_id,
+				 is_wds);
+
+			return;
+		}
+
 	} else {
+		/*
+		 * It's the responsibility of the CP and FW to ensure
+		 * that peer is created successfully. Ideally DP should
+		 * not hit the below condition for directly assocaited
+		 * peers.
+		 */
+		if ((hw_peer_id < 0) ||
+		    (hw_peer_id >=
+		     wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) {
+			QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
+				  "invalid hw_peer_id: %d", hw_peer_id);
+			qdf_assert_always(0);
+		}
+
 		peer = dp_peer_find_add_id(soc, peer_mac_addr, peer_id,
 					   hw_peer_id, vdev_id);
 
@@ -1515,7 +1567,6 @@ dp_rx_peer_unmap_handler(void *soc_handle, uint16_t peer_id,
 			 uint8_t is_wds)
 {
 	struct dp_peer *peer;
-	struct dp_ast_entry *ast_entry;
 	struct dp_soc *soc = (struct dp_soc *)soc_handle;
 	uint8_t i;
 
@@ -1534,16 +1585,8 @@ dp_rx_peer_unmap_handler(void *soc_handle, uint16_t peer_id,
 	/* If V2 Peer map messages are enabled AST entry has to be freed here
 	 */
 	if (soc->is_peer_map_unmap_v2 && is_wds) {
-
-		qdf_spin_lock_bh(&soc->ast_lock);
-		ast_entry = dp_peer_ast_list_find(soc, peer,
-						  mac_addr);
-		qdf_spin_unlock_bh(&soc->ast_lock);
-
-		if (ast_entry) {
-			dp_peer_ast_free_entry(soc, ast_entry);
+		if (!dp_peer_ast_free_entry_by_mac(soc, peer, mac_addr))
 			return;
-		}
 
 		dp_alert("AST entry not found with peer %pK peer_id %u peer_mac %pM mac_addr %pM vdev_id %u next_hop %u",
 			 peer, peer->peer_ids[0],

dp/wifi3.0/dp_stats.c

@@ -5260,7 +5260,7 @@ dp_print_pdev_tx_stats(struct dp_pdev *pdev)
 		       pdev->stats.tx.dropped.age_out);
 	DP_PRINT_STATS("	headroom insufficient = %d",
 		       pdev->stats.tx_i.dropped.headroom_insufficient);
-	DP_PRINT_STATS("	Multicast:");
+	DP_PRINT_STATS("Multicast:");
 	DP_PRINT_STATS("	Packets: %u",
 		       pdev->stats.tx.mcast.num);
 	DP_PRINT_STATS("	Bytes: %llu",

dp/wifi3.0/dp_tx.c

@@ -3090,12 +3090,7 @@ void dp_tx_comp_process_tx_status(struct dp_tx_desc_s *tx_desc,
 		goto out;
 	}
 
-	if (qdf_likely(!peer->bss_peer)) {
-		DP_STATS_INC_PKT(peer, tx.ucast, 1, length);
-
-		if (ts->status == HAL_TX_TQM_RR_FRAME_ACKED)
-			DP_STATS_INC_PKT(peer, tx.tx_success, 1, length);
-	} else {
+	if (qdf_unlikely(peer->bss_peer && vdev->opmode == wlan_op_mode_ap)) {
 		if (ts->status != HAL_TX_TQM_RR_REM_CMD_REM) {
 			DP_STATS_INC_PKT(peer, tx.mcast, 1, length);
 
@@ -3105,6 +3100,10 @@ void dp_tx_comp_process_tx_status(struct dp_tx_desc_s *tx_desc,
 				DP_STATS_INC_PKT(peer, tx.bcast, 1, length);
 			}
 		}
+	} else {
+		DP_STATS_INC_PKT(peer, tx.ucast, 1, length);
+		if (ts->status == HAL_TX_TQM_RR_FRAME_ACKED)
+			DP_STATS_INC_PKT(peer, tx.tx_success, 1, length);
 	}
 
 	dp_tx_update_peer_stats(tx_desc, ts, peer, ring_id);

dp/wifi3.0/dp_types.h

@@ -644,6 +644,7 @@ struct dp_soc_stats {
 		uint32_t added;
 		uint32_t deleted;
 		uint32_t aged_out;
+		uint32_t map_err;
 	} ast;
 
 	/* SOC level TX stats */

hif/inc/hif.h

@@ -118,12 +118,6 @@ struct CE_state;
 #define HIF_MAX_GROUP 8
 #endif
 
-#ifdef CONFIG_SLUB_DEBUG_ON
-#ifndef CONFIG_WIN
-#define HIF_CONFIG_SLUB_DEBUG_ON
-#endif
-#endif
-
 #ifndef NAPI_YIELD_BUDGET_BASED
 #ifdef HIF_CONFIG_SLUB_DEBUG_ON
 #define QCA_NAPI_DEF_SCALE_BIN_SHIFT 1

hif/src/ce/ce_main.c

@@ -37,9 +37,6 @@
 #include "ce_reg.h"
 #include "ce_assignment.h"
 #include "ce_tasklet.h"
-#ifndef CONFIG_WIN
-#include "qwlan_version.h"
-#endif
 #include "qdf_module.h"
 
 #define CE_POLL_TIMEOUT 10      /* ms */
@@ -2973,8 +2970,7 @@ int hif_wlan_enable(struct hif_softc *scn)
 	if (BYPASS_QMI)
 		return 0;
 	else
-		return pld_wlan_enable(scn->qdf_dev->dev, &cfg,
-				       mode, QWLAN_VERSIONSTR);
+		return pld_wlan_enable(scn->qdf_dev->dev, &cfg, mode);
 }
 
 #ifdef WLAN_FEATURE_EPPING

hif/src/ce/ce_main.h

@@ -76,10 +76,6 @@ enum ce_target_type {
 	CE_MAX_TARGET_TYPE
 };
 
-#ifdef CONFIG_WIN
-#define QWLAN_VERSIONSTR "WIN"
-#endif
-
 enum ol_ath_hif_pkt_ecodes {
 	HIF_PIPE_NO_RESOURCE = 0
 };

hif/src/usb/if_usb.c

@@ -26,7 +26,6 @@
 #include "hif_debug.h"
 #include "epping_main.h"
 #include "hif_main.h"
-#include "qwlan_version.h"
 #include "usb_api.h"
 
 #define DELAY_FOR_TARGET_READY 200	/* 200ms */
@@ -532,8 +531,7 @@ int hif_usb_bus_configure(struct hif_softc *scn)
 	else
 		mode = PLD_MISSION;
 
-	return pld_wlan_enable(scn->qdf_dev->dev, &cfg,
-			       mode, QWLAN_VERSIONSTR);
+	return pld_wlan_enable(scn->qdf_dev->dev, &cfg, mode);
 }
 #else
 /**
@@ -706,7 +704,6 @@ void hif_usb_ramdump_handler(struct hif_opaque_softc *scn)
 
 	if (pattern == FW_ASSERT_PATTERN) {
 		HIF_ERROR("Firmware crash detected...\n");
-		HIF_ERROR("Host SW version: %s\n", QWLAN_VERSIONSTR);
 		HIF_ERROR("target_type: %d.target_version %d. target_revision%d.",
 			tgt_info->target_type,
 			tgt_info->target_version,

htc/htc.c

@@ -45,7 +45,7 @@ ATH_DEBUG_INSTANTIATE_MODULE_VAR(htc,
 
 #endif
 
-#if (defined(CONFIG_MCL) || defined(QCA_WIFI_QCA8074) || \
+#if (defined(WMI_MULTI_MAC_SVC) || defined(QCA_WIFI_QCA8074) || \
 	defined(QCA_WIFI_QCA6018))
 static const uint32_t svc_id[] = {WMI_CONTROL_SVC, WMI_CONTROL_SVC_WMAC1,
 						WMI_CONTROL_SVC_WMAC2};

htc/htc_send.c

@@ -1139,14 +1139,6 @@ static enum HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target,
 		return result;
 	}
 
-	if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) {
-		tx_resources =
-			hif_get_free_queue_number(target->hif_dev,
-						  pEndpoint->UL_PipeID);
-	} else {
-		tx_resources = 0;
-	}
-
 	LOCK_HTC_TX(target);
 
 	if (!HTC_QUEUE_EMPTY(&sendQueue)) {
@@ -1185,6 +1177,14 @@ static enum HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target,
 	/* now drain the endpoint TX queue for transmission as long as we have
 	 * enough transmit resources
 	 */
+	if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) {
+		tx_resources =
+			hif_get_free_queue_number(target->hif_dev,
+						  pEndpoint->UL_PipeID);
+	} else {
+		tx_resources = 0;
+	}
+
 	while (true) {
 
 		if (HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue) == 0)

target_if/crypto/src/target_if_crypto.c

@@ -118,7 +118,7 @@ QDF_STATUS target_if_crypto_set_key(struct wlan_objmgr_vdev *vdev,
 	struct cdp_peer *peer = NULL;
 	uint8_t peer_id;
 	uint8_t def_tx_idx;
-	void *pdev_wmi_handle;
+	wmi_unified_t pdev_wmi_handle;
 	bool pairwise;
 	QDF_STATUS status;
 

target_if/dfs/src/target_if_dfs.c

@@ -285,7 +285,7 @@ static QDF_STATUS target_if_dfs_set_phyerr_filter_offload(
 					bool dfs_phyerr_filter_offload)
 {
 	QDF_STATUS status;
-	void *wmi_handle;
+	wmi_unified_t wmi_handle;
 
 	if (!pdev) {
 		target_if_err("null pdev");

target_if/green_ap/src/target_if_green_ap.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -140,7 +140,7 @@ QDF_STATUS target_if_green_ap_enable_egap(
 		struct wlan_green_ap_egap_params *egap_params)
 {
 	struct wlan_pdev_green_ap_ctx *green_ap_ctx;
-	void *wmi_hdl;
+	wmi_unified_t wmi_hdl;
 
 	if (!pdev) {
 		green_ap_err("pdev context passed is NULL");
@@ -175,7 +175,7 @@ QDF_STATUS target_if_green_ap_enable_egap(
 QDF_STATUS target_if_green_ap_set_ps_on_off(struct wlan_objmgr_pdev *pdev,
 					    bool value, uint8_t pdev_id)
 {
-	void *wmi_hdl;
+	wmi_unified_t wmi_hdl;
 
 	if (!pdev) {
 		green_ap_err("pdev context passed is NULL");

target_if/init_deinit/inc/service_ready_util.h

@@ -117,7 +117,8 @@ int init_deinit_populate_service_bitmap(void *wmi_handle, uint8_t *event,
  *
  * Return: zero on successful population of fw_version command or failure flag
  */
-int init_deinit_populate_fw_version_cmd(void *wmi_handle, uint8_t *event);
+int
+init_deinit_populate_fw_version_cmd(wmi_unified_t wmi_handle, uint8_t *event);
 
 /**
  * init_deinit_populate_target_cap() - populate target cap

target_if/init_deinit/src/service_ready_util.c

@@ -142,7 +142,8 @@ int init_deinit_populate_service_bitmap(void *wmi_handle, uint8_t *event,
 	return 0;
 }
 
-int init_deinit_populate_fw_version_cmd(void *wmi_handle, uint8_t *event)
+int init_deinit_populate_fw_version_cmd(wmi_unified_t wmi_handle,
+					uint8_t *event)
 {
 	QDF_STATUS status;
 

target_if/scan/src/target_if_scan.c

@@ -378,7 +378,7 @@ QDF_STATUS
 target_if_scan_start(struct wlan_objmgr_pdev *pdev,
 		struct scan_start_request *req)
 {
-	void *pdev_wmi_handle;
+	wmi_unified_t pdev_wmi_handle;
 
 	pdev_wmi_handle = GET_WMI_HDL_FROM_PDEV(pdev);
 	if (!pdev_wmi_handle) {
@@ -392,7 +392,7 @@ QDF_STATUS
 target_if_scan_cancel(struct wlan_objmgr_pdev *pdev,
 		struct scan_cancel_param *req)
 {
-	void *pdev_wmi_handle;
+	wmi_unified_t pdev_wmi_handle;
 
 	pdev_wmi_handle = GET_WMI_HDL_FROM_PDEV(pdev);
 	if (!pdev_wmi_handle) {

target_if/wifi_pos/src/target_if_wifi_pos.c

@@ -269,7 +269,7 @@ static QDF_STATUS wifi_pos_oem_data_req(struct wlan_objmgr_psoc *psoc,
 					struct oem_data_req *req)
 {
 	QDF_STATUS status;
-	void *wmi_hdl = GET_WMI_HDL_FROM_PSOC(psoc);
+	wmi_unified_t wmi_hdl = GET_WMI_HDL_FROM_PSOC(psoc);
 
 	target_if_debug("Send oem data req to target");
 
@@ -564,7 +564,7 @@ static QDF_STATUS target_if_wifi_pos_cfg_fw(struct wlan_objmgr_psoc *psoc,
 {
 	uint8_t i;
 	QDF_STATUS status;
-	void *wmi_hdl = GET_WMI_HDL_FROM_PSOC(psoc);
+	wmi_unified_t wmi_hdl = GET_WMI_HDL_FROM_PSOC(psoc);
 	wmi_oem_dma_ring_cfg_req_fixed_param cfg = {0};
 
 	if (!wmi_hdl) {

umac/cmn_services/obj_mgr/inc/wlan_objmgr_cmn.h

@@ -235,7 +235,25 @@ typedef void (*wlan_objmgr_peer_status_handler)(
  * @WLAN_CFR_ID:                CFG Capture method
  * @WLAN_VDEV_TARGET_IF_ID:     Target interface layer
  * @WLAN_RX_PKT_TAG_ID:         RX protocol tag operations
- * @WLAN_INTEROP_ISSUES_AP_ID:           interop issues ap operation
+ * @WLAN_INTEROP_ISSUES_AP_ID:  interop issues ap operation
+ * @WLAN_WDS_ID:                WDS operations
+ * @WLAN_PROXY_ARP_ID:          AP proxy ARP
+ * @WLAN_WNM_ID:                wireless network management operations
+ * @WLAN_RRM_ID:                Radio resource management operations
+ * @WLAN_TR69_ID:               TR69 operations
+ * @WLAN_MGMT_RX_ID:            Legacy offload management frame input handler
+ * @WLAN_MGMT_TX_ID:            Legacy offload management frame output handler
+ * @WLAN_NSS_IF_ID:             NSS offload interface operations
+ * @WLAN_MBO_ID:                MBO operations
+ * @WLAN_RTT_ID:                RTT operations
+ * @WLAN_ALD_ID:                Ath Link Diagnostic operations
+ * @WLAN_ME_ID:                 Multicast enhancement operations
+ * @WLAN_MGMT_HANDLER_ID:       Management frame handler
+ * @WLAN_MLME_HANDLER_ID:       MLME handler
+ * @WLAN_DBDC_ID:               Dual Band Dual Concurrent mode operations
+ * @WLAN_MLME_OBJMGR_ID:        MLME object manager operations VAP, Node
+ * @WLAN_OFFCHAN_TX_ID:         Offchannel Tx operations
+ * @WLAN_MISC_ID:               power manager, PAPI, rate set, etc.
  * @WLAN_REF_ID_MAX:            Max id used to generate ref count tracking array
  */
  /* New value added to the enum must also be reflected in function
@@ -294,6 +312,24 @@ typedef enum {
 	WLAN_VDEV_TARGET_IF_ID     = 49,
 	WLAN_RX_PKT_TAG_ID         = 50,
 	WLAN_INTEROP_ISSUES_AP_ID           = 51,
+	WLAN_WDS_ID           = 52,
+	WLAN_PROXY_ARP_ID     = 53,
+	WLAN_WNM_ID           = 54,
+	WLAN_RRM_ID           = 55,
+	WLAN_TR69_ID          = 56,
+	WLAN_MGMT_RX_ID       = 57,
+	WLAN_MGMT_TX_ID       = 58,
+	WLAN_NSS_IF_ID        = 59,
+	WLAN_MBO_ID           = 60,
+	WLAN_RTT_ID           = 61,
+	WLAN_ALD_ID           = 62,
+	WLAN_ME_ID            = 63,
+	WLAN_MGMT_HANDLER_ID  = 64,
+	WLAN_MLME_HANDLER_ID  = 65,
+	WLAN_DBDC_ID          = 66,
+	WLAN_MLME_OBJMGR_ID   = 67,
+	WLAN_OFFCHAN_TX_ID    = 68,
+	WLAN_MISC_ID          = 69,
 	WLAN_REF_ID_MAX,
 } wlan_objmgr_ref_dbgid;
 
@@ -359,6 +395,24 @@ static inline char *string_from_dbgid(wlan_objmgr_ref_dbgid id)
 					"WLAN_VDEV_TARGET_IF_ID",
 					"WLAN_RX_PKT_TAG_ID",
 					"WLAN_INTEROP_ISSUES_AP_ID",
+					"WLAN_WDS_ID",
+					"WLAN_PROXY_ARP_ID",
+					"WLAN_WNM_ID",
+					"WLAN_RRM_ID",
+					"WLAN_TR69_ID",
+					"WLAN_MGMT_RX_ID",
+					"WLAN_MGMT_TX_ID",
+					"WLAN_NSS_IF_ID",
+					"WLAN_MBO_ID",
+					"WLAN_RTT_ID",
+					"WLAN_ALD_ID",
+					"WLAN_ME_ID",
+					"WLAN_MGMT_HANDLER_ID",
+					"WLAN_MLME_HANDLER_ID",
+					"WLAN_DBDC_ID",
+					"WLAN_MLME_OBJMGR_ID",
+					"WLAN_OFFCHAN_TX_ID",
+					"WLAN_MISC_ID",
 					"WLAN_REF_ID_MAX"};
 
 	return (char *)strings[id];

umac/cmn_services/serialization/inc/wlan_serialization_api.h

@@ -159,7 +159,37 @@ typedef QDF_STATUS (*wlan_ser_umac_cmd_cb)(void *umac_cmd);
 
 /**
  * enum wlan_umac_cmd_id - Command Type
- * @WLAN_SER_CMD_SCAN:     Scan command
+ * @WLAN_SER_CMD_SCAN: Scan command
+ * @WLAN_SER_CMD_NONSCAN: Non-scan command
+ * @WLAN_SER_CMD_HDD_ISSUE_REASSOC_SAME_AP: HDD Reassoc cmd
+ * @WLAN_SER_CMD_SME_ISSUE_REASSOC_SAME_AP: SME Reassoc cmd
+ * @WLAN_SER_CMD_SME_ISSUE_DISASSOC_FOR_HANDOFF: SME Disassoc cmd
+ * @WLAN_SER_CMD_SME_ISSUE_ASSOC_TO_SIMILAR_AP: SME Assoc cmd
+ * @WLAN_SER_CMD_FORCE_IBSS_LEAVE: IBSS leave AP cmd
+ * @WLAN_SER_CMD_SME_ISSUE_FT_REASSOC: SME reassoc cmd
+ * @WLAN_SER_CMD_FORCE_DISASSOC_STA: Force diassoc for STA vap
+ * @WLAN_SER_CMD_FORCE_DEAUTH_STA: Force deauth for STA vap
+ * @WLAN_SER_CMD_PERFORM_PRE_AUTH: Pre auth ops cmd
+ * @WLAN_SER_CMD_WM_STATUS_CHANGE: WM status modification cmd
+ * @WLAN_SER_CMD_NDP_INIT_REQ: NDP init request cmd
+ * @WLAN_SER_CMD_NDP_RESP_REQ: NDP response to request cmd
+ * @WLAN_SER_CMD_NDP_DATA_END_INIT_REQ: NDP data end init request
+ * @WLAN_SER_CMD_NDP_END_ALL_REQ: NDP close all request
+ * @WLAN_SER_CMD_ADDTS: ADD Ts cmd
+ * @WLAN_SER_CMD_DELTS: Del Ts cmd
+ * @WLAN_SER_CMD_TDLS_SEND_MGMT: TDLS mgmt send cmd
+ * @WLAN_SER_CMD_TDLS_ADD_PEER: TDLS cmd to add peer
+ * @WLAN_SER_CMD_TDLS_DEL_PEER: TDLS cmd to del peer
+ * @WLAN_SER_CMD_SET_HW_MODE: Cmd to set hardware mode change
+ * @WLAN_SER_CMD_NSS_UPDATE: Cmd to update NSS config
+ * @WLAN_SER_CMD_SET_DUAL_MAC_CONFIG: Cmd to set dual mac
+ * @WLAN_SER_CMD_SET_ANTENNA_MODE: Set antenna mode
+ * @WLAN_SER_CMD_DEL_STA_SESSION: Cmd to del STA session
+ * @WLAN_SER_CMD_VDEV_START_BSS: Cmd to start a AP VDEV
+ * @WLAN_SER_CMD_VDEV_STOP_BSS: Cmd to stop a AP VDEV
+ * @WLAN_SER_CMD_VDEV_CONNECT: Cmd to start a STA VDEV
+ * @WLAN_SER_CMD_VDEV_DISCONNECT: Cmd to stop a STA VDEV
+ * @WLAN_SER_CMD_VDEV_RESTART: Cmd to restart a VDEV
  */
 enum wlan_serialization_cmd_type {
 	/* all scan command before non-scan */

umac/regulatory/core/src/reg_opclass.c

@@ -217,7 +217,13 @@ void reg_dmn_print_channels_in_opclass(uint8_t *country, uint8_t op_class)
 	uint16_t i = 0;
 
 	class = reg_get_class_from_country(country);
-	while (class && class->op_class) {
+
+	if (!class) {
+		reg_err("class is NULL");
+		return;
+	}
+
+	while (class->op_class) {
 		if (class->op_class == op_class) {
 			for (i = 0;
 			     (i < REG_MAX_CHANNELS_PER_OPERATING_CLASS &&

wmi/inc/wmi_unified_api.h

@@ -483,9 +483,11 @@ QDF_STATUS wmi_unified_vdev_delete_send(void *wmi_hdl,
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-QDF_STATUS wmi_unified_vdev_nss_chain_params_send(void *wmi_hdl,
-			uint8_t vdev_id,
-			struct vdev_nss_chains *nss_chains_user_cfg);
+QDF_STATUS
+wmi_unified_vdev_nss_chain_params_send(
+		wmi_unified_t wmi_handle,
+		uint8_t vdev_id,
+		struct vdev_nss_chains *nss_chains_user_cfg);
 
 QDF_STATUS wmi_unified_vdev_stop_send(void *wmi_hdl,
 					uint8_t vdev_id);
@@ -509,199 +511,607 @@ QDF_STATUS wmi_unified_vdev_start_send(void *wmi_hdl,
 QDF_STATUS wmi_unified_vdev_set_nac_rssi_send(void *wmi_hdl,
 			struct vdev_scan_nac_rssi_params *req);
 
-QDF_STATUS wmi_unified_hidden_ssid_vdev_restart_send(void *wmi_hdl,
+/**
+ * wmi_unified_hidden_ssid_vdev_restart_send() - restart vdev to set hidden ssid
+ * @wmi_handle: wmi handle
+ * @restart_params: vdev restart params
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_hidden_ssid_vdev_restart_send(
+		wmi_unified_t wmi_handle,
 		struct hidden_ssid_vdev_restart_params *restart_params);
 
-QDF_STATUS wmi_unified_vdev_set_param_send(void *wmi_hdl,
+/**
+ * wmi_unified_vdev_set_param_send() - WMI vdev set parameter function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to hold vdev set parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_vdev_set_param_send(wmi_unified_t wmi_handle,
 				struct vdev_set_params *param);
 
-QDF_STATUS wmi_unified_sifs_trigger_send(void *wmi_hdl,
+/**
+ * wmi_unified_sifs_trigger_send() - WMI vdev sifs trigger parameter function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to hold sifs trigger parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_sifs_trigger_send(wmi_unified_t wmi_handle,
 					 struct sifs_trigger_param *param);
 
-QDF_STATUS wmi_unified_peer_delete_send(void *wmi_hdl,
-				    uint8_t
-				    peer_addr[QDF_MAC_ADDR_SIZE],
-				    uint8_t vdev_id);
+/**
+ * wmi_unified_peer_delete_send() - send PEER delete command to fw
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac addr
+ * @vdev_id: vdev id
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_peer_delete_send(wmi_unified_t wmi_handle,
+			     uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
+			     uint8_t vdev_id);
 
-QDF_STATUS wmi_unified_peer_flush_tids_send(void *wmi_hdl,
-					 uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
-					 struct peer_flush_params *param);
+/**
+ * wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac address
+ * @param: pointer to hold peer flush tid parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_peer_flush_tids_send(wmi_unified_t wmi_handle,
+				 uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
+				 struct peer_flush_params *param);
 
-QDF_STATUS wmi_set_peer_param_send(void *wmi_hdl,
-				uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
-				struct peer_set_params *param);
+/**
+ * wmi_set_peer_param() - set peer parameter in fw
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac address
+ * @param: pointer to hold peer set parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_set_peer_param_send(wmi_unified_t wmi_handle,
+			uint8_t peer_addr[QDF_MAC_ADDR_SIZE],
+			struct peer_set_params *param);
 
-QDF_STATUS wmi_unified_peer_create_send(void *wmi_hdl,
+/**
+ * wmi_unified_peer_create_send() - send peer create command to fw
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac address
+ * @peer_type: peer type
+ * @vdev_id: vdev id
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_peer_create_send(wmi_unified_t wmi_handle,
 					struct peer_create_params *param);
 
 QDF_STATUS wmi_unified_stats_request_send(wmi_unified_t wmi_handle,
 					  uint8_t macaddr[QDF_MAC_ADDR_SIZE],
 					  struct stats_request_params *param);
 
-QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl,
+/**
+ * wmi_unified_green_ap_ps_send() - enable green ap powersave command
+ * @wmi_handle: wmi handle
+ * @value: value
+ * @pdev_id: pdev id to have radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_green_ap_ps_send(wmi_unified_t wmi_handle,
 					uint32_t value, uint8_t pdev_id);
 
-QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl,
-				struct wow_cmd_params *param,
-				uint8_t mac_id);
+/**
+ * wmi_unified_wow_enable_send() - WMI wow enable function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to hold wow enable parameter
+ * @mac_id: radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_wow_enable_send(wmi_unified_t wmi_handle,
+				       struct wow_cmd_params *param,
+				       uint8_t mac_id);
 
-QDF_STATUS wmi_unified_wow_wakeup_send(void *wmi_hdl);
+/**
+ * wmi_unified_wow_wakeup_send() - WMI wow wakeup function
+ * @wmi_handle: handle to WMI.
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_wow_wakeup_send(wmi_unified_t wmi_handle);
 
-QDF_STATUS wmi_unified_wow_add_wakeup_event_send(void *wmi_hdl,
-		struct wow_add_wakeup_params *param);
+/**
+ * wmi_unified_wow_add_wakeup_event_send() - WMI wow wakeup function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to wow wakeup event parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_wow_add_wakeup_event_send(wmi_unified_t wmi_handle,
+				      struct wow_add_wakeup_params *param);
 
-QDF_STATUS wmi_unified_wow_add_wakeup_pattern_send(void *wmi_hdl,
+/**
+ * wmi_unified_wow_add_wakeup_pattern_send() - WMI wow wakeup pattern function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to wow wakeup pattern parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_wow_add_wakeup_pattern_send(
+		wmi_unified_t wmi_handle,
 		struct wow_add_wakeup_pattern_params *param);
 
-QDF_STATUS wmi_unified_wow_remove_wakeup_pattern_send(void *wmi_hdl,
+/**
+ * wmi_unified_wow_remove_wakeup_pattern_send() - wow wakeup pattern function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to wow wakeup pattern parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_wow_remove_wakeup_pattern_send(
+		wmi_unified_t wmi_handle,
 		struct wow_remove_wakeup_pattern_params *param);
 
 /**
- *  wmi_unified_packet_log_enable_send() - WMI request stats function
- *  @param wmi_handle : handle to WMI.
- *  @param PKTLOG_EVENT : PKTLOG Event
- *  @param mac_id : MAC id corresponds to pdev id
+ * wmi_unified_packet_log_enable_send() - WMI request stats function
+ * @wmi_handle : handle to WMI.
+ * @PKTLOG_EVENT : PKTLOG Event
+ * @mac_id : MAC id corresponds to pdev id
  *
- *  Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl,
-			WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id);
+QDF_STATUS
+wmi_unified_packet_log_enable_send(wmi_unified_t wmi_handle,
+				   WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT,
+				   uint8_t mac_id);
 
 /**
- *  wmi_unified_peer_based_pktlog_send() - WMI request enable peer
- *  based filtering
- *  @wmi_handle: handle to WMI.
- *  @macaddr: PEER mac address to be filtered
- *  @mac_id: Mac id
- *  @enb_dsb: Enable or Disable peer based pktlog
- *            filtering
+ * wmi_unified_peer_based_pktlog_send() - WMI request enable peer
+ * based filtering
+ * @wmi_handle: handle to WMI.
+ * @macaddr: PEER mac address to be filtered
+ * @mac_id: Mac id
+ * @enb_dsb: Enable or Disable peer based pktlog
+ *           filtering
  *
- *  Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-QDF_STATUS wmi_unified_peer_based_pktlog_send(void *wmi_hdl,
+QDF_STATUS wmi_unified_peer_based_pktlog_send(wmi_unified_t wmi_handle,
 					      uint8_t *macaddr,
 					      uint8_t mac_id,
 					      uint8_t enb_dsb);
 
-QDF_STATUS wmi_unified_packet_log_disable_send(void *wmi_hdl, uint8_t mac_id);
+/**
+ * wmi_unified_packet_log_disable__send() - WMI pktlog disable function
+ * @wmi_handle: handle to WMI.
+ * @PKTLOG_EVENT: packet log event
+ *
+ * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_packet_log_disable_send(wmi_unified_t wmi_handle,
+					       uint8_t mac_id);
 
-QDF_STATUS wmi_unified_suspend_send(void *wmi_hdl,
-				struct suspend_params *param,
-				uint8_t mac_id);
+/**
+ * wmi_unified_suspend_send() - WMI suspend function
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to hold suspend parameter
+ * @mac_id: radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_suspend_send(wmi_unified_t wmi_handle,
+				    struct suspend_params *param,
+				    uint8_t mac_id);
 
-QDF_STATUS wmi_unified_resume_send(void *wmi_hdl,
-				uint8_t mac_id);
+/**
+ * wmi_unified_resume_send - WMI resume function
+ * @wmi_handle      : handle to WMI.
+ * @mac_id: radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_resume_send(wmi_unified_t wmi_handle,
+				   uint8_t mac_id);
 
+/**
+ * wmi_unified_pdev_param_send() - set pdev parameters
+ * @wmi_handle: wmi handle
+ * @param: pointer to pdev parameter
+ * @mac_id: radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
+ *         errno on failure
+ */
 QDF_STATUS
-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);
+wmi_unified_pdev_param_send(wmi_unified_t wmi_handle,
+			    struct pdev_params *param,
+			    uint8_t mac_id);
 
+/**
+ * wmi_unified_beacon_tmpl_send_cmd() - WMI beacon send function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to hold beacon send cmd parameter
+ *
+ * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_beacon_tmpl_send_cmd(wmi_unified_t wmi_handle,
+				 struct beacon_tmpl_params *param);
 
-QDF_STATUS wmi_unified_peer_assoc_send(void *wmi_hdl,
-				struct peer_assoc_params *param);
+/**
+ * wmi_unified_peer_assoc_send() - WMI peer assoc function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to peer assoc parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_peer_assoc_send(wmi_unified_t wmi_handle,
+				       struct peer_assoc_params *param);
 
-QDF_STATUS wmi_unified_sta_ps_cmd_send(void *wmi_hdl,
-				struct sta_ps_params *param);
+/**
+ * wmi_unified_sta_ps_cmd_send() - set sta powersave parameters
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac address
+ * @param: pointer to sta_ps parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_sta_ps_cmd_send(wmi_unified_t wmi_handle,
+				       struct sta_ps_params *param);
 
-QDF_STATUS wmi_unified_ap_ps_cmd_send(void *wmi_hdl,
-				uint8_t macaddr[QDF_MAC_ADDR_SIZE],
-				struct ap_ps_params *param);
+/**
+ * wmi_unified_ap_ps_cmd_send() - set ap powersave parameters
+ * @wmi_handle: wmi handle
+ * @peer_addr: peer mac address
+ * @param: pointer to ap_ps parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_ap_ps_cmd_send(wmi_unified_t wmi_handle,
+				      uint8_t macaddr[QDF_MAC_ADDR_SIZE],
+				      struct ap_ps_params *param);
 
-QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl,
+/**
+ * wmi_unified_scan_start_cmd_send() - WMI scan start function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to hold scan start cmd parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_scan_start_cmd_send(wmi_unified_t wmi_handle,
 				struct scan_req_params *param);
 
-QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl,
-				struct scan_cancel_param *param);
+/**
+ * wmi_unified_scan_stop_cmd_send() - WMI scan start function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to hold scan start cmd parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_scan_stop_cmd_send(wmi_unified_t wmi_handle,
+			       struct scan_cancel_param *param);
 
-QDF_STATUS wmi_unified_scan_chan_list_cmd_send(void *wmi_hdl,
-				struct scan_chan_list_params *param);
+/**
+ * wmi_unified_scan_chan_list_cmd_send() - WMI scan channel list function
+ * @wmi_handle: handle to WMI.
+ * @macaddr: MAC address
+ * @param: pointer to hold scan channel list parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_scan_chan_list_cmd_send(wmi_unified_t wmi_handle,
+				    struct scan_chan_list_params *param);
 
 
-QDF_STATUS wmi_crash_inject(void *wmi_hdl,
-				struct crash_inject *param);
+/**
+ * wmi_crash_inject() - inject fw crash
+ * @wmi_handle: wmi handle
+ * @param: ponirt to crash inject parameter structure
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_crash_inject(wmi_unified_t wmi_handle,
+			    struct crash_inject *param);
 
-QDF_STATUS wmi_unified_pdev_utf_cmd_send(void *wmi_hdl,
-				struct pdev_utf_params *param,
-				uint8_t mac_id);
+/**
+ * wmi_unified_pdev_utf_cmd() - send utf command to fw
+ * @wmi_handle: wmi handle
+ * @param: pointer to pdev_utf_params
+ * @mac_id: mac id to have radio context
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_pdev_utf_cmd_send(wmi_unified_t wmi_handle,
+					 struct pdev_utf_params *param,
+					 uint8_t mac_id);
 
 #ifdef FEATURE_FW_LOG_PARSING
-QDF_STATUS wmi_unified_dbglog_cmd_send(void *wmi_hdl,
+/**
+ * wmi_unified_dbglog_cmd_send() - set debug log level
+ * @wmi_handle: handle to WMI.
+ * @param: pointer to hold dbglog level parameter
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_dbglog_cmd_send(wmi_unified_t wmi_handle,
 				       struct dbglog_params *param);
 #else
 static inline QDF_STATUS
-wmi_unified_dbglog_cmd_send(void *wmi_hdl,
+wmi_unified_dbglog_cmd_send(wmi_unified_t wmi_handle,
 			    struct dbglog_params *param)
 {
 	return QDF_STATUS_SUCCESS;
 }
 #endif
 
-QDF_STATUS wmi_mgmt_unified_cmd_send(void *wmi_hdl,
-				struct wmi_mgmt_params *param);
+/**
+ *  wmi_mgmt_unified_cmd_send() - management cmd over wmi layer
+ *  @wmi_handle: handle to WMI.
+ *  @param: pointer to hold mgmt cmd parameter
+ *
+ *  Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_mgmt_unified_cmd_send(wmi_unified_t wmi_handle,
+				     struct wmi_mgmt_params *param);
+
+/**
+ *  wmi_offchan_data_tx_cmd_send() - Send offchan data tx cmd over wmi layer
+ *  @wmi_handle: handle to WMI.
+ *  @param: pointer to hold offchan data cmd parameter
+ *
+ *  Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_offchan_data_tx_cmd_send(
+		wmi_unified_t wmi_handle,
+		struct wmi_offchan_data_tx_params *param);
 
-QDF_STATUS wmi_offchan_data_tx_cmd_send(void *wmi_hdl,
-				struct wmi_offchan_data_tx_params *param);
+/**
+ * wmi_unified_modem_power_state() - set modem power state to fw
+ * @wmi_handle: wmi handle
+ * @param_value: parameter value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_modem_power_state(wmi_unified_t wmi_handle,
+					 uint32_t param_value);
 
-QDF_STATUS wmi_unified_modem_power_state(void *wmi_hdl,
-		uint32_t param_value);
+/**
+ * wmi_unified_set_sta_ps_mode() - set sta powersave params in fw
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ * @val: value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
+ */
+QDF_STATUS wmi_unified_set_sta_ps_mode(wmi_unified_t wmi_handle,
+				       uint32_t vdev_id,
+				       uint8_t val);
 
-QDF_STATUS wmi_unified_set_sta_ps_mode(void *wmi_hdl,
-			       uint32_t vdev_id, uint8_t val);
+/**
+ * wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command
+ * @wmi_handle: wmi handle
+ * @param: uapsd cmd parameter strcture
+ *
+ * This function sets the trigger
+ * uapsd params such as service interval, delay interval
+ * and suspend interval which will be used by the firmware
+ * to send trigger frames periodically when there is no
+ * traffic on the transmit side.
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
+ */
 QDF_STATUS
-wmi_unified_set_sta_uapsd_auto_trig_cmd(void *wmi_hdl,
-				struct sta_uapsd_trig_params *param);
+wmi_unified_set_sta_uapsd_auto_trig_cmd(wmi_unified_t wmi_handle,
+					struct sta_uapsd_trig_params *param);
 
-QDF_STATUS wmi_unified_get_temperature(void *wmi_hdl);
+/**
+ * wmi_get_temperature() - get pdev temperature req
+ * @wmi_handle: wmi handle
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
+ */
+QDF_STATUS wmi_unified_get_temperature(wmi_unified_t wmi_handle);
 
-QDF_STATUS wmi_unified_set_smps_params(void *wmi_hdl, uint8_t vdev_id,
-			       int value);
+/**
+ * wmi_set_smps_params() - set smps params
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ * @value: value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
+ */
+QDF_STATUS wmi_unified_set_smps_params(wmi_unified_t wmi_handle,
+				       uint8_t vdev_id,
+				       int value);
 
-QDF_STATUS wmi_unified_set_mimops(void *wmi_hdl, uint8_t vdev_id, int value);
+/**
+ * wmi_set_mimops() - set MIMO powersave
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ * @value: value
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
+ */
+QDF_STATUS wmi_unified_set_mimops(wmi_unified_t wmi_handle,
+				  uint8_t vdev_id, int value);
 
-QDF_STATUS wmi_unified_lro_config_cmd(void *wmi_hdl,
-	 struct wmi_lro_config_cmd_t *wmi_lro_cmd);
+/**
+ * wmi_unified_lro_config_cmd() - process the LRO config command
+ * @wmi_handle: Pointer to wmi handle
+ * @wmi_lro_cmd: Pointer to LRO configuration parameters
+ *
+ * This function sends down the LRO configuration parameters to
+ * the firmware to enable LRO, sets the TCP flags and sets the
+ * seed values for the toeplitz hash generation
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_lro_config_cmd(wmi_unified_t wmi_handle,
+			   struct wmi_lro_config_cmd_t *wmi_lro_cmd);
 
-QDF_STATUS wmi_unified_set_thermal_mgmt_cmd(void *wmi_hdl,
-				struct thermal_cmd_params *thermal_info);
+/**
+ * wmi_unified_set_thermal_mgmt_cmd() - set thermal mgmt command to fw
+ * @wmi_handle: Pointer to wmi handle
+ * @thermal_info: Thermal command information
+ *
+ * This function sends the thermal management command
+ * to the firmware
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_set_thermal_mgmt_cmd(wmi_unified_t wmi_handle,
+				 struct thermal_cmd_params *thermal_info);
 
-QDF_STATUS wmi_unified_peer_rate_report_cmd(void *wmi_hdl,
+/**
+ * wmi_unified_peer_rate_report_cmd() - process the peer rate report command
+ * @wmi_handle: Pointer to wmi handle
+ * @rate_report_params: Pointer to peer rate report parameters
+ *
+ *
+ * Return: QDF_STATUS_SUCCESS for success otherwise failure
+ */
+QDF_STATUS
+wmi_unified_peer_rate_report_cmd(
+		wmi_unified_t wmi_handle,
 		struct wmi_peer_rate_report_params *rate_report_params);
 
-QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl,
-		     uint8_t vdev_id, bool mu_edca_param,
-		     struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]);
+/**
+ * wmi_unified_process_update_edca_param() - update EDCA params
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id.
+ * @mu_edca_param: mu_edca_param.
+ * @wmm_vparams: edca parameters
+ *
+ * This function updates EDCA parameters to the target
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_process_update_edca_param(
+		wmi_unified_t wmi_handle,
+		uint8_t vdev_id,
+		bool mu_edca_param,
+		struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC]);
 
-QDF_STATUS wmi_unified_probe_rsp_tmpl_send_cmd(void *wmi_hdl,
-		   uint8_t vdev_id,
-		   struct wmi_probe_resp_params *probe_rsp_info);
+/**
+ * wmi_unified_probe_rsp_tmpl_send_cmd() - send probe response template to fw
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ * @probe_rsp_info: probe response info
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_probe_rsp_tmpl_send_cmd(
+		wmi_unified_t wmi_handle,
+		uint8_t vdev_id,
+		struct wmi_probe_resp_params *probe_rsp_info);
 
-QDF_STATUS wmi_unified_setup_install_key_cmd(void *wmi_hdl,
-			struct set_key_params *key_params);
+/**
+ * wmi_unified_setup_install_key_cmd - send key to install to fw
+ * @wmi_handle: wmi handle
+ * @key_params: key parameters
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_setup_install_key_cmd(wmi_unified_t wmi_handle,
+				  struct set_key_params *key_params);
 
-QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(void *wmi_hdl,
-				    uint32_t vdev_id, uint8_t *p2p_ie);
+/**
+ * wmi_unified_p2p_go_set_beacon_ie_cmd() - set beacon IE for p2p go
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ * @p2p_ie: p2p IE
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(wmi_unified_t wmi_hdl,
+						uint32_t vdev_id,
+						uint8_t *p2p_ie);
 
-QDF_STATUS wmi_unified_scan_probe_setoui_cmd(void *wmi_hdl,
-			  struct scan_mac_oui *psetoui);
+/**
+ * wmi_unified_scan_probe_setoui_cmd() - set scan probe OUI
+ * @wmi_handle: wmi handle
+ * @psetoui: OUI parameters
+ *
+ * set scan probe OUI parameters in firmware
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_scan_probe_setoui_cmd(wmi_unified_t wmi_handle,
+					     struct scan_mac_oui *psetoui);
 
 #ifdef IPA_OFFLOAD
-QDF_STATUS  wmi_unified_ipa_offload_control_cmd(void *wmi_hdl,
+/** wmi_unified_ipa_offload_control_cmd() - ipa offload control parameter
+ * @wmi_handle: wmi handle
+ * @ipa_offload: ipa offload control parameter
+ *
+ * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
+ *          error number otherwise
+ */
+QDF_STATUS
+wmi_unified_ipa_offload_control_cmd(
+		wmi_unified_t wmi_handle,
 		struct ipa_uc_offload_control_params *ipa_offload);
 #endif
 
-QDF_STATUS wmi_unified_pno_stop_cmd(void *wmi_hdl, uint8_t vdev_id);
+/**
+ * wmi_unified_pno_stop_cmd() - PNO stop request
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ *
+ * This function request FW to stop ongoing PNO operation.
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_pno_stop_cmd(wmi_unified_t wmi_handle, 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);
+/**
+ * wmi_unified_pno_start_cmd() - PNO start request
+ * @wmi_handle: wmi handle
+ * @pno: PNO request
+ *
+ * This function request FW to start PNO request.
+ * Request: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_pno_start_cmd(wmi_unified_t wmi_handle,
+				     struct pno_scan_req_params *pno);
 #endif
 
-QDF_STATUS wmi_unified_nlo_mawc_cmd(void *wmi_hdl,
-		struct nlo_mawc_params *params);
+/**
+ * wmi_unified_nlo_mawc_cmd() - NLO MAWC cmd configuration
+ * @wmi_handle: wmi handle
+ * @params: Configuration parameters
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_nlo_mawc_cmd(wmi_unified_t wmi_handle,
+				    struct nlo_mawc_params *params);
 
 #ifdef WLAN_FEATURE_LINK_LAYER_STATS
 /**
@@ -737,17 +1147,31 @@ QDF_STATUS wmi_unified_process_ll_stats_get_cmd(wmi_unified_t wmi_handle,
 
 /**
  * wmi_unified_congestion_request_cmd() - send request to fw to get CCA
- * @wmi_hdl: wma handle
+ * @wmi_handle: wma handle
  * @vdev_id: vdev id
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-QDF_STATUS wmi_unified_congestion_request_cmd(void *wmi_hdl,
-		uint8_t vdev_id);
+QDF_STATUS wmi_unified_congestion_request_cmd(wmi_unified_t wmi_handle,
+					      uint8_t vdev_id);
 
-QDF_STATUS wmi_unified_snr_request_cmd(void *wmi_hdl);
+/**
+ * wmi_unified_snr_request_cmd() - send request to fw to get RSSI stats
+ * @wmi_handle: wmi handle
+ * @rssi_req: get RSSI request
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_snr_request_cmd(wmi_unified_t wmi_handle);
 
-QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id);
+/**
+ * wmi_unified_snr_cmd() - get RSSI from fw
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_snr_cmd(wmi_unified_t wmi_handle, uint8_t vdev_id);
 
 /**
  * wmi_unified_link_status_req_cmd() - process link status request from UMAC
@@ -760,11 +1184,28 @@ QDF_STATUS wmi_unified_link_status_req_cmd(wmi_unified_t wmi_handle,
 					   struct link_status_params *params);
 
 #ifdef WLAN_SUPPORT_GREEN_AP
-QDF_STATUS wmi_unified_egap_conf_params_cmd(void *wmi_hdl,
+/**
+ * wmi_unified_egap_conf_params_cmd() - send wmi cmd of egap config params
+ * @wmi_handle: wmi handler
+ * @egap_params: pointer to egap_params
+ *
+ * Return:	 0 for success, otherwise appropriate error code
+ */
+QDF_STATUS
+wmi_unified_egap_conf_params_cmd(
+		wmi_unified_t wmi_handle,
 		struct wlan_green_ap_egap_params *egap_params);
 #endif
 
-QDF_STATUS wmi_unified_csa_offload_enable(void *wmi_hdl, uint8_t vdev_id);
+/**
+ * wmi_unified_csa_offload_enable() - send CSA offload enable command
+ * @wmi_handle: wmi handle
+ * @vdev_id: vdev id
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_csa_offload_enable(wmi_unified_t wmi_handle,
+					  uint8_t vdev_id);
 
 #ifdef WLAN_FEATURE_CIF_CFR
 /**
@@ -775,55 +1216,177 @@ QDF_STATUS wmi_unified_csa_offload_enable(void *wmi_hdl, uint8_t vdev_id);
  *
  * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
  */
-QDF_STATUS wmi_unified_oem_dma_ring_cfg(void *wmi_hdl,
-				wmi_oem_dma_ring_cfg_req_fixed_param *cfg);
+QDF_STATUS
+wmi_unified_oem_dma_ring_cfg(wmi_unified_t wmi_handle,
+			     wmi_oem_dma_ring_cfg_req_fixed_param *cfg);
 #endif
 
-QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl,
-			  uint32_t data_len,
-			  uint8_t *data);
+/**
+ * wmi_unified_start_oem_data_cmd() - start OEM data request to target
+ * @wmi_handle: wmi handle
+ * @data_len: length of OEM data
+ * @data: OEM data
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_start_oem_data_cmd(wmi_unified_t wmi_handle,
+					  uint32_t data_len,
+					  uint8_t *data);
 
-QDF_STATUS wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl,
-			bool dfs_phyerr_filter_offload);
+/**
+ * wmi_unified_dfs_phyerr_filter_offload_en_cmd() - enable dfs phyerr filter
+ * @wmi_handle: wmi handle
+ * @dfs_phyerr_filter_offload: is dfs phyerr filter offload
+ *
+ * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or
+ * WMI_DFS_PHYERR_FILTER_DIS_CMDID command
+ * to firmware based on phyerr filtering
+ * offload status.
+ *
+ * Return: 1 success, 0 failure
+ */
+QDF_STATUS
+wmi_unified_dfs_phyerr_filter_offload_en_cmd(wmi_unified_t wmi_handle,
+					     bool dfs_phyerr_filter_offload);
 
 #if !defined(REMOVE_PKT_LOG) && defined(FEATURE_PKTLOG)
-QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl,
-				   WMI_PKTLOG_EVENT pktlog_event,
-				   uint32_t cmd_id,
-				   uint8_t user_triggered);
+/**
+ * wmi_unified_pktlog_wmi_send_cmd() - send pktlog event command to target
+ * @wmi_handle: wmi handle
+ * @pktlog_event: pktlog event
+ * @cmd_id: pktlog cmd id
+ * @user_triggered: user triggered input for PKTLOG enable mode
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(wmi_unified_t wmi_handle,
+					   WMI_PKTLOG_EVENT pktlog_event,
+					   uint32_t cmd_id,
+					   uint8_t user_triggered);
 #endif
 
-QDF_STATUS wmi_unified_stats_ext_req_cmd(void *wmi_hdl,
-			struct stats_ext_params *preq);
+/**
+ * wmi_unified_stats_ext_req_cmd() - request ext stats from fw
+ * @wmi_handle: wmi handle
+ * @preq: stats ext params
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_stats_ext_req_cmd(wmi_unified_t wmi_handle,
+					 struct stats_ext_params *preq);
 
-QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd(void *wmi_hdl,
-				struct dhcp_offload_info_params *params);
+/**
+ * wmi_unified_process_dhcpserver_offload_cmd() - enable DHCP server offload
+ * @wmi_handle: wmi handle
+ * @pDhcpSrvOffloadInfo: DHCP server offload info
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd(
+		wmi_unified_t wmi_handle,
+		struct dhcp_offload_info_params *params);
 
-QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(void *wmi_hdl,
-				   uint32_t reg_dmn, uint16_t regdmn2G,
-				   uint16_t regdmn5G, uint8_t ctl2G,
-				   uint8_t ctl5G);
+/**
+ * wmi_unified_send_regdomain_info_to_fw_cmd() - send regdomain info to fw
+ * @wmi_handle: wmi handle
+ * @reg_dmn: reg domain
+ * @regdmn2G: 2G reg domain
+ * @regdmn5G: 5G reg domain
+ * @ctl2G: 2G test limit
+ * @ctl5G: 5G test limit
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(wmi_unified_t wmi_handle,
+						     uint32_t reg_dmn,
+						     uint16_t regdmn2G,
+						     uint16_t regdmn5G,
+						     uint8_t ctl2G,
+						     uint8_t ctl5G);
 
-QDF_STATUS wmi_unified_process_fw_mem_dump_cmd(void *wmi_hdl,
-					struct fw_dump_req_param *mem_dump_req);
+QDF_STATUS
+wmi_unified_process_fw_mem_dump_cmd(wmi_unified_t wmi_hdl,
+				    struct fw_dump_req_param *mem_dump_req);
 
-QDF_STATUS wmi_unified_cfg_action_frm_tb_ppdu_cmd(void *wmi_hdl,
-				struct cfg_action_frm_tb_ppdu_param *cfg_info);
+/**
+ * wmi_unified_cfg_action_frm_tb_ppdu_cmd()-send action frame TB PPDU cfg to FW
+ * @wmi_handle: Pointer to WMi handle
+ * @cfg_info: Pointer to cfg msg
+ *
+ * This function sends action frame TB PPDU cfg to firmware
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ *
+ */
+QDF_STATUS
+wmi_unified_cfg_action_frm_tb_ppdu_cmd(
+		wmi_unified_t wmi_handle,
+		struct cfg_action_frm_tb_ppdu_param *cfg_info);
 
-QDF_STATUS wmi_unified_save_fw_version_cmd(void *wmi_hdl,
-		void *evt_buf);
+/**
+ * wmi_unified_save_fw_version_cmd() - save fw version
+ * @wmi_handle: pointer to wmi handle
+ * @evt_buf: Event buffer
+ *
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ *
+ */
+QDF_STATUS wmi_unified_save_fw_version_cmd(wmi_unified_t wmi_handle,
+					   void *evt_buf);
 
-QDF_STATUS wmi_unified_log_supported_evt_cmd(void *wmi_hdl,
-		uint8_t *event,
-		uint32_t len);
+/**
+ * wmi_unified_log_supported_evt_cmd() - Enable/Disable FW diag/log events
+ * @wmi_handle: wmi handle
+ * @event: Event received from FW
+ * @len: Length of the event
+ *
+ * Enables the low frequency events and disables the high frequency
+ * events. Bit 17 indicates if the event if low/high frequency.
+ * 1 - high frequency, 0 - low frequency
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
+ */
+QDF_STATUS wmi_unified_log_supported_evt_cmd(wmi_unified_t wmi_handle,
+					     uint8_t *event,
+					     uint32_t len);
 
-QDF_STATUS wmi_unified_enable_specific_fw_logs_cmd(void *wmi_hdl,
-		struct wmi_wifi_start_log *start_log);
+/**
+ * wmi_unified_enable_specific_fw_logs_cmd() - Start/Stop logging of diag log id
+ * @wmi_handle: wmi handle
+ * @start_log: Start logging related parameters
+ *
+ * Send the command to the FW based on which specific logging of diag
+ * event/log id can be started/stopped
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_enable_specific_fw_logs_cmd(wmi_unified_t wmi_handle,
+					struct wmi_wifi_start_log *start_log);
 
-QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(void *wmi_hdl);
+/**
+ * wmi_unified_flush_logs_to_fw_cmd() - Send log flush command to FW
+ * @wmi_handle: WMI handle
+ *
+ * This function is used to send the flush command to the FW,
+ * that will flush the fw logs that are residue in the FW
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(wmi_unified_t wmi_handle);
 
-QDF_STATUS wmi_unified_unit_test_cmd(void *wmi_hdl,
-			       struct wmi_unit_test_cmd *wmi_utest);
+/**
+ * wmi_unified_unit_test_cmd() - send unit test command to fw.
+ * @wmi_handle: wmi handle
+ * @wmi_utest: unit test command
+ *
+ * This function send unit test command to fw.
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS wmi_unified_unit_test_cmd(wmi_unified_t wmi_handle,
+				     struct wmi_unit_test_cmd *wmi_utest);
 
 #ifdef FEATURE_WLAN_APF
 /**