qcacld-3.0: Update HDD to use DP component APIs

All the DP specific code logic is moved out of HDD to
new DP component. So update HDD module to use newly
introduced DP component APIs for DP specific operations.

Change-Id: I02fd36c45ec247fbd4fe79e035c1176cba3ebcec
CRs-Fixed: 3172570

core/cds/inc/cds_api.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2014-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. 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
@@ -563,14 +563,6 @@ bool cds_is_group_addr(uint8_t *mac_addr)
 		return false;
 }
 
-/**
- * cds_get_connectivity_stats_pkt_bitmap() - get pkt-type bitmap
- * @context: osif dev context
- *
- * Return: pkt bitmap to track
- */
-uint32_t cds_get_connectivity_stats_pkt_bitmap(void *context);
-
 #ifdef FEATURE_ALIGN_STATS_FROM_DP
 /**
  * cds_dp_get_vdev_stats() - get vdev stats from DP

core/cds/src/cds_api.c

@@ -85,6 +85,7 @@
 #include <qwlan_version.h>
 #include <qdf_trace.h>
 #include <qdf_nbuf.h>
+#include "wlan_dp_ucfg_api.h"
 
 /* Preprocessor Definitions and Constants */
 
@@ -443,7 +444,6 @@ static void cds_cdp_cfg_attach(struct wlan_objmgr_psoc *psoc)
 {
 	struct txrx_pdev_cfg_param_t cdp_cfg = {0};
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-	struct hdd_context *hdd_ctx = gp_cds_context->hdd_context;
 	uint32_t gro_bit_set;
 
 	cdp_cfg.is_full_reorder_offload = DP_REORDER_OFFLOAD_SUPPORT;
@@ -455,7 +455,7 @@ static void cds_cdp_cfg_attach(struct wlan_objmgr_psoc *psoc)
 		cfg_get(psoc, CFG_DP_IPA_UC_RX_IND_RING_COUNT);
 	cdp_cfg.uc_tx_partition_base =
 		cfg_get(psoc, CFG_DP_IPA_UC_TX_PARTITION_BASE);
-	cdp_cfg.enable_rxthread = hdd_ctx->enable_rxthread;
+	cdp_cfg.enable_rxthread = ucfg_dp_is_rx_common_thread_enabled(psoc);
 	cdp_cfg.ip_tcp_udp_checksum_offload =
 		cfg_get(psoc, CFG_DP_TCP_UDP_CKSUM_OFFLOAD);
 	cdp_cfg.nan_ip_tcp_udp_checksum_offload =
@@ -1000,9 +1000,9 @@ QDF_STATUS cds_dp_open(struct wlan_objmgr_psoc *psoc)
 	cds_debug("CDS successfully Opened");
 
 	if (cdp_cfg_get(gp_cds_context->dp_soc, cfg_dp_force_gro_enable))
-		hdd_ctx->dp_agg_param.force_gro_enable = true;
+		ucfg_dp_set_force_gro_enable(psoc, true);
 	else
-		hdd_ctx->dp_agg_param.force_gro_enable = false;
+		ucfg_dp_set_force_gro_enable(psoc, false);
 
 	return 0;
 
@@ -2823,22 +2823,6 @@ cds_print_htc_credit_history(uint32_t count, qdf_abstract_print *print,
 }
 #endif
 
-uint32_t cds_get_connectivity_stats_pkt_bitmap(void *context)
-{
-	struct hdd_adapter *adapter = NULL;
-
-	if (!context)
-		return 0;
-
-	adapter = (struct hdd_adapter *)context;
-	if (unlikely(adapter->magic != WLAN_HDD_ADAPTER_MAGIC)) {
-		cds_err("Magic cookie(%x) for adapter sanity verification is invalid",
-			adapter->magic);
-		return 0;
-	}
-	return adapter->pkt_type_bitmap;
-}
-
 #ifdef FEATURE_ALIGN_STATS_FROM_DP
 /**
  * cds_get_cdp_vdev_stats() - Function which retrieves cdp vdev stats

core/dp/txrx/ol_tx_send.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2021, Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc. 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
@@ -55,6 +55,7 @@
 #include <pktlog_ac_fmt.h>
 #include <cdp_txrx_handle.h>
 #include <wlan_pkt_capture_ucfg_api.h>
+#include <wlan_dp_txrx.h>
 #ifdef TX_CREDIT_RECLAIM_SUPPORT
 
 #define OL_TX_CREDIT_RECLAIM(pdev)					\
@@ -947,7 +948,7 @@ static void ol_tx_update_connectivity_stats(struct ol_tx_desc_t *tx_desc,
 	stats_rx = tx_desc->vdev->stats_rx;
 	ol_tx_flow_pool_unlock(tx_desc);
 
-	pkt_type_bitmap = cds_get_connectivity_stats_pkt_bitmap(osif_dev);
+	pkt_type_bitmap = wlan_dp_intf_get_pkt_type_bitmap_value(tx_desc->vdev);
 
 	if (pkt_type_bitmap) {
 		if (status != htt_tx_status_download_fail)

core/hdd/src/wlan_hdd_assoc.c

@@ -92,6 +92,7 @@
 #include "wlan_hdd_twt.h"
 #include "wlan_cm_roam_ucfg_api.h"
 #include "wlan_hdd_son.h"
+#include "wlan_dp_ucfg_api.h"
 
 /* These are needed to recognize WPA and RSN suite types */
 #define HDD_WPA_OUI_SIZE 4
@@ -288,6 +289,7 @@ static void hdd_start_powersave_timer_on_associated(struct hdd_adapter *adapter)
 void hdd_conn_set_authenticated(struct hdd_adapter *adapter, uint8_t auth_state)
 {
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
+	struct wlan_objmgr_vdev *vdev;
 	char *auth_time;
 	uint32_t time_buffer_size;
 
@@ -296,6 +298,12 @@ void hdd_conn_set_authenticated(struct hdd_adapter *adapter, uint8_t auth_state)
 		  sta_ctx->conn_info.is_authenticated, auth_state);
 	sta_ctx->conn_info.is_authenticated = auth_state;
 
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_conn_info_set_peer_authenticate(vdev, auth_state);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
 	auth_time = sta_ctx->conn_info.auth_time;
 	time_buffer_size = sizeof(sta_ctx->conn_info.auth_time);
 
@@ -1231,8 +1239,8 @@ QDF_STATUS hdd_roam_register_sta(struct hdd_adapter *adapter,
 {
 	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type txrx_desc = {0};
-	struct ol_txrx_ops txrx_ops;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	/* Get the Station ID from the one saved during the association */
 	if (!QDF_IS_ADDR_BROADCAST(bssid->bytes))
@@ -1257,40 +1265,17 @@ QDF_STATUS hdd_roam_register_sta(struct hdd_adapter *adapter,
 		txrx_desc.is_wapi_supported = 0;
 #endif /* FEATURE_WLAN_WAPI */
 
-	/* Register the vdev transmit and receive functions */
-	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
-
-	if (adapter->hdd_ctx->enable_dp_rx_threads) {
-		txrx_ops.rx.rx = hdd_rx_pkt_thread_enqueue_cbk;
-		txrx_ops.rx.rx_stack = hdd_rx_packet_cbk;
-		txrx_ops.rx.rx_flush = hdd_rx_flush_packet_cbk;
-		txrx_ops.rx.rx_gro_flush = hdd_rx_thread_gro_flush_ind_cbk;
-		adapter->rx_stack = hdd_rx_packet_cbk;
-	} else {
-		txrx_ops.rx.rx = hdd_rx_packet_cbk;
-		txrx_ops.rx.rx_stack = NULL;
-		txrx_ops.rx.rx_flush = NULL;
-	}
-
-	if (adapter->hdd_ctx->config->fisa_enable &&
-		(adapter->device_mode != QDF_MONITOR_MODE)) {
-		hdd_debug("FISA feature enabled");
-		hdd_rx_register_fisa_ops(&txrx_ops);
-	}
-
-	txrx_ops.rx.stats_rx = hdd_tx_rx_collect_connectivity_stats_info;
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return QDF_STATUS_E_INVAL;
 
-	txrx_ops.tx.tx_comp = hdd_sta_notify_tx_comp_cb;
-	txrx_ops.tx.tx = NULL;
-	txrx_ops.get_tsf_time = hdd_get_tsf_time;
-	cdp_vdev_register(soc, adapter->vdev_id, (ol_osif_vdev_handle)adapter,
-			  &txrx_ops);
-	if (!txrx_ops.tx.tx) {
-		hdd_err("vdev register fail");
-		return QDF_STATUS_E_FAILURE;
+	qdf_status = ucfg_dp_sta_register_txrx_ops(vdev);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
+		hdd_err("DP tx/rx ops register failed Status: %d", qdf_status);
+		return qdf_status;
 	}
 
-	adapter->tx_fn = txrx_ops.tx.tx;
 	qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &txrx_desc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_err("cdp_peer_register() failed Status: %d [0x%08X]",
@@ -1545,8 +1530,8 @@ QDF_STATUS hdd_roam_register_tdlssta(struct hdd_adapter *adapter,
 {
 	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type txrx_desc = { 0 };
-	struct ol_txrx_ops txrx_ops;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	/*
 	 * TDLS sta in BSS should be set as STA type TDLS and STA MAC should
@@ -1557,41 +1542,17 @@ QDF_STATUS hdd_roam_register_tdlssta(struct hdd_adapter *adapter,
 	/* set the QoS field appropriately .. */
 	txrx_desc.is_qos_enabled = qos;
 
-	/* Register the vdev transmit and receive functions */
-	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
-	if (adapter->hdd_ctx->enable_dp_rx_threads) {
-		txrx_ops.rx.rx = hdd_rx_pkt_thread_enqueue_cbk;
-		txrx_ops.rx.rx_stack = hdd_rx_packet_cbk;
-		txrx_ops.rx.rx_flush = hdd_rx_flush_packet_cbk;
-		txrx_ops.rx.rx_gro_flush = hdd_rx_thread_gro_flush_ind_cbk;
-		adapter->rx_stack = hdd_rx_packet_cbk;
-	} else {
-		txrx_ops.rx.rx = hdd_rx_packet_cbk;
-		txrx_ops.rx.rx_stack = NULL;
-		txrx_ops.rx.rx_flush = NULL;
-	}
-	if (adapter->hdd_ctx->config->fisa_enable &&
-	    adapter->device_mode != QDF_MONITOR_MODE) {
-		hdd_debug("FISA feature enabled");
-		hdd_rx_register_fisa_ops(&txrx_ops);
-	}
-
-	txrx_ops.rx.stats_rx = hdd_tx_rx_collect_connectivity_stats_info;
-
-	txrx_ops.tx.tx_comp = hdd_sta_notify_tx_comp_cb;
-	txrx_ops.tx.tx = NULL;
-
-	cdp_vdev_register(soc, adapter->vdev_id, (ol_osif_vdev_handle)adapter,
-			  &txrx_ops);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return QDF_STATUS_E_INVAL;
 
-	if (!txrx_ops.tx.tx) {
-		hdd_err("vdev register fail");
-		return QDF_STATUS_E_FAILURE;
+	qdf_status = ucfg_dp_tdlsta_register_txrx_ops(vdev);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
+		hdd_err("DP tx/rx ops register failed Status: %d", qdf_status);
+		return qdf_status;
 	}
 
-	adapter->tx_fn = txrx_ops.tx.tx;
-
-
 	/* Register the Station with TL...  */
 	qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &txrx_desc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {

core/hdd/src/wlan_hdd_cfg80211.c

@@ -180,6 +180,9 @@
 #include "wlan_hdd_son.h"
 #include "wlan_hdd_mcc_quota.h"
 #include "wlan_cfg80211_wifi_pos.h"
+#include "wlan_dp_ucfg_api.h"
+#include "os_if_dp.h"
+#include "os_if_dp_lro.h"
 
 #define g_mode_rates_size (12)
 #define a_mode_rates_size (8)
@@ -8405,12 +8408,19 @@ static int hdd_config_listen_interval(struct hdd_adapter *adapter,
 static int hdd_config_lro(struct hdd_adapter *adapter,
 			  const struct nlattr *attr)
 {
-	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+	struct wlan_objmgr_vdev *vdev;
 	uint8_t enable_flag;
+	QDF_STATUS status = QDF_STATUS_E_FAULT;
 
 	enable_flag = nla_get_u8(attr);
 
-	return hdd_lro_set_reset(hdd_ctx, adapter, enable_flag);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		status = osif_dp_lro_set_reset(vdev, enable_flag);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
+	return qdf_status_to_os_return(status);
 }
 
 static int hdd_config_scan_enable(struct hdd_adapter *adapter,
@@ -8898,6 +8908,7 @@ static void hdd_set_wlm_host_latency_level(struct hdd_context *hdd_ctx,
 					   uint32_t latency_host_flags)
 {
 	ol_txrx_soc_handle soc_hdl = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	if (!soc_hdl)
 		return;
@@ -8913,14 +8924,22 @@ static void hdd_set_wlm_host_latency_level(struct hdd_context *hdd_ctx,
 		wlan_hdd_set_pm_qos_request(hdd_ctx, false);
 
 	if (latency_host_flags & WLM_HOST_HBB_FLAG)
-		hdd_ctx->high_bus_bw_request |= (1 << adapter->vdev_id);
+		ucfg_dp_set_high_bus_bw_request(hdd_ctx->psoc,
+						adapter->vdev_id, true);
 	else
-		hdd_ctx->high_bus_bw_request &= ~(1 << adapter->vdev_id);
+		ucfg_dp_set_high_bus_bw_request(hdd_ctx->psoc,
+						adapter->vdev_id, false);
+
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return;
 
 	if (latency_host_flags & WLM_HOST_RX_THREAD_FLAG)
-		adapter->runtime_disable_rx_thread = true;
+		ucfg_dp_runtime_disable_rx_thread(vdev, true);
 	else
-		adapter->runtime_disable_rx_thread = false;
+		ucfg_dp_runtime_disable_rx_thread(vdev, false);
+
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 }
 
 #ifdef MULTI_CLIENT_LL_SUPPORT
@@ -15322,13 +15341,11 @@ static int __wlan_hdd_cfg80211_set_nud_stats(struct wiphy *wiphy,
 					     struct wireless_dev *wdev,
 					     const void *data, int data_len)
 {
-	struct nlattr *tb[STATS_SET_MAX + 1];
 	struct net_device   *dev = wdev->netdev;
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
-	struct set_arp_stats_params arp_stats_params = {0};
+	struct wlan_objmgr_vdev *vdev;
 	int err = 0;
-	mac_handle_t mac_handle;
 
 	hdd_enter();
 
@@ -15359,81 +15376,13 @@ static int __wlan_hdd_cfg80211_set_nud_stats(struct wiphy *wiphy,
 	if (hdd_is_roaming_in_progress(hdd_ctx))
 		return -EINVAL;
 
-	err = wlan_cfg80211_nla_parse(tb, STATS_SET_MAX, data, data_len,
-				      qca_wlan_vendor_set_nud_stats_policy);
-	if (err) {
-		hdd_err("STATS_SET_START ATTR");
-		return err;
-	}
-
-	if (tb[STATS_SET_START]) {
-		/* tracking is enabled for stats other than arp. */
-		if (tb[STATS_SET_DATA_PKT_INFO]) {
-			err = hdd_set_clear_connectivity_check_stats_info(
-						adapter,
-						&arp_stats_params, tb, true);
-			if (err)
-				return -EINVAL;
-
-			/*
-			 * if only tracking dns, then don't send
-			 * wmi command to FW.
-			 */
-			if (!arp_stats_params.pkt_type_bitmap)
-				return err;
-		} else {
-			if (!tb[STATS_GW_IPV4]) {
-				hdd_err("STATS_SET_START CMD");
-				return -EINVAL;
-			}
-
-			arp_stats_params.pkt_type_bitmap =
-						CONNECTIVITY_CHECK_SET_ARP;
-			adapter->pkt_type_bitmap |=
-					arp_stats_params.pkt_type_bitmap;
-			arp_stats_params.flag = true;
-			arp_stats_params.ip_addr =
-					nla_get_u32(tb[STATS_GW_IPV4]);
-			adapter->track_arp_ip = arp_stats_params.ip_addr;
-			arp_stats_params.pkt_type = WLAN_NUD_STATS_ARP_PKT_TYPE;
-		}
-	} else {
-		/* clear stats command received. */
-		if (tb[STATS_SET_DATA_PKT_INFO]) {
-			err = hdd_set_clear_connectivity_check_stats_info(
-						adapter,
-						&arp_stats_params, tb, false);
-			if (err)
-				return -EINVAL;
-
-			/*
-			 * if only tracking dns, then don't send
-			 * wmi command to FW.
-			 */
-			if (!arp_stats_params.pkt_type_bitmap)
-				return err;
-		} else {
-			arp_stats_params.pkt_type_bitmap =
-						CONNECTIVITY_CHECK_SET_ARP;
-			adapter->pkt_type_bitmap &=
-					(~arp_stats_params.pkt_type_bitmap);
-			arp_stats_params.flag = false;
-			qdf_mem_zero(&adapter->hdd_stats.hdd_arp_stats,
-				     sizeof(adapter->hdd_stats.hdd_arp_stats));
-			arp_stats_params.pkt_type = WLAN_NUD_STATS_ARP_PKT_TYPE;
-		}
-	}
-
-	hdd_debug("STATS_SET_START Received flag %d!", arp_stats_params.flag);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return -EINVAL;
 
-	arp_stats_params.vdev_id = adapter->vdev_id;
+	err = osif_dp_set_nud_stats(wiphy, vdev, data, data_len);
 
-	mac_handle = hdd_ctx->mac_handle;
-	if (QDF_STATUS_SUCCESS !=
-	    sme_set_nud_debug_stats(mac_handle, &arp_stats_params)) {
-		hdd_err("STATS_SET_START CMD Failed!");
-		return -EINVAL;
-	}
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 
 	hdd_exit();
 
@@ -15841,17 +15790,7 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 	struct net_device *dev = wdev->netdev;
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
-	struct get_arp_stats_params arp_stats_params;
-	mac_handle_t mac_handle;
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-	uint32_t pkt_type_bitmap;
-	struct sk_buff *skb;
-	struct osif_request *request = NULL;
-	static const struct osif_request_params params = {
-		.priv_size = 0,
-		.timeout_ms = WLAN_WAIT_TIME_NUD_STATS,
-	};
-	void *cookie = NULL;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_enter();
 
@@ -15873,102 +15812,14 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	request = osif_request_alloc(&params);
-	if (!request) {
-		hdd_err("Request allocation failure");
-		return -ENOMEM;
-	}
-
-	cookie = osif_request_cookie(request);
-
-	arp_stats_params.pkt_type = WLAN_NUD_STATS_ARP_PKT_TYPE;
-	arp_stats_params.vdev_id = adapter->vdev_id;
-
-	pkt_type_bitmap = adapter->pkt_type_bitmap;
-
-	/* send NUD failure event only when ARP tracking is enabled. */
-	if (hdd_is_data_stall_event_enabled(HDD_HOST_NUD_FAILURE) &&
-	    !hdd_ctx->config->enable_nud_tracking &&
-	    (pkt_type_bitmap & CONNECTIVITY_CHECK_SET_ARP)) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_ERROR,
-			  "Data stall due to NUD failure");
-		cdp_post_data_stall_event(soc,
-				      DATA_STALL_LOG_INDICATOR_FRAMEWORK,
-				      DATA_STALL_LOG_NUD_FAILURE,
-				      OL_TXRX_PDEV_ID, 0XFF,
-				      DATA_STALL_LOG_RECOVERY_TRIGGER_PDR);
-	}
-
-	mac_handle = hdd_ctx->mac_handle;
-	if (sme_set_nud_debug_stats_cb(mac_handle, hdd_get_nud_stats_cb,
-				       cookie) != QDF_STATUS_SUCCESS) {
-		hdd_err("Setting NUD debug stats callback failure");
-		err = -EINVAL;
-		goto exit;
-	}
-
-	if (QDF_STATUS_SUCCESS !=
-	    sme_get_nud_debug_stats(mac_handle, &arp_stats_params)) {
-		hdd_err("STATS_SET_START CMD Failed!");
-		err = -EINVAL;
-		goto exit;
-	}
-
-	err = osif_request_wait_for_response(request);
-	if (err) {
-		hdd_err("SME timedout while retrieving NUD stats");
-		err = -ETIMEDOUT;
-		goto exit;
-	}
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return -EINVAL;
 
-	skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy,
-						  WLAN_NUD_STATS_LEN);
-	if (!skb) {
-		hdd_err("cfg80211_vendor_cmd_alloc_reply_skb failed");
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	if (nla_put_u16(skb, COUNT_FROM_NETDEV,
-			adapter->hdd_stats.hdd_arp_stats.tx_arp_req_count) ||
-	    nla_put_u16(skb, COUNT_TO_LOWER_MAC,
-			adapter->hdd_stats.hdd_arp_stats.tx_host_fw_sent) ||
-	    nla_put_u16(skb, RX_COUNT_BY_LOWER_MAC,
-			adapter->hdd_stats.hdd_arp_stats.tx_host_fw_sent) ||
-	    nla_put_u16(skb, COUNT_TX_SUCCESS,
-			adapter->hdd_stats.hdd_arp_stats.tx_ack_cnt) ||
-	    nla_put_u16(skb, RSP_RX_COUNT_BY_LOWER_MAC,
-			adapter->hdd_stats.hdd_arp_stats.rx_fw_cnt) ||
-	    nla_put_u16(skb, RSP_RX_COUNT_BY_UPPER_MAC,
-			adapter->hdd_stats.hdd_arp_stats.rx_arp_rsp_count) ||
-	    nla_put_u16(skb, RSP_COUNT_TO_NETDEV,
-			adapter->hdd_stats.hdd_arp_stats.rx_delivered) ||
-	    nla_put_u16(skb, RSP_COUNT_OUT_OF_ORDER_DROP,
-			adapter->hdd_stats.hdd_arp_stats.
-			rx_host_drop_reorder)) {
-		hdd_err("nla put fail");
-		kfree_skb(skb);
-		err = -EINVAL;
-		goto exit;
-	}
-	if (adapter->con_status)
-		nla_put_flag(skb, AP_LINK_ACTIVE);
-	if (adapter->dad)
-		nla_put_flag(skb, AP_LINK_DAD);
+	err = osif_dp_get_nud_stats(wiphy, vdev, data, data_len);
 
-	/* ARP tracking is done above. */
-	pkt_type_bitmap &= ~CONNECTIVITY_CHECK_SET_ARP;
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 
-	if (pkt_type_bitmap) {
-		if (hdd_populate_connectivity_check_stats_info(adapter, skb)) {
-			err = -EINVAL;
-			goto exit;
-		}
-	}
-
-	cfg80211_vendor_cmd_reply(skb);
-exit:
-	osif_request_put(request);
 	return err;
 }
 
@@ -21156,9 +21007,16 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 								     param)))
 			goto fn_end;
 	} else {
-		if (param->reason_code == REASON_1X_AUTH_FAILURE)
-			hdd_softap_check_wait_for_tx_eap_pkt(
-					adapter, (struct qdf_mac_addr *)mac);
+		if (param->reason_code == REASON_1X_AUTH_FAILURE) {
+			struct wlan_objmgr_vdev *vdev;
+
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_softap_check_wait_for_tx_eap_pkt(vdev,
+						(struct qdf_mac_addr *)mac);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
+		}
 
 		sta_info = hdd_get_sta_info_by_mac(
 						&adapter->sta_info_list,

core/hdd/src/wlan_hdd_cm_connect.c

@@ -52,6 +52,7 @@
 #include "wlan_hdd_hostapd.h"
 #include <wlan_twt_ucfg_ext_api.h>
 #include <osif_twt_internal.h>
+#include <wlan_dp_ucfg_api.h>
 
 bool hdd_cm_is_vdev_associated(struct hdd_adapter *adapter)
 {
@@ -260,13 +261,12 @@ void hdd_cm_handle_assoc_event(struct wlan_objmgr_vdev *vdev, uint8_t *peer_mac)
 	if (ret)
 		hdd_err("Peer object " QDF_MAC_ADDR_FMT " fail to set associated state",
 			QDF_MAC_ADDR_REF(peer_mac));
-	hdd_add_latency_critical_client(
-			adapter,
+	ucfg_dp_add_latency_critical_client(vdev,
 			hdd_convert_cfgdot11mode_to_80211mode(
 				sta_ctx->conn_info.dot11mode));
 
-	hdd_bus_bw_compute_prev_txrx_stats(adapter);
-	hdd_bus_bw_compute_timer_start(hdd_ctx);
+	ucfg_dp_bus_bw_compute_prev_txrx_stats(vdev);
+	ucfg_dp_bus_bw_compute_timer_start(hdd_ctx->psoc);
 
 	if (ucfg_pkt_capture_get_pktcap_mode(hdd_ctx->psoc))
 		ucfg_pkt_capture_record_channel(adapter->vdev);
@@ -704,6 +704,7 @@ hdd_cm_connect_failure_pre_user_update(struct wlan_objmgr_vdev *vdev,
 	hdd_init_scan_reject_params(hdd_ctx);
 	hdd_cm_save_connect_status(adapter, rsp->status_code);
 	hdd_conn_remove_connect_info(hdd_sta_ctx);
+	ucfg_dp_remove_conn_info(vdev);
 	hdd_cm_update_rssi_snr_by_bssid(adapter);
 	hdd_cm_rec_connect_info(adapter, rsp);
 	hdd_debug("Invoking packetdump deregistration API");
@@ -742,7 +743,7 @@ hdd_cm_connect_failure_post_user_update(struct wlan_objmgr_vdev *vdev,
 	wlan_hdd_netif_queue_control(adapter,
 				     WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER,
 				     WLAN_CONTROL_PATH);
-	hdd_periodic_sta_stats_start(adapter);
+	ucfg_dp_periodic_sta_stats_start(vdev);
 	wlan_twt_concurrency_update(hdd_ctx);
 }
 
@@ -963,6 +964,7 @@ static void hdd_cm_save_connect_info(struct hdd_adapter *adapter,
 	uint8_t *ie_field;
 	uint32_t ie_len, status;
 	tDot11fBeaconIEs *bcn_ie;
+	struct s_ext_cap *p_ext_cap = NULL;
 	mac_handle_t mac_handle = hdd_adapter_get_mac_handle(adapter);
 
 	sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
@@ -971,6 +973,11 @@ static void hdd_cm_save_connect_info(struct hdd_adapter *adapter,
 		return;
 
 	qdf_copy_macaddr(&sta_ctx->conn_info.bssid, &rsp->bssid);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_conn_info_set_bssid(vdev, &rsp->bssid);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
 	sta_ctx->conn_info.assoc_status_code = rsp->status_code;
 
 	crypto_params = wlan_crypto_vdev_get_crypto_params(adapter->vdev);
@@ -1030,10 +1037,10 @@ static void hdd_cm_save_connect_info(struct hdd_adapter *adapter,
 		return;
 	}
 	if (bcn_ie->ExtCap.present) {
-		struct s_ext_cap *p_ext_cap = (struct s_ext_cap *)
-						bcn_ie->ExtCap.bytes;
+		p_ext_cap = (struct s_ext_cap *)bcn_ie->ExtCap.bytes;
 		sta_ctx->conn_info.proxy_arp_service =
 						p_ext_cap->proxy_arp_service;
+
 	}
 
 	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_OSIF_CM_ID);
@@ -1043,6 +1050,11 @@ static void hdd_cm_save_connect_info(struct hdd_adapter *adapter,
 					     &sta_ctx->conn_info.rate_flags);
 		hdd_wmm_cm_connect(vdev, adapter, bcn_ie,
 				   sta_ctx->conn_info.auth_type);
+
+		if (p_ext_cap)
+			ucfg_dp_conn_info_set_arp_service(vdev,
+					p_ext_cap->proxy_arp_service);
+
 		hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_CM_ID);
 	}
 	qdf_mem_free(bcn_ie);
@@ -1302,7 +1314,7 @@ hdd_cm_connect_success_pre_user_update(struct wlan_objmgr_vdev *vdev,
 		QDF_PROTO_TYPE_MGMT, QDF_PROTO_MGMT_ASSOC));
 
 	if (is_roam)
-		hdd_nud_indicate_roam(adapter);
+		ucfg_dp_nud_indicate_roam(vdev);
 	 /* hdd_objmgr_set_peer_mlme_auth_state */
 }
 
@@ -1344,7 +1356,7 @@ hdd_cm_connect_success_post_user_update(struct wlan_objmgr_vdev *vdev,
 				      &rsp->bssid,
 				      TWT_ALL_SESSIONS_DIALOG_ID);
 	}
-	hdd_periodic_sta_stats_start(adapter);
+	ucfg_dp_periodic_sta_stats_start(vdev);
 	wlan_twt_concurrency_update(hdd_ctx);
 }
 
@@ -1520,7 +1532,13 @@ static void hdd_update_hlp_info(struct net_device *dev,
 	 */
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-	status = hdd_rx_packet_cbk(adapter, skb);
+	/*
+	 * adapter->vdev is directly dereferenced because in per packet
+	 * path usage of hdd_get_vdev_by_user is costly operation as it
+	 * involves lock access. And it is guranteed during TX/RX operations
+	 * vdev will be active will not deleted.
+	 */
+	status = ucfg_dp_rx_packet_cbk(adapter->vdev, (qdf_nbuf_t)skb);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Sending HLP packet fails");
 		return;

core/hdd/src/wlan_hdd_cm_disconnect.c

@@ -49,6 +49,7 @@
 #include "wlan_hdd_cfr.h"
 #include "wlan_roam_debug.h"
 #include "wma_api.h"
+#include "wlan_dp_ucfg_api.h"
 
 void hdd_handle_disassociation_event(struct hdd_adapter *adapter,
 				     struct qdf_mac_addr *peer_macaddr)
@@ -56,6 +57,7 @@ void hdd_handle_disassociation_event(struct hdd_adapter *adapter,
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 	ol_txrx_soc_handle soc = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode, false);
 
@@ -71,13 +73,17 @@ void hdd_handle_disassociation_event(struct hdd_adapter *adapter,
 
 	hdd_lpass_notify_disconnect(adapter);
 
-	hdd_del_latency_critical_client(
-		adapter,
-		hdd_convert_cfgdot11mode_to_80211mode(
-			sta_ctx->conn_info.dot11mode));
-	/* stop timer in sta/p2p_cli */
-	hdd_bus_bw_compute_reset_prev_txrx_stats(adapter);
-	hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_del_latency_critical_client(vdev,
+			hdd_convert_cfgdot11mode_to_80211mode(
+				sta_ctx->conn_info.dot11mode));
+		/* stop timer in sta/p2p_cli */
+		ucfg_dp_bus_bw_compute_reset_prev_txrx_stats(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
+	ucfg_dp_bus_bw_compute_timer_try_stop(hdd_ctx->psoc);
 	cdp_display_txrx_hw_info(soc);
 }
 
@@ -118,6 +124,7 @@ void __hdd_cm_disconnect_handler_pre_user_update(struct hdd_adapter *adapter)
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 	uint32_t time_buffer_size;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_stop_tsf_sync(adapter);
 	time_buffer_size = sizeof(sta_ctx->conn_info.connect_time);
@@ -132,7 +139,12 @@ void __hdd_cm_disconnect_handler_pre_user_update(struct hdd_adapter *adapter)
 				  sta_ctx->conn_info.bssid.bytes,
 				  false);
 
-	hdd_periodic_sta_stats_stop(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_periodic_sta_stats_stop(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
 	wlan_hdd_auto_shutdown_enable(hdd_ctx, true);
 
 	DPTRACE(qdf_dp_trace_mgmt_pkt(QDF_DP_TRACE_MGMT_PACKET_RECORD,
@@ -178,6 +190,8 @@ void __hdd_cm_disconnect_handler_post_user_update(struct hdd_adapter *adapter,
 	/* Clear saved connection information in HDD */
 	hdd_conn_remove_connect_info(sta_ctx);
 
+	ucfg_dp_remove_conn_info(vdev);
+
 	/* Setting the RTS profile to original value */
 	if (sme_cli_set_command(adapter->vdev_id, WMI_VDEV_PARAM_ENABLE_RTSCTS,
 				cfg_get(hdd_ctx->psoc,
@@ -196,9 +210,9 @@ void __hdd_cm_disconnect_handler_post_user_update(struct hdd_adapter *adapter,
 	}
 	wlan_hdd_clear_link_layer_stats(adapter);
 
-	adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
+	ucfg_dp_reset_cont_txtimeout_cnt(vdev);
 
-	hdd_nud_reset_tracking(adapter);
+	ucfg_dp_nud_reset_tracking(vdev);
 	hdd_reset_limit_off_chan(adapter);
 
 	hdd_cm_print_bss_info(sta_ctx);

core/hdd/src/wlan_hdd_driver_ops.c

@@ -48,7 +48,7 @@
 #include <qdf_notifier.h>
 #include <qdf_hang_event_notifier.h>
 #include "wlan_hdd_thermal.h"
-#include "wlan_hdd_bus_bandwidth.h"
+#include "wlan_dp_ucfg_api.h"
 
 #ifdef MODULE
 #ifdef WLAN_WEAR_CHIPSET
@@ -99,7 +99,7 @@ static int hdd_get_bandwidth_level(void *data)
 	struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
 
 	if (hdd_ctx)
-		ret = hdd_get_current_throughput_level(hdd_ctx);
+		ret = ucfg_dp_get_current_throughput_level(hdd_ctx->psoc);
 
 	return ret;
 }
@@ -434,7 +434,7 @@ int hdd_hif_open(struct device *dev, void *bdev, const struct hif_bus_id *bid,
 			goto mark_target_not_ready;
 		} else {
 			hdd_napi_event(NAPI_EVT_INI_FILE,
-				(void *)hdd_ctx->napi_enable);
+				       (void *)ucfg_dp_get_napi_enabled(hdd_ctx->psoc));
 		}
 	}
 
@@ -957,7 +957,7 @@ static void hdd_soc_recovery_cleanup(void)
 
 	/* cancel/flush any pending/active idle shutdown work */
 	hdd_psoc_idle_timer_stop(hdd_ctx);
-	hdd_bus_bw_compute_timer_stop(hdd_ctx);
+	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 
 	/* nothing to do if the soc is already unloaded */
 	if (hdd_ctx->driver_status == DRIVER_MODULES_CLOSED) {
@@ -1042,7 +1042,7 @@ static void hdd_soc_recovery_shutdown(struct device *dev)
 	if (errno)
 		return;
 
-	hdd_wait_for_dp_tx();
+	ucfg_dp_wait_complete_tasks();
 	osif_psoc_sync_wait_for_ops(psoc_sync);
 
 	__hdd_soc_recovery_shutdown();
@@ -1292,7 +1292,7 @@ static int __wlan_hdd_bus_suspend(struct wow_enable_params wow_params,
 	 */
 	param.policy = BBM_NON_PERSISTENT_POLICY;
 	param.policy_info.flag = BBM_APPS_SUSPEND;
-	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
 
 	hdd_info("bus suspend succeeded");
 	return 0;
@@ -1459,7 +1459,7 @@ int wlan_hdd_bus_resume(enum qdf_suspend_type type)
 	 */
 	param.policy = BBM_NON_PERSISTENT_POLICY;
 	param.policy_info.flag = BBM_APPS_RESUME;
-	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
 
 	status = hif_bus_resume(hif_ctx);
 	if (status) {
@@ -1660,7 +1660,7 @@ static int wlan_hdd_runtime_suspend(struct device *dev)
 			  err, delta);
 
 	if (status == QDF_STATUS_SUCCESS)
-		hdd_bus_bw_compute_timer_stop(hdd_ctx);
+		ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 
 	hdd_debug("Runtime suspend done result: %d", err);
 
@@ -1736,7 +1736,7 @@ static int wlan_hdd_runtime_resume(struct device *dev)
 		hdd_err("PMO Runtime resume failed: %d", status);
 	} else {
 		if (policy_mgr_get_connection_count(hdd_ctx->psoc))
-			hdd_bus_bw_compute_timer_try_start(hdd_ctx);
+			ucfg_dp_bus_bw_compute_timer_try_start(hdd_ctx->psoc);
 	}
 
 	hdd_debug("Runtime resume done");

core/hdd/src/wlan_hdd_hostapd.c

@@ -2106,6 +2106,12 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		ucfg_ipa_set_dfs_cac_tx(hdd_ctx->pdev,
 					ap_ctx->dfs_cac_block_tx);
 
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_set_dfs_cac_tx(vdev, ap_ctx->dfs_cac_block_tx);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
+
 		hdd_debug("The value of dfs_cac_block_tx[%d] for ApCtx[%pK]:%d",
 				ap_ctx->dfs_cac_block_tx, ap_ctx,
 				adapter->vdev_id);
@@ -2119,6 +2125,11 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 			 * go through before that.
 			 */
 			hostapd_state->bss_state = BSS_STOP;
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_set_bss_state_start(vdev, false);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
 			qdf_event_set(&hostapd_state->qdf_event);
 			goto stopbss;
 		} else {
@@ -2173,6 +2184,11 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 			ap_ctx->operating_chan_freq);
 
 		hostapd_state->bss_state = BSS_START;
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_set_bss_state_start(vdev, true);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
 		hdd_start_tsf_sync(adapter);
 
 		hdd_hostapd_set_sap_key(adapter);
@@ -2256,6 +2272,12 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		if (!con_sap_adapter) {
 			ap_ctx->dfs_cac_block_tx = true;
 			hdd_ctx->dev_dfs_cac_status = DFS_CAC_NEVER_DONE;
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_set_dfs_cac_tx(vdev,
+						ap_ctx->dfs_cac_block_tx);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
 		}
 		hdd_nofl_info("Ap stopped vid %d reason=%d", adapter->vdev_id,
 			      ap_ctx->bss_stop_reason);
@@ -2319,6 +2341,13 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		ap_ctx->dfs_cac_block_tx = false;
 		ucfg_ipa_set_dfs_cac_tx(hdd_ctx->pdev,
 					ap_ctx->dfs_cac_block_tx);
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_set_dfs_cac_tx(vdev,
+					       ap_ctx->dfs_cac_block_tx);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
+
 		hdd_ctx->dev_dfs_cac_status = DFS_CAC_ALREADY_DONE;
 		if (QDF_STATUS_SUCCESS !=
 			hdd_send_radar_event(hdd_ctx, eSAP_DFS_CAC_END,
@@ -2382,6 +2411,13 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		ap_ctx->dfs_cac_block_tx = false;
 		ucfg_ipa_set_dfs_cac_tx(hdd_ctx->pdev,
 					ap_ctx->dfs_cac_block_tx);
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_set_dfs_cac_tx(vdev,
+					       ap_ctx->dfs_cac_block_tx);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
+
 		hdd_ctx->dev_dfs_cac_status = DFS_CAC_ALREADY_DONE;
 
 		qdf_create_work(0, &hdd_ctx->sap_pre_cac_work,
@@ -2561,8 +2597,12 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 
 		/* start timer in sap/p2p_go */
 		if (ap_ctx->ap_active == false) {
-			hdd_bus_bw_compute_prev_txrx_stats(adapter);
-			hdd_bus_bw_compute_timer_start(hdd_ctx);
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_bus_bw_compute_prev_txrx_stats(vdev);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
+			ucfg_dp_bus_bw_compute_timer_start(hdd_ctx->psoc);
 		}
 		ap_ctx->ap_active = true;
 
@@ -2707,14 +2747,12 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 			}
 		}
 
-		/* Send DHCP STOP indication to FW */
-		stainfo->dhcp_phase = DHCP_PHASE_ACK;
-		if (stainfo->dhcp_nego_status ==
-					DHCP_NEGO_IN_PROGRESS)
-			hdd_post_dhcp_ind(adapter,
-					  disassoc_comp->staMac.bytes,
-					  WMA_DHCP_STOP_IND);
-		stainfo->dhcp_nego_status = DHCP_NEGO_STOP;
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_update_dhcp_state_on_disassoc(vdev,
+						      &disassoc_comp->staMac);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
 
 		hdd_softap_deregister_sta(adapter, &stainfo);
 		hdd_put_sta_info_ref(&adapter->sta_info_list, &stainfo, true,
@@ -2788,8 +2826,12 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 
 		/*stop timer in sap/p2p_go */
 		if (ap_ctx->ap_active == false) {
-			hdd_bus_bw_compute_reset_prev_txrx_stats(adapter);
-			hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_bus_bw_compute_reset_prev_txrx_stats(vdev);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
+			ucfg_dp_bus_bw_compute_timer_try_stop(hdd_ctx->psoc);
 		}
 		hdd_son_deliver_assoc_disassoc_event(adapter,
 						     disassoc_comp->staMac,
@@ -2972,8 +3014,15 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		if (CHANNEL_STATE_DFS !=
 		    wlan_reg_get_channel_state_from_secondary_list_for_freq(
 						hdd_ctx->pdev,
-						ap_ctx->operating_chan_freq))
+						ap_ctx->operating_chan_freq)) {
 			ap_ctx->dfs_cac_block_tx = false;
+			vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+			if (vdev) {
+				ucfg_dp_set_dfs_cac_tx(vdev,
+						ap_ctx->dfs_cac_block_tx);
+				hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			}
+		}
 
 		/* Check any other sap need restart */
 		if (ap_ctx->sap_context->csa_reason ==
@@ -3018,6 +3067,12 @@ stopbss:
 		 * re-enabled
 		 */
 		hostapd_state->bss_state = BSS_STOP;
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_set_bss_state_start(vdev, false);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
+
 		hdd_stop_tsf_sync(adapter);
 
 #ifdef FEATURE_WLAN_AUTO_SHUTDOWN
@@ -3072,7 +3127,7 @@ stopbss:
 		 */
 		if (eSAP_STOP_BSS_EVENT == event_id) {
 			qdf_event_set(&hostapd_state->qdf_stop_bss_event);
-			hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
+			ucfg_dp_bus_bw_compute_timer_try_stop(hdd_ctx->psoc);
 		}
 
 		hdd_ipa_set_tx_flow_info();
@@ -4011,6 +4066,7 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
 	uint8_t enable_sifs_burst = 0;
 	bool is_6g_sap_fd_enabled = 0;
 	enum reg_6g_ap_type ap_pwr_type;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_enter();
 
@@ -4080,7 +4136,9 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
 	qdf_atomic_init(&adapter->cache_sta_count);
 
 	/* Initialize the data path module */
-	hdd_softap_init_tx_rx(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev)
+		ucfg_dp_softap_init_txrx(vdev);
 
 	status = hdd_wmm_adapter_init(adapter);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -4105,8 +4163,8 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
 
 	ucfg_mlme_is_6g_sap_fd_enabled(hdd_ctx->psoc, &is_6g_sap_fd_enabled);
 	hdd_debug("6g sap fd enabled %d", is_6g_sap_fd_enabled);
-	if (is_6g_sap_fd_enabled)
-		wlan_vdev_mlme_feat_ext_cap_set(adapter->vdev,
+	if (is_6g_sap_fd_enabled && vdev)
+		wlan_vdev_mlme_feat_ext_cap_set(vdev,
 						WLAN_VDEV_FEXT_FILS_DISC_6G_SAP);
 
 	hdd_set_netdev_flags(adapter);
@@ -4124,13 +4182,19 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
 				       &hdd_indicate_peers_deleted);
 	/* rcpi info initialization */
 	qdf_mem_zero(&adapter->rcpi, sizeof(adapter->rcpi));
+
+	if (vdev)
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 	hdd_exit();
 
 	return status;
 
 error_release_softap_tx_rx:
 	hdd_unregister_wext(adapter->dev);
-	hdd_softap_deinit_tx_rx(adapter);
+	if (vdev) {
+		ucfg_dp_softap_deinit_txrx(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
 error_deinit_sap_session:
 	hdd_hostapd_deinit_sap_session(adapter);
 error_release_vdev:
@@ -4142,6 +4206,8 @@ void hdd_deinit_ap_mode(struct hdd_context *hdd_ctx,
 			struct hdd_adapter *adapter,
 			bool rtnl_held)
 {
+	struct wlan_objmgr_vdev *vdev;
+
 	hdd_enter_dev(adapter->dev);
 
 	if (test_bit(WMM_INIT_DONE, &adapter->event_flags)) {
@@ -4157,7 +4223,12 @@ void hdd_deinit_ap_mode(struct hdd_context *hdd_ctx,
 		wlan_hdd_enable_roaming(adapter, RSO_SAP_CHANNEL_CHANGE);
 	}
 
-	hdd_softap_deinit_tx_rx(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_softap_deinit_txrx(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
 	if (hdd_hostapd_deinit_sap_session(adapter))
 		hdd_err("Failed:hdd_hostapd_deinit_sap_session");
 
@@ -6327,6 +6398,8 @@ int wlan_hdd_cfg80211_start_bss(struct hdd_adapter *adapter,
 	(WLAN_HDD_GET_AP_CTX_PTR(adapter))->dfs_cac_block_tx = true;
 	set_bit(SOFTAP_INIT_DONE, &adapter->event_flags);
 
+	ucfg_dp_set_dfs_cac_tx(vdev, true);
+
 	qdf_event_reset(&hostapd_state->qdf_event);
 
 	sap_ctx = WLAN_HDD_GET_SAP_CTX_PTR(adapter);

core/hdd/src/wlan_hdd_hostapd_wext.c

@@ -47,6 +47,7 @@
 #include "wlan_reg_ucfg_api.h"
 #include "wlan_hdd_sta_info.h"
 #include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 #define WE_WLAN_VERSION     1
 
@@ -961,7 +962,7 @@ static __iw_softap_setparam(struct net_device *dev,
 					sizeof(adapter->hdd_stats));
 			break;
 		case CDP_TXRX_HIST_STATS:
-			wlan_hdd_clear_tx_rx_histogram(hdd_ctx);
+			ucfg_wlan_dp_clear_tx_rx_histogram(hdd_ctx->psoc);
 			break;
 		case CDP_HDD_NETIF_OPER_HISTORY:
 			wlan_hdd_clear_netif_queue_history(hdd_ctx);

core/hdd/src/wlan_hdd_ipa.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. 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
@@ -453,7 +453,7 @@ void hdd_ipa_send_nbuf_to_network(qdf_nbuf_t nbuf, qdf_netdev_t dev)
 {
 	struct hdd_adapter *adapter = (struct hdd_adapter *) netdev_priv(dev);
 	int result;
-	unsigned int cpu_index;
+	bool delivered = false;
 	uint32_t enabled;
 	struct hdd_tx_rx_stats *stats;
 
@@ -502,24 +502,24 @@ void hdd_ipa_send_nbuf_to_network(qdf_nbuf_t nbuf, qdf_netdev_t dev)
 	nbuf->protocol = eth_type_trans(nbuf, nbuf->dev);
 	nbuf->ip_summed = CHECKSUM_NONE;
 
-	cpu_index = wlan_hdd_get_cpu();
-
-	++stats->per_cpu[cpu_index].rx_packets;
-
 	/*
 	 * Update STA RX exception packet stats.
 	 * For SAP as part of IPA HW stats are updated.
 	 */
 
-	++adapter->stats.rx_packets;
-	adapter->stats.rx_bytes += nbuf->len;
-
 	result = hdd_ipa_aggregated_rx_ind(nbuf);
 	if (result == NET_RX_SUCCESS)
-		++stats->per_cpu[cpu_index].rx_delivered;
-	else
-		++stats->per_cpu[cpu_index].rx_refused;
-
+		delivered = true;
+	/*
+	 * adapter->vdev is directly dereferenced because this is per packet
+	 * path, hdd_get_vdev_by_user() usage will be very costly as it involves
+	 * lock access.
+	 * Expectation here is vdev will be present during TX/RX processing
+	 * and also DP internally maintaining vdev ref count
+	 */
+	ucfg_dp_inc_rx_pkt_stats(adapter->vdev,
+				 nbuf->len,
+				 delivered);
 	/*
 	 * Restore PF_WAKE_UP_IDLE flag in the task structure
 	 */

core/hdd/src/wlan_hdd_main.c

@@ -3110,9 +3110,9 @@ static int __hdd_mon_open(struct net_device *dev)
 	if (!ret) {
 		param.policy = BBM_DRIVER_MODE_POLICY;
 		param.policy_info.driver_mode = QDF_GLOBAL_MONITOR_MODE;
-		hdd_bbm_apply_independent_policy(hdd_ctx, &param);
-		hdd_set_current_throughput_level(hdd_ctx,
-						 PLD_BUS_WIDTH_VERY_HIGH);
+		ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+		ucfg_dp_set_current_throughput_level(hdd_ctx->psoc,
+						     PLD_BUS_WIDTH_VERY_HIGH);
 	}
 
 	return ret;
@@ -3158,6 +3158,7 @@ static int __hdd_pktcapture_open(struct net_device *dev)
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	struct hdd_adapter *sta_adapter;
 	QDF_STATUS status;
+	struct wlan_objmgr_vdev *vdev;
 	int ret;
 
 	hdd_enter_dev(dev);
@@ -3172,24 +3173,20 @@ static int __hdd_pktcapture_open(struct net_device *dev)
 		return -EINVAL;
 	}
 
-	adapter->vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
-	if (!adapter->vdev) {
-		hdd_err("station interface is not up");
+	vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
+	if (!vdev)
 		return -EINVAL;
-	}
 
 	hdd_mon_mode_ether_setup(dev);
 
-	status = ucfg_pkt_capture_register_callbacks(adapter->vdev,
-						     hdd_mon_rx_packet_cbk,
-						     adapter);
+	status = ucfg_dp_register_pkt_capture_callbacks(vdev);
 	ret = qdf_status_to_os_return(status);
 	if (ret) {
-		hdd_objmgr_put_vdev_by_user(adapter->vdev, WLAN_OSIF_ID);
-		adapter->vdev = NULL;
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_ID);
 		return ret;
 	}
 
+	adapter->vdev = vdev;
 	set_bit(DEVICE_IFACE_OPENED, &adapter->event_flags);
 	sta_adapter->mon_adapter = adapter;
 
@@ -3253,6 +3250,7 @@ static void hdd_map_monitor_interface_vdev(struct hdd_adapter *sta_adapter)
 {
 	struct hdd_adapter *mon_adapter;
 	QDF_STATUS status;
+	struct wlan_objmgr_vdev *vdev;
 	int ret;
 
 	mon_adapter = hdd_get_adapter(sta_adapter->hdd_ctx, QDF_MONITOR_MODE);
@@ -3269,21 +3267,20 @@ static void hdd_map_monitor_interface_vdev(struct hdd_adapter *sta_adapter)
 	if (!wlan_hdd_is_session_type_monitor(mon_adapter->device_mode))
 		return;
 
-	mon_adapter->vdev = hdd_objmgr_get_vdev_by_user(sta_adapter,
-							WLAN_OSIF_ID);
+	vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
+	if (!vdev)
+		return;
 
-	status = ucfg_pkt_capture_register_callbacks(mon_adapter->vdev,
-						     hdd_mon_rx_packet_cbk,
-						     mon_adapter);
+	status = ucfg_dp_register_pkt_capture_callbacks(vdev);
 	ret = qdf_status_to_os_return(status);
 	if (ret) {
 		hdd_err("Failed registering packet capture callbacks");
-		hdd_objmgr_put_vdev_by_user(mon_adapter->vdev,
+		hdd_objmgr_put_vdev_by_user(vdev,
 					    WLAN_OSIF_ID);
-		mon_adapter->vdev = NULL;
 		return;
 	}
 
+	mon_adapter->vdev = vdev;
 	sta_adapter->mon_adapter = mon_adapter;
 }
 
@@ -4358,7 +4355,7 @@ static int hdd_register_notifiers(struct hdd_context *hdd_ctx)
 		goto unregister_ip6_notifier;
 	}
 
-	ret = hdd_nud_register_netevent_notifier(hdd_ctx);
+	ret = osif_dp_nud_register_netevent_notifier(hdd_ctx->psoc);
 	if (ret) {
 		hdd_err("Failed to register netevent notifier: %d",
 			ret);
@@ -4805,8 +4802,7 @@ int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit)
 				 hdd_softap_ipa_start_xmit);
 	ucfg_ipa_reg_send_to_nw_cb(hdd_ctx->pdev,
 				   hdd_ipa_send_nbuf_to_network);
-	ucfg_ipa_reg_rps_enable_cb(hdd_ctx->pdev,
-				   hdd_adapter_set_rps);
+	ucfg_dp_reg_ipa_rsp_ind(hdd_ctx->pdev);
 
 	if (!pld_get_thermal_state(hdd_ctx->parent_dev, &thermal_state,
 				   THERMAL_MONITOR_APPS)) {
@@ -6812,6 +6808,7 @@ QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
 	bool bval = false;
 	uint8_t enable_sifs_burst = 0;
 	uint32_t fine_time_meas_cap = 0, roam_triggers;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	mac_handle = hdd_ctx->mac_handle;
@@ -6841,10 +6838,16 @@ QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
 	/* Make the default Auth Type as OPEN */
 	sta_ctx->conn_info.auth_type = eCSR_AUTH_TYPE_OPEN_SYSTEM;
 
-	status = hdd_init_tx_rx(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev) {
+		status = QDF_STATUS_E_INVAL;
+		goto error_init_txrx;
+	}
+
+	status = ucfg_dp_init_txrx(vdev);
 	if (QDF_STATUS_SUCCESS != status) {
-		hdd_err("hdd_init_tx_rx() failed, status code %08d [x%08x]",
-			status, status);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		hdd_err("ucfg_dp_init_tx_rx() failed, status code %d", status);
 		goto error_init_txrx;
 	}
 
@@ -6893,11 +6896,13 @@ QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
 			VDEV_CMD);
 	}
 
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 	return QDF_STATUS_SUCCESS;
 
 error_wmm_init:
 	clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
-	hdd_deinit_tx_rx(adapter);
+	ucfg_dp_deinit_txrx(vdev);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 error_init_txrx:
 	hdd_unregister_wext(adapter->dev);
 	QDF_BUG(!hdd_vdev_destroy(adapter));
@@ -7915,7 +7920,6 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx,
 
 	adapter->upgrade_udp_qos_threshold = QCA_WLAN_AC_BK;
 	qdf_spinlock_create(&adapter->vdev_lock);
-	qdf_atomic_init(&hdd_ctx->num_latency_critical_clients);
 
 	hdd_init_completion(adapter);
 	INIT_WORK(&adapter->scan_block_work, wlan_hdd_cfg80211_scan_block_cb);
@@ -8005,14 +8009,14 @@ void hdd_close_adapter(struct hdd_context *hdd_ctx,
 	 * Stop the global bus bandwidth timer while touching the adapter list
 	 * to avoid bad memory access by the timer handler.
 	 */
-	hdd_bus_bw_compute_timer_stop(hdd_ctx);
+	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 
 	hdd_check_for_net_dev_ref_leak(adapter);
 	hdd_remove_adapter(hdd_ctx, adapter);
 	__hdd_close_adapter(hdd_ctx, adapter, rtnl_held);
 
 	/* conditionally restart the bw timer */
-	hdd_bus_bw_compute_timer_try_start(hdd_ctx);
+	ucfg_dp_bus_bw_compute_timer_try_start(hdd_ctx->psoc);
 }
 
 void hdd_close_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held)
@@ -8228,10 +8232,6 @@ QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
 	if (adapter->vdev_id != WLAN_UMAC_VDEV_ID_MAX)
 		wlan_hdd_cfg80211_deregister_frames(adapter);
 
-	hdd_nud_ignore_tracking(adapter, true);
-	hdd_nud_reset_tracking(adapter);
-	hdd_nud_flush_work(adapter);
-	hdd_mic_flush_work(adapter);
 	hdd_stop_tsf_sync(adapter);
 	cds_flush_work(&adapter->scan_block_work);
 	wlan_hdd_cfg80211_scan_block(adapter);
@@ -9707,7 +9707,7 @@ static QDF_STATUS hdd_abort_sched_scan_all_adapters(struct hdd_context *hdd_ctx)
  */
 void hdd_unregister_notifiers(struct hdd_context *hdd_ctx)
 {
-	hdd_nud_unregister_netevent_notifier(hdd_ctx);
+	osif_dp_nud_unregister_netevent_notifier(hdd_ctx->psoc);
 	hdd_wlan_unregister_ip6_notifier(hdd_ctx);
 
 	unregister_inetaddr_notifier(&hdd_ctx->ipv4_notifier);
@@ -9827,7 +9827,7 @@ static int hdd_context_deinit(struct hdd_context *hdd_ctx)
 
 	wlan_hdd_cfg80211_deinit(hdd_ctx->wiphy);
 
-	hdd_bbm_context_deinit(hdd_ctx);
+	ucfg_dp_bbm_context_deinit(hdd_ctx->psoc);
 
 	hdd_sap_context_destroy(hdd_ctx);
 
@@ -9897,7 +9897,7 @@ void hdd_wlan_exit(struct hdd_context *hdd_ctx)
 
 	hdd_enter();
 
-	hdd_wait_for_dp_tx();
+	ucfg_dp_wait_complete_tasks();
 	wlan_hdd_destroy_mib_stats_lock();
 	hdd_debugfs_ini_config_deinit(hdd_ctx);
 	hdd_debugfs_mws_coex_info_deinit(hdd_ctx);
@@ -11220,6 +11220,7 @@ void hdd_send_mscs_action_frame(struct hdd_context *hdd_ctx,
 	unsigned long tx_vo_pkts = 0;
 	uint8_t cpu;
 	struct hdd_tx_rx_stats *stats = &adapter->hdd_stats.tx_rx_stats;
+	uint32_t bus_bw_compute_interval;
 
 	/*
 	 * To disable MSCS feature in driver set mscs_pkt_threshold = 0
@@ -11235,10 +11236,12 @@ void hdd_send_mscs_action_frame(struct hdd_context *hdd_ctx,
 		adapter->mscs_prev_tx_vo_pkts = tx_vo_pkts;
 
 	adapter->mscs_counter++;
+	bus_bw_compute_interval =
+		ucfg_dp_get_bus_bw_compute_interval(hdd_ctx->psoc);
 
-	if (adapter->mscs_counter * hdd_ctx->config->bus_bw_compute_interval >=
+	if (adapter->mscs_counter * bus_bw_compute_interval >=
 	    hdd_ctx->config->mscs_voice_interval * 1000) {
-	    adapter->mscs_counter = 0;
+		adapter->mscs_counter = 0;
 		mscs_vo_pkt_delta =
 				HDD_BW_GET_DIFF(tx_vo_pkts,
 						adapter->mscs_prev_tx_vo_pkts);
@@ -12092,7 +12095,7 @@ int hdd_wlan_dump_stats(struct hdd_adapter *adapter, int stats_id)
 
 	switch (stats_id) {
 	case CDP_TXRX_HIST_STATS:
-		wlan_hdd_display_tx_rx_histogram(hdd_ctx);
+		ucfg_wlan_dp_display_tx_rx_histogram(hdd_ctx->psoc);
 		break;
 	case CDP_HDD_NETIF_OPER_HISTORY:
 		wlan_hdd_display_adapter_netif_queue_history(adapter);
@@ -12142,7 +12145,7 @@ int hdd_wlan_clear_stats(struct hdd_adapter *adapter, int stats_id)
 		memset(&adapter->hdd_stats, 0, sizeof(adapter->hdd_stats));
 		break;
 	case CDP_TXRX_HIST_STATS:
-		wlan_hdd_clear_tx_rx_histogram(adapter->hdd_ctx);
+		ucfg_wlan_dp_clear_tx_rx_histogram(adapter->hdd_ctx->psoc);
 		break;
 	case CDP_HDD_NETIF_OPER_HISTORY:
 		wlan_hdd_clear_netif_queue_history(adapter->hdd_ctx);
@@ -13416,7 +13419,7 @@ static int hdd_context_init(struct hdd_context *hdd_ctx)
 	if (ret)
 		goto scan_destroy;
 
-	ret = hdd_bbm_context_init(hdd_ctx);
+	ret = ucfg_dp_bbm_context_init(hdd_ctx->psoc);
 	if (ret)
 		goto sap_destroy;
 
@@ -13435,7 +13438,7 @@ static int hdd_context_init(struct hdd_context *hdd_ctx)
 	return 0;
 
 bbm_destroy:
-	hdd_bbm_context_deinit(hdd_ctx);
+	ucfg_dp_bbm_context_deinit(hdd_ctx->psoc);
 
 sap_destroy:
 	hdd_sap_context_destroy(hdd_ctx);
@@ -14316,7 +14319,8 @@ static inline void hdd_txrx_populate_cds_config(struct cds_config_info
 	cds_cfg->tx_flow_start_queue_offset =
 		cfg_get(hdd_ctx->psoc, CFG_DP_TX_FLOW_START_QUEUE_OFFSET);
 	/* configuration for DP RX Threads */
-	cds_cfg->enable_dp_rx_threads = hdd_ctx->enable_dp_rx_threads;
+	cds_cfg->enable_dp_rx_threads =
+		ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc);
 }
 #else
 static inline void hdd_txrx_populate_cds_config(struct cds_config_info
@@ -14391,7 +14395,8 @@ static int hdd_update_cds_config(struct hdd_context *hdd_ctx)
 	/* IPA micro controller data path offload resource config item */
 	cds_cfg->uc_offload_enabled = ucfg_ipa_uc_is_enabled();
 
-	cds_cfg->enable_rxthread = hdd_ctx->enable_rxthread;
+	cds_cfg->enable_rxthread =
+		ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc);
 	ucfg_mlme_get_sap_max_peers(hdd_ctx->psoc, &value);
 	cds_cfg->max_station = value;
 	cds_cfg->sub_20_channel_width = WLAN_SUB_20_CH_WIDTH_NONE;
@@ -15029,7 +15034,7 @@ static int hdd_pre_enable_configure(struct hdd_context *hdd_ctx)
 	/* Register HL netdev flow control callback */
 	cdp_hl_fc_register(soc, OL_TXRX_PDEV_ID, wlan_hdd_txrx_pause_cb);
 	/* Register rx mic error indication handler */
-	cdp_register_rx_mic_error_ind_handler(soc, hdd_rx_mic_error_ind);
+	ucfg_dp_register_rx_mic_error_ind_handler(soc);
 
 	/*
 	 * Note that the cds_pre_enable() sequence triggers the cfg download.
@@ -15472,7 +15477,7 @@ static int hdd_features_init(struct hdd_context *hdd_ctx)
 	if (hdd_set_vc_mode_config(hdd_ctx))
 		hdd_warn("Error in setting Voltage Corner mode config to FW");
 
-	if (hdd_rx_ol_init(hdd_ctx))
+	if (ucfg_dp_rx_ol_init(hdd_ctx->psoc, hdd_ctx->is_wifi3_0_target))
 		hdd_err("Unable to initialize Rx LRO/GRO in fw");
 
 	if (hdd_adaptive_dwelltime_init(hdd_ctx))
@@ -15860,7 +15865,7 @@ int hdd_configure_cds(struct hdd_context *hdd_ctx)
 		goto cds_disable;
 
 	dp_cbs.hdd_rx_handle_concurrency = hdd_rx_handle_concurrency;
-	dp_cbs.hdd_set_rx_mode_rps_cb = hdd_set_rx_mode_rps;
+	dp_cbs.hdd_set_rx_mode_rps_cb = ucfg_dp_set_rx_mode_rps;
 	dp_cbs.hdd_ipa_set_mcc_mode_cb = hdd_ipa_set_mcc_mode;
 	dp_cbs.hdd_v2_flow_pool_map = hdd_v2_flow_pool_map;
 	dp_cbs.hdd_v2_flow_pool_unmap = hdd_v2_flow_pool_unmap;
@@ -15995,12 +16000,12 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 			hdd_psoc_idle_timer_start(hdd_ctx);
 			cds_set_driver_state_module_stop(false);
 
-			hdd_bus_bw_compute_timer_stop(hdd_ctx);
+			ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 			return -EAGAIN;
 		}
 	}
 
-	hdd_bus_bw_compute_timer_stop(hdd_ctx);
+	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 	hdd_deregister_policy_manager_callback(hdd_ctx->psoc);
 
 	/* free user wowl patterns */
@@ -16150,7 +16155,7 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 	 */
 	param.policy = BBM_DRIVER_MODE_POLICY;
 	param.policy_info.driver_mode = QDF_GLOBAL_MAX_MODE;
-	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
 
 	hdd_deinit_adapter_ops_wq(hdd_ctx);
 	hdd_bus_bandwidth_deinit(hdd_ctx);
@@ -16776,8 +16781,7 @@ QDF_STATUS hdd_psoc_create_vdevs(struct hdd_context *hdd_ctx)
 		return status;
 	}
 
-	if (hdd_ctx->rps)
-		hdd_set_rps_cpu_mask(hdd_ctx);
+	ucfg_dp_try_set_rps_cpu_mask(hdd_ctx->psoc);
 
 	if (driver_mode != QDF_GLOBAL_FTM_MODE &&
 	    driver_mode != QDF_GLOBAL_EPPING_MODE)
@@ -17576,7 +17580,7 @@ exit:
 	}
 	param.policy = BBM_TPUT_POLICY;
 	param.policy_info.tput_level = TPUT_LEVEL_NONE;
-	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
 
 }
 
@@ -19107,7 +19111,7 @@ static int __hdd_driver_mode_change(struct hdd_context *hdd_ctx,
 
 	param.policy = BBM_DRIVER_MODE_POLICY;
 	param.policy_info.driver_mode = con_mode;
-	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
 
 	return 0;
 }
@@ -19428,7 +19432,7 @@ void hdd_driver_unload(void)
 		 * Runtime PM sync resume may have started the bus bandwidth
 		 * periodic work hence stop it.
 		 */
-		hdd_bus_bw_compute_timer_stop(hdd_ctx);
+		ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
 	}
 
 	/*

core/hdd/src/wlan_hdd_nan_datapath.c

@@ -43,6 +43,7 @@
 #include "qdf_util.h"
 #include <cdp_txrx_misc.h>
 #include "wlan_fwol_ucfg_api.h"
+#include "wlan_dp_ucfg_api.h"
 
 /**
  * hdd_nan_datapath_target_config() - Configure NAN datapath features
@@ -608,6 +609,7 @@ int hdd_init_nan_data_mode(struct hdd_adapter *adapter)
 	mac_handle_t mac_handle;
 	bool bval = false;
 	uint8_t enable_sifs_burst = 0;
+	struct wlan_objmgr_vdev *vdev;
 
 	ret_val = hdd_vdev_create(adapter);
 	if (ret_val) {
@@ -631,9 +633,16 @@ int hdd_init_nan_data_mode(struct hdd_adapter *adapter)
 	hdd_roam_profile_init(adapter);
 	hdd_register_wext(wlan_dev);
 
-	status = hdd_init_tx_rx(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev) {
+		ret_val = -EAGAIN;
+		goto error_init_txrx;
+	}
+
+	status = ucfg_dp_init_txrx(vdev);
 	if (QDF_STATUS_SUCCESS != status) {
-		hdd_err("hdd_init_tx_rx() init failed, status %d", status);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		hdd_err("ucfg_dp_init_tx_rx() init failed, status %d", status);
 		ret_val = -EAGAIN;
 		goto error_init_txrx;
 	}
@@ -663,11 +672,13 @@ int hdd_init_nan_data_mode(struct hdd_adapter *adapter)
 	hdd_set_netdev_flags(adapter);
 
 	update_ndi_state(adapter, NAN_DATA_NDI_CREATING_STATE);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 	return ret_val;
 
 error_wmm_init:
 	clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
-	hdd_deinit_tx_rx(adapter);
+	ucfg_dp_deinit_txrx(vdev);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 
 error_init_txrx:
 	hdd_unregister_wext(wlan_dev);
@@ -1030,6 +1041,7 @@ int hdd_ndp_new_peer_handler(uint8_t vdev_id, uint16_t sta_id,
 	struct hdd_adapter *adapter;
 	struct hdd_station_ctx *sta_ctx;
 	struct csr_roam_info *roam_info;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
 	if (!hdd_ctx)
@@ -1066,14 +1078,18 @@ int hdd_ndp_new_peer_handler(uint8_t vdev_id, uint16_t sta_id,
 	if (first_peer) {
 		hdd_debug("Set ctx connection state to connected");
 		/* Disable LRO/GRO for NDI Mode */
-		if (hdd_ctx->ol_enable &&
+		if (ucfg_dp_is_ol_enabled(hdd_ctx->psoc) &&
 		    !NAN_CONCURRENCY_SUPPORTED(hdd_ctx->psoc)) {
 			hdd_debug("Disable LRO/GRO in NDI Mode");
 			hdd_rx_handle_concurrency(true);
 		}
 
-		hdd_bus_bw_compute_prev_txrx_stats(adapter);
-		hdd_bus_bw_compute_timer_start(hdd_ctx);
+		vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+		if (vdev) {
+			ucfg_dp_bus_bw_compute_prev_txrx_stats(vdev);
+			hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		}
+		ucfg_dp_bus_bw_compute_timer_start(hdd_ctx->psoc);
 		sta_ctx->conn_info.conn_state = eConnectionState_NdiConnected;
 		hdd_wmm_connect(adapter, roam_info, eCSR_BSS_TYPE_NDI);
 		wlan_hdd_netif_queue_control(
@@ -1097,6 +1113,7 @@ void hdd_cleanup_ndi(struct hdd_context *hdd_ctx,
 		     struct hdd_adapter *adapter)
 {
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
+	struct wlan_objmgr_vdev *vdev;
 
 	if (sta_ctx->conn_info.conn_state != eConnectionState_NdiConnected) {
 		hdd_debug("NDI has no NDPs");
@@ -1109,9 +1126,13 @@ void hdd_cleanup_ndi(struct hdd_context *hdd_ctx,
 	wlan_hdd_netif_queue_control(adapter,
 				     WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER,
 				     WLAN_CONTROL_PATH);
-	hdd_bus_bw_compute_reset_prev_txrx_stats(adapter);
-	hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
-	if ((hdd_ctx->ol_enable &&
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_bus_bw_compute_reset_prev_txrx_stats(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+	ucfg_dp_bus_bw_compute_timer_try_stop(hdd_ctx->psoc);
+	if ((ucfg_dp_is_ol_enabled(hdd_ctx->psoc) &&
 	     !NAN_CONCURRENCY_SUPPORTED(hdd_ctx->psoc)) &&
 	    ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 0) ||
 	     ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 1) &&
@@ -1120,7 +1141,9 @@ void hdd_cleanup_ndi(struct hdd_context *hdd_ctx,
 						PM_STA_MODE,
 						NULL) == 1)))) {
 		hdd_debug("Enable LRO/GRO");
-		hdd_rx_handle_concurrency(false);
+		ucfg_dp_rx_handle_concurrency(hdd_ctx->psoc,
+					      hdd_ctx->is_wifi3_0_target,
+					      false);
 	}
 }
 

core/hdd/src/wlan_hdd_napi.c

@@ -30,6 +30,7 @@
 #include "wlan_hdd_main.h" /* hdd_err/warn... */
 #include "qdf_types.h"     /* QDF_MODULE_ID_... */
 #include "ce_api.h"
+#include "wlan_dp_ucfg_api.h"
 
 /*  guaranteed to be initialized to zero/NULL by the standard */
 static struct qca_napi_data *hdd_napi_ctx;
@@ -139,7 +140,7 @@ int hdd_napi_create(void)
 	}
 
 	rc = hdd_napi_event(NAPI_EVT_INI_FILE,
-			    (void *)hdd_ctx->napi_enable);
+			    (void *)ucfg_dp_get_napi_enabled(hdd_ctx->psoc));
 	napid->user_cpu_affin_mask =
 		hdd_ctx->config->napi_cpu_affinity_mask;
 

core/hdd/src/wlan_hdd_nud_tracking.c

@@ -23,6 +23,7 @@
 
 #include "osif_sync.h"
 #include "wlan_hdd_main.h"
+#include "wlan_dp_ucfg_api.h"
 #include "wlan_dlm_ucfg_api.h"
 #include "hdd_dp_cfg.h"
 #include <cdp_txrx_misc.h>
@@ -338,7 +339,7 @@ static void __hdd_nud_failure_work(struct hdd_adapter *adapter)
 	}
 
 	if (adapter->device_mode == QDF_STA_MODE &&
-	    hdd_is_roam_after_nud_enabled(hdd_ctx->config)) {
+	    ucfg_dp_is_roam_after_nud_enabled(hdd_ctx->psoc)) {
 		hdd_handle_nud_fail_sta(hdd_ctx, adapter);
 		return;
 	}

core/hdd/src/wlan_hdd_ocb.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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
@@ -43,6 +44,7 @@
 #include <cdp_txrx_ocb.h>
 #include "ol_txrx.h"
 #include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 /* Structure definitions for WLAN_SET_DOT11P_CHANNEL_SCHED */
 #define AIFSN_MIN		(2)
@@ -219,8 +221,8 @@ static int hdd_ocb_register_sta(struct hdd_adapter *adapter)
 	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type sta_desc = {0};
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
-	struct ol_txrx_ops txrx_ops;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	qdf_status = cdp_peer_register_ocb_peer(soc,
 				adapter->mac_addr.bytes);
@@ -232,14 +234,16 @@ static int hdd_ocb_register_sta(struct hdd_adapter *adapter)
 	WLAN_ADDR_COPY(sta_desc.peer_addr.bytes, adapter->mac_addr.bytes);
 	sta_desc.is_qos_enabled = 1;
 
-	/* Register the vdev transmit and receive functions */
-	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
-	txrx_ops.rx.rx = hdd_rx_packet_cbk;
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return -EINVAL;
 
-	cdp_vdev_register(soc, adapter->vdev_id, (ol_osif_vdev_handle)adapter,
-			  &txrx_ops);
-	txrx_ops.rx.stats_rx = hdd_tx_rx_collect_connectivity_stats_info;
-	adapter->tx_fn = txrx_ops.tx.tx;
+	qdf_status = ucfg_dp_ocb_register_txrx_ops(vdev);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
+		hdd_err("Failed to register tx/rx ops. Status= %d", qdf_status);
+		return -EINVAL;
+	}
 
 	qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &sta_desc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {

core/hdd/src/wlan_hdd_p2p.c

@@ -54,6 +54,7 @@
 #include "nan_ucfg_api.h"
 #include "wlan_pkt_capture_ucfg_api.h"
 #include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 /* Ms to Time Unit Micro Sec */
 #define MS_TO_TU_MUS(x)   ((x) * 1024)
@@ -817,8 +818,11 @@ struct wireless_dev *__wlan_hdd_add_virtual_intf(struct wiphy *wiphy,
 		goto close_adapter;
 	}
 
-	if (hdd_ctx->rps)
-		hdd_send_rps_ind(adapter);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_try_send_rps_ind(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
 
 	hdd_exit();
 

core/hdd/src/wlan_hdd_power.c

@@ -90,6 +90,7 @@
 #include "qdf_types.h"
 #include <linux/cpuidle.h>
 #include <cdp_txrx_ctrl.h>
+#include "wlan_dp_ucfg_api.h"
 
 /* Preprocessor definitions and constants */
 #ifdef QCA_WIFI_EMULATION
@@ -1695,6 +1696,8 @@ hdd_suspend_wlan(void)
 
 	hdd_ctx->hdd_wlan_suspended = true;
 
+	ucfg_dp_suspend_wlan(hdd_ctx->psoc);
+
 	hdd_configure_sar_sleep_index(hdd_ctx);
 
 	hdd_wlan_suspend_resume_event(HDD_WLAN_EARLY_SUSPEND);
@@ -1754,6 +1757,7 @@ static int hdd_resume_wlan(void)
 	}
 
 	ucfg_ipa_resume(hdd_ctx->pdev);
+	ucfg_dp_resume_wlan(hdd_ctx->psoc);
 	status = ucfg_pmo_psoc_user_space_resume_req(hdd_ctx->psoc,
 						     QDF_SYSTEM_SUSPEND);
 	if (QDF_IS_STATUS_ERROR(status))
@@ -2341,10 +2345,10 @@ static int __wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy)
 		goto exit_with_code;
 	}
 	/* Resume tlshim Rx thread */
-	if (hdd_ctx->enable_rxthread)
+	if (ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc))
 		wlan_hdd_rx_thread_resume(hdd_ctx);
 
-	if (hdd_ctx->enable_dp_rx_threads)
+	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc))
 		dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
 
 	if (ucfg_pkt_capture_get_mode(hdd_ctx->psoc) !=
@@ -2647,12 +2651,12 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	}
 	hdd_ctx->is_scheduler_suspended = true;
 
-	if (hdd_ctx->enable_rxthread) {
+	if (ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc)) {
 		if (wlan_hdd_rx_thread_suspend(hdd_ctx))
 			goto resume_ol_rx;
 	}
 
-	if (hdd_ctx->enable_dp_rx_threads) {
+	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc)) {
 		if (dp_txrx_suspend(cds_get_context(QDF_MODULE_ID_SOC)))
 			goto resume_ol_rx;
 	}
@@ -2691,7 +2695,7 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	return 0;
 
 resume_dp_thread:
-	if (hdd_ctx->enable_dp_rx_threads)
+	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc))
 		dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
 
 	/* Resume packet capture MON thread */

core/hdd/src/wlan_hdd_softap_tx_rx.c

@@ -43,6 +43,7 @@
 #include "wlan_p2p_ucfg_api.h"
 #include <wlan_hdd_regulatory.h>
 #include "wlan_ipa_ucfg_api.h"
+#include "wlan_dp_ucfg_api.h"
 #include "wlan_policy_mgr_ucfg.h"
 #include "wlan_mlme_twt_ucfg_api.h"
 #include <wma_types.h>
@@ -55,6 +56,7 @@
 #ifdef FEATURE_WDS
 #include <net/llc_pdu.h>
 #endif
+#include <os_if_dp.h>
 
 /* Preprocessor definitions and constants */
 #undef QCA_HDD_SAP_DUMP_SK_BUFF
@@ -697,101 +699,23 @@ static void __hdd_softap_hard_start_xmit(struct sk_buff *skb,
 	sme_ac_enum_type ac = SME_AC_BE;
 	struct hdd_adapter *adapter = (struct hdd_adapter *)netdev_priv(dev);
 	struct hdd_context *hdd_ctx = adapter->hdd_ctx;
-	struct qdf_mac_addr *dest_mac_addr;
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-	uint32_t num_seg;
 	struct hdd_tx_rx_stats *stats = &adapter->hdd_stats.tx_rx_stats;
 	int cpu = qdf_get_smp_processor_id();
-	uint16_t dump_level = cfg_get(hdd_ctx->psoc,
-				      CFG_ENABLE_DEBUG_PACKET_LOG);
-
-	dest_mac_addr = (struct qdf_mac_addr *)skb->data;
-	++stats->per_cpu[cpu].tx_called;
-	stats->cont_txtimeout_cnt = 0;
-
-	if (QDF_IS_STATUS_ERROR(hdd_softap_validate_driver_state(adapter)))
-		goto drop_pkt;
-
-	wlan_hdd_mark_pkt_type(skb);
-
-	hdd_pkt_add_timestamp(adapter, QDF_PKT_TX_DRIVER_ENTRY,
-			      qdf_get_log_timestamp(), skb);
-
-	if (QDF_IS_STATUS_ERROR(hdd_softap_validate_peer_state(adapter, skb)))
-		goto drop_pkt;
+	QDF_STATUS status;
 
-	hdd_softap_get_tx_resource(adapter, skb);
+	osif_dp_mark_pkt_type(skb);
 
 	/* Get TL AC corresponding to Qdisc queue index/AC. */
 	ac = hdd_qdisc_ac_to_tl_ac[skb->queue_mapping];
 	++stats->per_cpu[cpu].tx_classified_ac[ac];
 
-	skb = hdd_sap_skb_orphan(adapter, skb);
-	if (!skb)
-		goto drop_pkt_accounting;
-
-
-	qdf_net_buf_debug_acquire_skb(skb, __FILE__, __LINE__);
-
-	adapter->stats.tx_bytes += skb->len;
-
-	if (qdf_nbuf_is_tso(skb)) {
-		num_seg = qdf_nbuf_get_tso_num_seg(skb);
-		adapter->stats.tx_packets += num_seg;
-	} else {
-		++adapter->stats.tx_packets;
-		hdd_ctx->no_tx_offload_pkt_cnt++;
-	}
-
-	QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_NOTIFY_COMP(skb) = 0;
-
-	if (qdf_unlikely(QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-			 QDF_NBUF_CB_PACKET_TYPE_DHCP))
-		hdd_softap_inspect_dhcp_packet(adapter, skb, QDF_TX);
-
-	if (qdf_unlikely(QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-			 QDF_NBUF_CB_PACKET_TYPE_EAPOL)) {
-		hdd_softap_inspect_tx_eap_pkt(adapter, skb, false);
-		hdd_event_eapol_log(skb, QDF_TX);
-	}
-
-	if (qdf_unlikely(dump_level >= DEBUG_PKTLOG_TYPE_EAPOL))
-		hdd_debug_pkt_dump(skb, skb->len,  &dump_level);
-
-	hdd_softap_config_tx_pkt_tracing(adapter, skb);
-
-	/* check whether need to linearize skb, like non-linear udp data */
-	if (hdd_skb_nontso_linearize(skb) != QDF_STATUS_SUCCESS) {
-		hdd_sapd_debug_rl("skb %pK linearize failed. drop the pkt",
-				  skb);
-		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
-
-	if (adapter->tx_fn(soc, adapter->vdev_id, (qdf_nbuf_t)skb)) {
-		hdd_sapd_debug_rl("Failed to send packet to txrx for sta: "
-				  QDF_MAC_ADDR_FMT,
-				  QDF_MAC_ADDR_REF(dest_mac_addr->bytes));
+	status = ucfg_dp_softap_start_xmit((qdf_nbuf_t)skb, adapter->vdev);
+	if (QDF_IS_STATUS_ERROR(status))
 		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
 
 	netif_trans_update(dev);
 
 	wlan_hdd_sar_unsolicited_timer_start(hdd_ctx);
-
-	return;
-
-drop_pkt_and_release_skb:
-	qdf_net_buf_debug_release_skb(skb);
-drop_pkt:
-	qdf_dp_trace_data_pkt(skb, QDF_TRACE_DEFAULT_PDEV_ID,
-			      QDF_DP_TRACE_DROP_PACKET_RECORD, 0,
-			      QDF_TX);
-	kfree_skb(skb);
-drop_pkt_accounting:
-	++adapter->stats.tx_dropped;
-	++stats->per_cpu[cpu].tx_dropped;
 }
 
 netdev_tx_t hdd_softap_hard_start_xmit(struct sk_buff *skb,
@@ -820,8 +744,8 @@ static void __hdd_softap_tx_timeout(struct net_device *dev)
 {
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	struct hdd_context *hdd_ctx;
+	struct wlan_objmgr_vdev *vdev;
 	struct netdev_queue *txq;
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	int i;
 
 	DPTRACE(qdf_dp_trace(NULL, QDF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT,
@@ -857,26 +781,14 @@ static void __hdd_softap_tx_timeout(struct net_device *dev)
 
 	wlan_hdd_display_adapter_netif_queue_history(adapter);
 
-	cdp_dump_flow_pool_info(cds_get_context(QDF_MODULE_ID_SOC));
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_softap_tx_timeout(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
+
 	QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_DEBUG,
 			"carrier state: %d", netif_carrier_ok(dev));
-
-	++adapter->hdd_stats.tx_rx_stats.tx_timeout_cnt;
-	++adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt;
-
-	if (adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt >
-	    HDD_TX_STALL_THRESHOLD) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_ERROR,
-			  "Detected data stall due to continuous TX timeouts");
-		adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
-
-		if (hdd_is_data_stall_event_enabled(HDD_HOST_SAP_TX_TIMEOUT))
-			cdp_post_data_stall_event(soc,
-					  DATA_STALL_LOG_INDICATOR_HOST_DRIVER,
-					  DATA_STALL_LOG_HOST_SOFTAP_TX_TIMEOUT,
-					  OL_TXRX_PDEV_ID, 0xFF,
-					  DATA_STALL_LOG_RECOVERY_TRIGGER_PDR);
-	}
 }
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
@@ -1264,6 +1176,7 @@ QDF_STATUS hdd_softap_deregister_sta(struct hdd_adapter *adapter,
 	struct qdf_mac_addr *mac_addr;
 	struct hdd_station_info *sta = *sta_info;
 	struct hdd_ap_ctx *ap_ctx;
+	struct wlan_objmgr_vdev *vdev;
 
 	if (!adapter) {
 		hdd_err("NULL adapter");
@@ -1306,7 +1219,12 @@ QDF_STATUS hdd_softap_deregister_sta(struct hdd_adapter *adapter,
 			hdd_debug("WLAN_CLIENT_DISCONNECT event failed");
 	}
 
-	hdd_del_latency_critical_client(adapter, sta->dot11_mode);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return QDF_STATUS_E_INVAL;
+
+	ucfg_dp_del_latency_critical_client(vdev, sta->dot11_mode);
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 
 	ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(adapter);
 	if (!QDF_IS_ADDR_BROADCAST(sta->sta_mac.bytes) &&
@@ -1336,6 +1254,7 @@ QDF_STATUS hdd_softap_register_sta(struct hdd_adapter *adapter,
 	bool wmm_enabled = false;
 	enum qca_wlan_802_11_mode dot11mode = QCA_WLAN_802_11_MODE_INVALID;
 	bool is_macaddr_broadcast = false;
+	struct wlan_objmgr_vdev *vdev;
 
 	if (event) {
 		wmm_enabled = event->wmmEnabled;
@@ -1368,7 +1287,12 @@ QDF_STATUS hdd_softap_register_sta(struct hdd_adapter *adapter,
 	}
 
 	txrx_desc.is_qos_enabled = wmm_enabled;
-	hdd_add_latency_critical_client(adapter, dot11mode);
+
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return QDF_STATUS_E_INVAL;
+
+	ucfg_dp_add_latency_critical_client(vdev, dot11mode);
 
 	if (is_macaddr_broadcast) {
 		/*
@@ -1377,29 +1301,11 @@ QDF_STATUS hdd_softap_register_sta(struct hdd_adapter *adapter,
 		 * started.
 		 */
 		qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
-
-		txrx_ops.tx.tx_comp = hdd_softap_notify_tx_compl_cbk;
-
-		if (adapter->hdd_ctx->enable_dp_rx_threads) {
-			txrx_ops.rx.rx = hdd_rx_pkt_thread_enqueue_cbk;
-			txrx_ops.rx.rx_stack = hdd_softap_rx_packet_cbk;
-			txrx_ops.rx.rx_flush = hdd_rx_flush_packet_cbk;
-			txrx_ops.rx.rx_gro_flush =
-					hdd_rx_thread_gro_flush_ind_cbk;
-			adapter->rx_stack = hdd_softap_rx_packet_cbk;
-		} else {
-			txrx_ops.rx.rx = hdd_softap_rx_packet_cbk;
-		}
-
-		txrx_ops.get_tsf_time = hdd_get_tsf_time;
 		txrx_ops.tx.tx_classify_critical_pkt_cb =
 					hdd_wmm_classify_pkt_cb;
-		cdp_vdev_register(soc,
-				  adapter->vdev_id,
-				  (ol_osif_vdev_handle)adapter,
-				  &txrx_ops);
-		adapter->tx_fn = txrx_ops.tx.tx;
+		ucfg_dp_softap_register_txrx_ops(vdev, &txrx_ops);
 	}
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 
 	qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &txrx_desc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {

core/hdd/src/wlan_hdd_stats.c

@@ -46,6 +46,7 @@
 #include "cdp_txrx_misc.h"
 #include "cdp_txrx_host_stats.h"
 #include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)) && !defined(WITH_BACKPORTS)
 #define HDD_INFO_SIGNAL                 STATION_INFO_SIGNAL
@@ -6294,7 +6295,7 @@ struct net_device_stats *hdd_get_stats(struct net_device *dev)
 {
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 
-	return &adapter->stats;
+	return (struct net_device_stats *)ucfg_dp_get_dev_stats(&adapter->mac_addr);
 }
 
 

core/hdd/src/wlan_hdd_subnet_detect.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2015-2021 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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
@@ -32,6 +33,8 @@
 #include "wlan_hdd_main.h"
 #include "wlan_hdd_subnet_detect.h"
 #include <qca_vendor.h>
+#include "wlan_dp_ucfg_api.h"
+#include "wlan_hdd_object_manager.h"
 
 /*
  * define short names for the global vendor params
@@ -73,6 +76,7 @@ static int __wlan_hdd_cfg80211_set_gateway_params(struct wiphy *wiphy,
 	int ret;
 	QDF_STATUS status;
 	bool subnet_detection_enabled;
+	struct wlan_objmgr_vdev *vdev;
 
 	hdd_enter_dev(dev);
 
@@ -150,7 +154,11 @@ static int __wlan_hdd_cfg80211_set_gateway_params(struct wiphy *wiphy,
 		  req.ipv4_addr, req.ipv4_addr_type,
 		  req.ipv6_addr, req.ipv6_addr_type);
 
-	hdd_nud_set_gateway_addr(adapter, req.gw_mac_addr);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_nud_set_gateway_addr(vdev, req.gw_mac_addr);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	}
 
 	status = sme_gateway_param_update(hdd_ctx->mac_handle, &req);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {

core/hdd/src/wlan_hdd_sysfs_dp_aggregation.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 above
@@ -29,6 +30,7 @@
 #if defined(WLAN_SUPPORT_RX_FISA)
 #include "dp_fisa_rx.h"
 #endif
+#include "wlan_dp_ucfg_api.h"
 
 #if defined(WLAN_SUPPORT_RX_FISA)
 static inline
@@ -51,7 +53,7 @@ __hdd_sysfs_dp_aggregation_show(struct hdd_context *hdd_ctx,
 		return -EINVAL;
 
 	hdd_debug("dp_aggregation: %d",
-		  qdf_atomic_read(&hdd_ctx->dp_agg_param.rx_aggregation));
+		  ucfg_dp_get_rx_aggregation_val(hdd_ctx->psoc));
 
 	return 0;
 }
@@ -113,7 +115,7 @@ __hdd_sysfs_dp_aggregation_store(struct hdd_context *hdd_ctx,
 	hdd_debug("dp_aggregation: %d", value);
 
 	hdd_rx_skip_fisa(dp_soc, value);
-	qdf_atomic_set(&hdd_ctx->dp_agg_param.rx_aggregation, !!value);
+	ucfg_dp_set_rx_aggregation_val(hdd_ctx->psoc, !!value);
 
 	return count;
 }

core/hdd/src/wlan_hdd_sysfs_stats.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2011-2021, The Linux Foundation. All rights reserved.
- * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. 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 above
@@ -30,6 +30,8 @@
 #include <wlan_hdd_sysfs.h>
 #include "wlan_hdd_sysfs_stats.h"
 #include "cdp_txrx_stats.h"
+#include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 static int stats_id = -1;
 
@@ -37,6 +39,7 @@ static void hdd_sysfs_get_stats(struct hdd_adapter *adapter, ssize_t *length,
 				char *buffer, size_t buf_len)
 {
 	struct hdd_tx_rx_stats *stats = &adapter->hdd_stats.tx_rx_stats;
+	struct dp_tx_rx_stats dp_stats = {0};
 	uint32_t len = 0;
 	uint32_t total_rx_pkt = 0, total_rx_dropped = 0;
 	uint32_t total_rx_delv = 0, total_rx_refused = 0;
@@ -46,17 +49,32 @@ static void hdd_sysfs_get_stats(struct hdd_adapter *adapter, ssize_t *length,
 	uint32_t total_tx_classified_ac[WLAN_MAX_AC] = {0};
 	uint32_t total_tx_dropped_ac[WLAN_MAX_AC] = {0};
 	int i = 0;
-	uint8_t ac;
+	uint8_t ac, rx_ol_con = 0, rx_ol_low_tput = 0;
 	struct hdd_context *hdd_ctx = adapter->hdd_ctx;
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return;
+
+	if (ucfg_dp_get_txrx_stats(vdev, &dp_stats)) {
+		hdd_err("Unable to get stats from DP component");
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		return;
+	}
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+
+	ucfg_dp_get_disable_rx_ol_val(hdd_ctx->psoc,
+				      &rx_ol_con, &rx_ol_low_tput);
 
 	for (; i < NUM_CPUS; i++) {
-		total_rx_pkt += stats->per_cpu[i].rx_packets;
-		total_rx_dropped += stats->per_cpu[i].rx_dropped;
-		total_rx_delv += stats->per_cpu[i].rx_delivered;
-		total_rx_refused += stats->per_cpu[i].rx_refused;
-		total_tx_pkt += stats->per_cpu[i].tx_called;
-		total_tx_dropped += stats->per_cpu[i].tx_dropped;
-		total_tx_orphaned += stats->per_cpu[i].tx_orphaned;
+		total_rx_pkt += dp_stats.per_cpu[i].rx_packets;
+		total_rx_dropped += dp_stats.per_cpu[i].rx_dropped;
+		total_rx_delv += dp_stats.per_cpu[i].rx_delivered;
+		total_rx_refused += dp_stats.per_cpu[i].rx_refused;
+		total_tx_pkt += dp_stats.per_cpu[i].tx_called;
+		total_tx_dropped += dp_stats.per_cpu[i].tx_dropped;
+		total_tx_orphaned += dp_stats.per_cpu[i].tx_orphaned;
 		for (ac = 0; ac < WLAN_MAX_AC; ac++) {
 			total_tx_classified_ac[ac] +=
 					 stats->per_cpu[i].tx_classified_ac[ac];
@@ -87,25 +105,25 @@ static void hdd_sysfs_get_stats(struct hdd_adapter *adapter, ssize_t *length,
 			total_tx_classified_ac[SME_AC_VO],
 			qdf_system_ticks(),
 			total_rx_pkt, total_rx_dropped,
-			qdf_atomic_read(&stats->rx_usolict_arp_n_mcast_drp),
+			qdf_atomic_read(&dp_stats.rx_usolict_arp_n_mcast_drp),
 			total_rx_delv,
 			total_rx_refused,
-			stats->rx_aggregated, stats->rx_non_aggregated,
-			stats->rx_gro_flush_skip,
-			stats->rx_gro_low_tput_flush,
-			qdf_atomic_read(&hdd_ctx->disable_rx_ol_in_concurrency),
-			qdf_atomic_read(&hdd_ctx->disable_rx_ol_in_low_tput));
+			dp_stats.rx_aggregated, dp_stats.rx_non_aggregated,
+			dp_stats.rx_gro_flush_skip,
+			dp_stats.rx_gro_low_tput_flush,
+			rx_ol_con,
+			rx_ol_low_tput);
 
 	for (i = 0; i < NUM_CPUS; i++) {
-		if (stats->per_cpu[i].rx_packets == 0)
+		if (dp_stats.per_cpu[i].rx_packets == 0)
 			continue;
 		len += scnprintf(buffer + len, buf_len - len,
 				 "Rx CPU[%d]:"
 				 "packets %u, dropped %u, delivered %u, refused %u\n",
-				 i, stats->per_cpu[i].rx_packets,
-				 stats->per_cpu[i].rx_dropped,
-				 stats->per_cpu[i].rx_delivered,
-				 stats->per_cpu[i].rx_refused);
+				 i, dp_stats.per_cpu[i].rx_packets,
+				 dp_stats.per_cpu[i].rx_dropped,
+				 dp_stats.per_cpu[i].rx_delivered,
+				 dp_stats.per_cpu[i].rx_refused);
 	}
 
 	len += scnprintf(buffer + len, buf_len - len,

core/hdd/src/wlan_hdd_tx_rx.c

@@ -58,7 +58,6 @@
 #include <net/tcp.h>
 #include "wma_api.h"
 
-#include "wlan_hdd_nud_tracking.h"
 #include "dp_txrx.h"
 #if defined(WLAN_SUPPORT_RX_FISA)
 #include "dp_fisa_rx.h"
@@ -74,6 +73,8 @@
 #include <wlan_hdd_sar_limits.h>
 #include "wlan_hdd_object_manager.h"
 #include "wlan_hdd_mlo.h"
+#include "wlan_dp_ucfg_api.h"
+#include "os_if_dp.h"
 
 #ifdef TX_MULTIQ_PER_AC
 #if defined(QCA_LL_TX_FLOW_CONTROL_V2) || defined(QCA_LL_PDEV_TX_FLOW_CONTROL)
@@ -1146,6 +1147,24 @@ void hdd_pkt_add_timestamp(struct hdd_adapter *adapter,
 }
 #endif
 
+#ifdef QCA_WIFI_FTM
+static inline bool
+hdd_drop_tx_packet_on_ftm(struct sk_buff *skb)
+{
+	if (hdd_get_conparam() == QDF_GLOBAL_FTM_MODE) {
+		kfree_skb(skb);
+		return true;
+	}
+	return false;
+}
+#else
+static inline bool
+hdd_drop_tx_packet_on_ftm(struct sk_buff *skb)
+{
+	return false;
+}
+#endif
+
 /**
  * __hdd_hard_start_xmit() - Transmit a frame
  * @skb: pointer to OS packet (sk_buff)
@@ -1162,127 +1181,23 @@ void hdd_pkt_add_timestamp(struct hdd_adapter *adapter,
 static void __hdd_hard_start_xmit(struct sk_buff *skb,
 				  struct net_device *dev)
 {
-	QDF_STATUS status;
-	sme_ac_enum_type ac;
-	enum sme_qos_wmmuptype up;
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
-	bool granted;
-	struct qdf_mac_addr mac_addr_tx_allowed = QDF_MAC_ADDR_ZERO_INIT;
-	uint8_t pkt_type = 0;
-	bool is_arp = false;
-	struct hdd_context *hdd_ctx;
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-	enum qdf_proto_subtype subtype = QDF_PROTO_INVALID;
-	bool is_eapol = false;
-	bool is_dhcp = false;
 	struct hdd_tx_rx_stats *stats = &adapter->hdd_stats.tx_rx_stats;
+	struct hdd_station_ctx *sta_ctx = &adapter->session.station;
 	int cpu = qdf_get_smp_processor_id();
-	uint16_t dump_level;
+	bool granted;
+	sme_ac_enum_type ac;
+	enum sme_qos_wmmuptype up;
+	QDF_STATUS status;
 
-#ifdef QCA_WIFI_FTM
-	if (hdd_get_conparam() == QDF_GLOBAL_FTM_MODE) {
-		kfree_skb(skb);
+	if (hdd_drop_tx_packet_on_ftm(skb))
 		return;
-	}
-#endif
-
-	++stats->per_cpu[cpu].tx_called;
-	stats->cont_txtimeout_cnt = 0;
 
-	if (cds_is_driver_transitioning()) {
-		QDF_TRACE_DEBUG_RL(QDF_MODULE_ID_HDD_DATA,
-				   "Recovery/(Un)load in progress, dropping the packet");
-		goto drop_pkt;
-	}
-
-	hdd_ctx = adapter->hdd_ctx;
-
-	if (!hdd_ctx || hdd_ctx->hdd_wlan_suspended) {
-		hdd_err_rl("Device is system suspended, drop pkt");
-		goto drop_pkt;
-	}
-
-	dump_level = cfg_get(hdd_ctx->psoc, CFG_ENABLE_DEBUG_PACKET_LOG);
-
-	/*
-	 * wlan_hdd_mark_pkt_type zeros out skb->cb.  All skb->cb access
-	 * should be after it.
-	 */
-	wlan_hdd_mark_pkt_type(skb);
-	QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_NOTIFY_COMP(skb) = 1;
-
-	if (QDF_NBUF_CB_GET_PACKET_TYPE(skb) == QDF_NBUF_CB_PACKET_TYPE_ARP) {
-		if (qdf_nbuf_data_is_arp_req(skb) &&
-		    (adapter->track_arp_ip == qdf_nbuf_get_arp_tgt_ip(skb))) {
-			is_arp = true;
-			++adapter->hdd_stats.hdd_arp_stats.tx_arp_req_count;
-			QDF_TRACE(QDF_MODULE_ID_HDD_DATA,
-				  QDF_TRACE_LEVEL_INFO_HIGH,
-					"%s : ARP packet", __func__);
-		}
-	} else if (QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-		   QDF_NBUF_CB_PACKET_TYPE_EAPOL) {
-		subtype = qdf_nbuf_get_eapol_subtype(skb);
-		if (subtype == QDF_PROTO_EAPOL_M2) {
-			++adapter->hdd_stats.hdd_eapol_stats.eapol_m2_count;
-			is_eapol = true;
-		} else if (subtype == QDF_PROTO_EAPOL_M4) {
-			++adapter->hdd_stats.hdd_eapol_stats.eapol_m4_count;
-			is_eapol = true;
-		}
-	} else if (QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-		   QDF_NBUF_CB_PACKET_TYPE_DHCP) {
-		subtype = qdf_nbuf_get_dhcp_subtype(skb);
-		if (subtype == QDF_PROTO_DHCP_DISCOVER) {
-			++adapter->hdd_stats.hdd_dhcp_stats.dhcp_dis_count;
-			is_dhcp = true;
-		} else if (subtype == QDF_PROTO_DHCP_REQUEST) {
-			++adapter->hdd_stats.hdd_dhcp_stats.dhcp_req_count;
-			is_dhcp = true;
-		}
-	} else if ((QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-		   QDF_NBUF_CB_PACKET_TYPE_ICMP) ||
-		   (QDF_NBUF_CB_GET_PACKET_TYPE(skb) ==
-		   QDF_NBUF_CB_PACKET_TYPE_ICMPv6)) {
-		hdd_mark_icmp_req_to_fw(hdd_ctx, skb);
-	}
-
-	if (qdf_unlikely(dump_level >= DEBUG_PKTLOG_TYPE_EAPOL))
-		hdd_debug_pkt_dump(skb, skb->len, &dump_level);
-
-	hdd_pkt_add_timestamp(adapter, QDF_PKT_TX_DRIVER_ENTRY,
-			      qdf_get_log_timestamp(), skb);
-
-	/* track connectivity stats */
-	if (adapter->pkt_type_bitmap)
-		hdd_tx_rx_collect_connectivity_stats_info(skb, adapter,
-						PKT_TYPE_REQ, &pkt_type);
-
-	hdd_get_transmit_mac_addr(adapter, skb, &mac_addr_tx_allowed);
-	if (qdf_is_macaddr_zero(&mac_addr_tx_allowed)) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_INFO_HIGH,
-			  "tx not allowed, transmit operation suspended");
-		goto drop_pkt;
-	}
-
-	hdd_get_tx_resource(adapter, &mac_addr_tx_allowed,
-			    WLAN_HDD_TX_FLOW_CONTROL_OS_Q_BLOCK_TIME);
+	osif_dp_mark_pkt_type(skb);
 
 	/* Get TL AC corresponding to Qdisc queue index/AC. */
 	ac = hdd_qdisc_ac_to_tl_ac[skb->queue_mapping];
 
-	if (!qdf_nbuf_ipa_owned_get(skb)) {
-		skb = hdd_skb_orphan(adapter, skb);
-		if (!skb)
-			goto drop_pkt_accounting;
-	}
-
-	/*
-	 * Add SKB to internal tracking table before further processing
-	 * in WLAN driver.
-	 */
-	qdf_net_buf_debug_acquire_skb(skb, __FILE__, __LINE__);
-
 	/*
 	 * user priority from IP header, which is already extracted and set from
 	 * select_queue call back function
@@ -1310,13 +1225,13 @@ static void __hdd_hard_start_xmit(struct sk_buff *skb,
 	 */
 
 	if (((adapter->psb_changed & (1 << ac)) &&
-		likely(adapter->hdd_wmm_status.ac_status[ac].
+	     likely(adapter->hdd_wmm_status.ac_status[ac].
 			is_access_allowed)) ||
-		(!hdd_is_sta_authenticated(adapter) &&
-		 (QDF_NBUF_CB_PACKET_TYPE_EAPOL ==
-			QDF_NBUF_CB_GET_PACKET_TYPE(skb) ||
-		  QDF_NBUF_CB_PACKET_TYPE_WAPI ==
-			QDF_NBUF_CB_GET_PACKET_TYPE(skb)))) {
+	    ((!sta_ctx->conn_info.is_authenticated) &&
+	     (QDF_NBUF_CB_PACKET_TYPE_EAPOL ==
+	      QDF_NBUF_CB_GET_PACKET_TYPE(skb) ||
+	      QDF_NBUF_CB_PACKET_TYPE_WAPI ==
+	      QDF_NBUF_CB_GET_PACKET_TYPE(skb)))) {
 		granted = true;
 	} else {
 		status = hdd_wmm_acquire_access(adapter, ac, &granted);
@@ -1324,7 +1239,7 @@ static void __hdd_hard_start_xmit(struct sk_buff *skb,
 	}
 
 	if (!granted) {
-		bool isDefaultAc = false;
+		bool is_default_ac = false;
 		/*
 		 * ADDTS request for this AC is sent, for now
 		 * send this packet through next available lower
@@ -1349,111 +1264,29 @@ static void __hdd_hard_start_xmit(struct sk_buff *skb,
 			default:
 				ac = SME_AC_BK;
 				up = SME_QOS_WMM_UP_BK;
-				isDefaultAc = true;
+				is_default_ac = true;
 				break;
 			}
-			if (isDefaultAc)
+			if (is_default_ac)
 				break;
 		}
 		skb->priority = up;
 		skb->queue_mapping = hdd_linux_up_to_ac_map[up];
 	}
 
-	adapter->stats.tx_bytes += skb->len;
-
-	if (qdf_nbuf_is_tso(skb)) {
-		adapter->stats.tx_packets += qdf_nbuf_get_tso_num_seg(skb);
-	} else {
-		++adapter->stats.tx_packets;
-		hdd_ctx->no_tx_offload_pkt_cnt++;
-	}
-
-	hdd_event_eapol_log(skb, QDF_TX);
-	QDF_NBUF_CB_TX_PACKET_TRACK(skb) = QDF_NBUF_TX_PKT_DATA_TRACK;
-	QDF_NBUF_UPDATE_TX_PKT_COUNT(skb, QDF_NBUF_TX_PKT_HDD);
-
-	qdf_dp_trace_set_track(skb, QDF_TX);
-
-	DPTRACE(qdf_dp_trace(skb, QDF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD,
-			QDF_TRACE_DEFAULT_PDEV_ID, qdf_nbuf_data_addr(skb),
-			sizeof(qdf_nbuf_data(skb)),
-			QDF_TX));
-
-	if (!hdd_is_tx_allowed(adapter, skb,
-			       mac_addr_tx_allowed.bytes)) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA,
-			  QDF_TRACE_LEVEL_INFO_HIGH,
-			  FL("Tx not allowed for sta: "
-			  QDF_MAC_ADDR_FMT), QDF_MAC_ADDR_REF(
-			  mac_addr_tx_allowed.bytes));
-		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
-
-	/* check whether need to linearize skb, like non-linear udp data */
-	if (hdd_skb_nontso_linearize(skb) != QDF_STATUS_SUCCESS) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA,
-			  QDF_TRACE_LEVEL_INFO_HIGH,
-			  "%s: skb %pK linearize failed. drop the pkt",
-			  __func__, skb);
-		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
-
 	/*
-	 * If a transmit function is not registered, drop packet
+	 * adapter->vdev is directly dereferenced because this is per packet
+	 * path, hdd_get_vdev_by_user() usage will be very costly as it
+	 * involves lock access.
+	 * Expectation here is vdev will be present during TX/RX processing
+	 * and also DP internally maintaining vdev ref count
 	 */
-	if (!adapter->tx_fn) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_SAP_DATA, QDF_TRACE_LEVEL_INFO_HIGH,
-			 "%s: TX function not registered by the data path",
-			 __func__);
-		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
-
-	wlan_hdd_fix_broadcast_eapol(adapter, skb);
-
-	if (adapter->tx_fn(soc, adapter->vdev_id, (qdf_nbuf_t)skb)) {
-		hdd_dp_debug_rl("Failed to send packet from adapter %u",
-				adapter->vdev_id);
+	status = ucfg_dp_start_xmit((qdf_nbuf_t)skb, adapter->vdev);
+	if (QDF_IS_STATUS_SUCCESS(status)) {
+		netif_trans_update(dev);
+		wlan_hdd_sar_unsolicited_timer_start(adapter->hdd_ctx);
+	} else {
 		++stats->per_cpu[cpu].tx_dropped_ac[ac];
-		goto drop_pkt_and_release_skb;
-	}
-
-	netif_trans_update(dev);
-
-	wlan_hdd_sar_unsolicited_timer_start(hdd_ctx);
-
-	return;
-
-drop_pkt_and_release_skb:
-	qdf_net_buf_debug_release_skb(skb);
-drop_pkt:
-
-	/* track connectivity stats */
-	if (adapter->pkt_type_bitmap)
-		hdd_tx_rx_collect_connectivity_stats_info(skb, adapter,
-							  PKT_TYPE_TX_DROPPED,
-							  &pkt_type);
-	qdf_dp_trace_data_pkt(skb, QDF_TRACE_DEFAULT_PDEV_ID,
-			      QDF_DP_TRACE_DROP_PACKET_RECORD, 0,
-			      QDF_TX);
-	kfree_skb(skb);
-
-drop_pkt_accounting:
-
-	++adapter->stats.tx_dropped;
-	++stats->per_cpu[cpu].tx_dropped;
-	if (is_arp) {
-		++adapter->hdd_stats.hdd_arp_stats.tx_dropped;
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_INFO_HIGH,
-			"%s : ARP packet dropped", __func__);
-	} else if (is_eapol) {
-		++adapter->hdd_stats.hdd_eapol_stats.
-				tx_dropped[subtype - QDF_PROTO_EAPOL_M1];
-	} else if (is_dhcp) {
-		++adapter->hdd_stats.hdd_dhcp_stats.
-				tx_dropped[subtype - QDF_PROTO_DHCP_DISCOVER];
 	}
 }
 
@@ -1493,8 +1326,7 @@ static void __hdd_tx_timeout(struct net_device *dev)
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	struct hdd_context *hdd_ctx;
 	struct netdev_queue *txq;
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-	u64 diff_jiffies;
+	struct wlan_objmgr_vdev *vdev;
 	int i = 0;
 
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
@@ -1526,47 +1358,10 @@ static void __hdd_tx_timeout(struct net_device *dev)
 
 	wlan_hdd_display_adapter_netif_queue_history(adapter);
 
-	cdp_dump_flow_pool_info(cds_get_context(QDF_MODULE_ID_SOC));
-
-	++adapter->hdd_stats.tx_rx_stats.tx_timeout_cnt;
-	++adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt;
-
-	diff_jiffies = jiffies -
-		       adapter->hdd_stats.tx_rx_stats.jiffies_last_txtimeout;
-
-	if ((adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt > 1) &&
-	    (diff_jiffies > (HDD_TX_TIMEOUT * 2))) {
-		/*
-		 * In case when there is no traffic is running, it may
-		 * possible tx time-out may once happen and later system
-		 * recovered then continuous tx timeout count has to be
-		 * reset as it is gets modified only when traffic is running.
-		 * If over a period of time if this count reaches to threshold
-		 * then host triggers a false subsystem restart. In genuine
-		 * time out case kernel will call the tx time-out back to back
-		 * at interval of HDD_TX_TIMEOUT. Here now check if previous
-		 * TX TIME out has occurred more than twice of HDD_TX_TIMEOUT
-		 * back then host may recovered here from data stall.
-		 */
-		adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_DEBUG,
-			  "Reset continuous tx timeout stat");
-	}
-
-	adapter->hdd_stats.tx_rx_stats.jiffies_last_txtimeout = jiffies;
-
-	if (adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt >
-	    HDD_TX_STALL_THRESHOLD) {
-		QDF_TRACE(QDF_MODULE_ID_HDD_DATA, QDF_TRACE_LEVEL_ERROR,
-			  "Data stall due to continuous TX timeouts");
-		adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
-
-		if (hdd_is_data_stall_event_enabled(HDD_HOST_STA_TX_TIMEOUT))
-			cdp_post_data_stall_event(soc,
-					  DATA_STALL_LOG_INDICATOR_HOST_DRIVER,
-					  DATA_STALL_LOG_HOST_STA_TX_TIMEOUT,
-					  OL_TXRX_PDEV_ID, 0xFF,
-					  DATA_STALL_LOG_RECOVERY_TRIGGER_PDR);
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (vdev) {
+		ucfg_dp_tx_timeout(vdev);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
 	}
 }
 
@@ -2004,6 +1799,33 @@ out:
 	return status;
 }
 
+qdf_napi_struct
+*hdd_legacy_gro_get_napi(qdf_nbuf_t nbuf, bool enable_rxthread)
+{
+	struct qca_napi_info *qca_napii;
+	struct qca_napi_data *napid;
+	struct napi_struct *napi_to_use;
+
+	napid = hdd_napi_get_all();
+	if (unlikely(!napid))
+		return NULL;
+
+	qca_napii = hif_get_napi(QDF_NBUF_CB_RX_CTX_ID(nbuf), napid);
+	if (unlikely(!qca_napii))
+		return NULL;
+
+	/*
+	 * As we are breaking context in Rxthread mode, there is rx_thread NAPI
+	 * corresponds each hif_napi.
+	 */
+	if (enable_rxthread)
+		napi_to_use =  &qca_napii->rx_thread_napi;
+	else
+		napi_to_use = &qca_napii->napi;
+
+	return (qdf_napi_struct *)napi_to_use;
+}
+
 /**
  * hdd_rxthread_napi_gro_flush() - GRO flush callback for NAPI+Rx_Thread Rx mode
  * @data: hif NAPI context
@@ -2174,41 +1996,9 @@ void hdd_rx_handle_concurrency(bool is_concurrency)
 	if (!hdd_ctx)
 		return;
 
-	if (hdd_ctx->is_wifi3_0_target) {
-		/*
-		 * Donot disable rx offload on concurrency for lithium and
-		 * beryllium based targets
-		 */
-		if (is_concurrency)
-			qdf_atomic_set(&hdd_ctx->rx_skip_qdisc_chk_conc, 1);
-		else
-			qdf_atomic_set(&hdd_ctx->rx_skip_qdisc_chk_conc, 0);
-
-		return;
-	}
-
-	if (!hdd_ctx->ol_enable)
-		return;
-
-	if (is_concurrency) {
-		if (HDD_MSM_CFG(hdd_ctx->config->enable_tcp_delack)) {
-			struct wlan_rx_tp_data rx_tp_data;
-
-			hdd_info("Enable TCP delack as LRO disabled in concurrency");
-			rx_tp_data.rx_tp_flags = TCP_DEL_ACK_IND;
-			rx_tp_data.level = GET_CUR_RX_LVL(hdd_ctx);
-			wlan_hdd_update_tcp_rx_param(hdd_ctx, &rx_tp_data);
-			hdd_ctx->en_tcp_delack_no_lro = 1;
-		}
-		qdf_atomic_set(&hdd_ctx->disable_rx_ol_in_concurrency, 1);
-	} else {
-		if (HDD_MSM_CFG(hdd_ctx->config->enable_tcp_delack)) {
-			hdd_info("Disable TCP delack as LRO is enabled");
-			hdd_ctx->en_tcp_delack_no_lro = 0;
-			hdd_reset_tcp_delack(hdd_ctx);
-		}
-		qdf_atomic_set(&hdd_ctx->disable_rx_ol_in_concurrency, 0);
-	}
+	ucfg_dp_rx_handle_concurrency(hdd_ctx->psoc,
+				      hdd_ctx->is_wifi3_0_target,
+				      is_concurrency);
 }
 
 void hdd_disable_rx_ol_for_low_tput(struct hdd_context *hdd_ctx, bool disable)
@@ -3477,16 +3267,26 @@ int hdd_set_mon_rx_cb(struct net_device *dev)
 	int ret;
 	QDF_STATUS qdf_status;
 	struct ol_txrx_desc_type sta_desc = {0};
-	struct ol_txrx_ops txrx_ops;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+	struct wlan_objmgr_vdev *vdev;
 
 	WLAN_ADDR_COPY(sta_desc.peer_addr.bytes, adapter->mac_addr.bytes);
-	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
-	txrx_ops.rx.rx = hdd_mon_rx_packet_cbk;
-	hdd_monitor_set_rx_monitor_cb(&txrx_ops, hdd_rx_monitor_callback);
-	cdp_vdev_register(soc, adapter->vdev_id,
-			  (ol_osif_vdev_handle)adapter,
-			  &txrx_ops);
+
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev) {
+		hdd_err("failed to get vdev");
+		return -EINVAL;
+	}
+
+	qdf_status = ucfg_dp_mon_register_txrx_ops(vdev);
+	if (QDF_STATUS_SUCCESS != qdf_status) {
+		hdd_err("failed to register txrx ops. Status= %d [0x%08X]",
+			qdf_status, qdf_status);
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		goto exit;
+	}
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+
 	/* peer is created wma_vdev_attach->wma_create_peer */
 	qdf_status = cdp_peer_register(soc, OL_TXRX_PDEV_ID, &sta_desc);
 	if (QDF_STATUS_SUCCESS != qdf_status) {

core/hdd/src/wlan_hdd_wext.c

@@ -114,6 +114,8 @@
 #include "wlan_hdd_unit_test.h"
 #include "wlan_hdd_thermal.h"
 #include "wlan_cm_roam_ucfg_api.h"
+#include "wlan_hdd_object_manager.h"
+#include "wlan_dp_ucfg_api.h"
 
 /* Private ioctls and their sub-ioctls */
 #define WLAN_PRIV_SET_INT_GET_NONE    (SIOCIWFIRSTPRIV + 0)
@@ -2788,6 +2790,7 @@ void hdd_wlan_get_stats(struct hdd_adapter *adapter, uint16_t *length,
 			char *buffer, uint16_t buf_len)
 {
 	struct hdd_tx_rx_stats *stats = &adapter->hdd_stats.tx_rx_stats;
+	struct dp_tx_rx_stats dp_stats = {0};
 	uint32_t len = 0;
 	uint32_t total_rx_pkt = 0, total_rx_dropped = 0;
 	uint32_t total_rx_delv = 0, total_rx_refused = 0;
@@ -2797,17 +2800,32 @@ void hdd_wlan_get_stats(struct hdd_adapter *adapter, uint16_t *length,
 	uint32_t total_tx_classified_ac[WLAN_MAX_AC] = {0};
 	uint32_t total_tx_dropped_ac[WLAN_MAX_AC] = {0};
 	int i = 0;
-	uint8_t ac;
+	uint8_t ac, rx_ol_con = 0, rx_ol_low_tput = 0;
 	struct hdd_context *hdd_ctx = adapter->hdd_ctx;
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
+	if (!vdev)
+		return;
+
+	if (ucfg_dp_get_txrx_stats(adapter->vdev, &dp_stats)) {
+		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		hdd_err("Unable to get stats from DP component");
+		return;
+	}
+	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+
+	ucfg_dp_get_disable_rx_ol_val(hdd_ctx->psoc,
+				      &rx_ol_con, &rx_ol_low_tput);
 
 	for (; i < NUM_CPUS; i++) {
-		total_rx_pkt += stats->per_cpu[i].rx_packets;
-		total_rx_dropped += stats->per_cpu[i].rx_dropped;
-		total_rx_delv += stats->per_cpu[i].rx_delivered;
-		total_rx_refused += stats->per_cpu[i].rx_refused;
-		total_tx_pkt += stats->per_cpu[i].tx_called;
-		total_tx_dropped += stats->per_cpu[i].tx_dropped;
-		total_tx_orphaned += stats->per_cpu[i].tx_orphaned;
+		total_rx_pkt += dp_stats.per_cpu[i].rx_packets;
+		total_rx_dropped += dp_stats.per_cpu[i].rx_dropped;
+		total_rx_delv += dp_stats.per_cpu[i].rx_delivered;
+		total_rx_refused += dp_stats.per_cpu[i].rx_refused;
+		total_tx_pkt += dp_stats.per_cpu[i].tx_called;
+		total_tx_dropped += dp_stats.per_cpu[i].tx_dropped;
+		total_tx_orphaned += dp_stats.per_cpu[i].tx_orphaned;
 		for (ac = 0; ac < WLAN_MAX_AC; ac++) {
 			total_tx_classified_ac[ac] +=
 					 stats->per_cpu[i].tx_classified_ac[ac];
@@ -2838,25 +2856,25 @@ void hdd_wlan_get_stats(struct hdd_adapter *adapter, uint16_t *length,
 			total_tx_classified_ac[SME_AC_VO],
 			qdf_system_ticks(),
 			total_rx_pkt, total_rx_dropped,
-			qdf_atomic_read(&stats->rx_usolict_arp_n_mcast_drp),
+			qdf_atomic_read(&dp_stats.rx_usolict_arp_n_mcast_drp),
 			total_rx_delv,
 			total_rx_refused,
-			stats->rx_aggregated, stats->rx_non_aggregated,
-			stats->rx_gro_flush_skip,
-			stats->rx_gro_low_tput_flush,
-			qdf_atomic_read(&hdd_ctx->disable_rx_ol_in_concurrency),
-			qdf_atomic_read(&hdd_ctx->disable_rx_ol_in_low_tput));
+			dp_stats.rx_aggregated, dp_stats.rx_non_aggregated,
+			dp_stats.rx_gro_flush_skip,
+			dp_stats.rx_gro_low_tput_flush,
+			rx_ol_con,
+			rx_ol_low_tput);
 
 	for (i = 0; i < NUM_CPUS; i++) {
-		if (stats->per_cpu[i].rx_packets == 0)
+		if (dp_stats.per_cpu[i].rx_packets == 0)
 			continue;
 		len += scnprintf(buffer + len, buf_len - len,
 				 "Rx CPU[%d]:"
 				 "packets %u, dropped %u, delivered %u, refused %u\n",
-				 i, stats->per_cpu[i].rx_packets,
-				 stats->per_cpu[i].rx_dropped,
-				 stats->per_cpu[i].rx_delivered,
-				 stats->per_cpu[i].rx_refused);
+				 i, dp_stats.per_cpu[i].rx_packets,
+				 dp_stats.per_cpu[i].rx_dropped,
+				 dp_stats.per_cpu[i].rx_delivered,
+				 dp_stats.per_cpu[i].rx_refused);
 	}
 
 	len += scnprintf(buffer + len, buf_len - len,

core/hdd/src/wlan_hdd_wmm.c

@@ -1806,7 +1806,6 @@ hdd_check_and_upgrade_udp_qos(struct hdd_adapter *adapter,
 
 /**
  * hdd_wmm_classify_critical_pkt() - Function checks and classifies critical skb
- * @adapter: adapter for which skb is being transmitted
  * @skb: pointer to network buffer
  * @user_pri: user priority of the OS packet to be determined
  * @is_critical: pointer to be marked true for a critical packet
@@ -1822,8 +1821,7 @@ hdd_check_and_upgrade_udp_qos(struct hdd_adapter *adapter,
  * Return: None
  */
 static
-void hdd_wmm_classify_critical_pkt(struct hdd_adapter *adapter,
-				   struct sk_buff *skb,
+void hdd_wmm_classify_critical_pkt(struct sk_buff *skb,
 				   enum sme_qos_wmmuptype *user_pri,
 				   bool *is_critical)
 {
@@ -1990,7 +1988,7 @@ void hdd_wmm_classify_pkt(struct hdd_adapter *adapter,
 			  enum sme_qos_wmmuptype *user_pri,
 			  bool *is_critical)
 {
-	hdd_wmm_classify_critical_pkt(adapter, skb, user_pri, is_critical);
+	hdd_wmm_classify_critical_pkt(skb, user_pri, is_critical);
 
 	if (!is_critical) {
 		hdd_wmm_get_user_priority_from_ip_tos(adapter, skb, user_pri);
@@ -2005,7 +2003,7 @@ void hdd_wmm_classify_pkt_cb(void *adapter,
 	enum sme_qos_wmmuptype user_pri;
 	bool is_critical;
 
-	hdd_wmm_classify_critical_pkt(adapter, skb, &user_pri, &is_critical);
+	hdd_wmm_classify_critical_pkt(skb, &user_pri, &is_critical);
 
 	if (is_critical) {
 		skb->priority = user_pri;