Revert "qcacld-3.0: Update HDD to use DP component APIs"

This reverts commit I02fd36c45ec247fbd4fe79e035c1176cba3ebcec.

Change-Id: I26758565ac783b9c76b59eee6c2a526c68646fa5
CRs-Fixed: 3196571

core/cds/inc/cds_api.h

@@ -563,6 +563,14 @@ 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,7 +85,6 @@
 #include <qwlan_version.h>
 #include <qdf_trace.h>
 #include <qdf_nbuf.h>
-#include "wlan_dp_ucfg_api.h"
 
 /* Preprocessor Definitions and Constants */
 
@@ -444,6 +443,7 @@ 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 = ucfg_dp_is_rx_common_thread_enabled(psoc);
+	cdp_cfg.enable_rxthread = hdd_ctx->enable_rxthread;
 	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))
-		ucfg_dp_set_force_gro_enable(psoc, true);
+		hdd_ctx->dp_agg_param.force_gro_enable = true;
 	else
-		ucfg_dp_set_force_gro_enable(psoc, false);
+		hdd_ctx->dp_agg_param.force_gro_enable = false;
 
 	return 0;
 
@@ -2823,6 +2823,22 @@ 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-2022, 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,7 +55,6 @@
 #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)					\
@@ -948,7 +947,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 = wlan_dp_intf_get_pkt_type_bitmap_value(tx_desc->vdev);
+	pkt_type_bitmap = cds_get_connectivity_stats_pkt_bitmap(osif_dev);
 
 	if (pkt_type_bitmap) {
 		if (status != htt_tx_status_download_fail)

core/hdd/src/wlan_hdd_assoc.c

@@ -92,7 +92,6 @@
 #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
@@ -289,7 +288,6 @@ 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;
 
@@ -298,12 +296,6 @@ 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);
 
@@ -1239,8 +1231,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))
@@ -1265,17 +1257,40 @@ QDF_STATUS hdd_roam_register_sta(struct hdd_adapter *adapter,
 		txrx_desc.is_wapi_supported = 0;
 #endif /* FEATURE_WLAN_WAPI */
 
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (!vdev)
-		return QDF_STATUS_E_INVAL;
+	/* Register the vdev transmit and receive functions */
+	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
 
-	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;
+	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;
+	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;
 	}
 
+	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]",
@@ -1530,8 +1545,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
@@ -1542,17 +1557,41 @@ QDF_STATUS hdd_roam_register_tdlssta(struct hdd_adapter *adapter,
 	/* set the QoS field appropriately .. */
 	txrx_desc.is_qos_enabled = qos;
 
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (!vdev)
-		return QDF_STATUS_E_INVAL;
+	/* 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);
+	}
 
-	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;
+	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);
+
+	if (!txrx_ops.tx.tx) {
+		hdd_err("vdev register fail");
+		return QDF_STATUS_E_FAILURE;
 	}
 
+	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,9 +180,6 @@
 #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)
@@ -8414,19 +8411,12 @@ static int hdd_config_listen_interval(struct hdd_adapter *adapter,
 static int hdd_config_lro(struct hdd_adapter *adapter,
 			  const struct nlattr *attr)
 {
-	struct wlan_objmgr_vdev *vdev;
+	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	uint8_t enable_flag;
-	QDF_STATUS status = QDF_STATUS_E_FAULT;
 
 	enable_flag = nla_get_u8(attr);
 
-	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);
+	return hdd_lro_set_reset(hdd_ctx, adapter, enable_flag);
 }
 
 static int hdd_config_scan_enable(struct hdd_adapter *adapter,
@@ -8914,7 +8904,6 @@ 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;
@@ -8930,22 +8919,14 @@ 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)
-		ucfg_dp_set_high_bus_bw_request(hdd_ctx->psoc,
-						adapter->vdev_id, true);
+		hdd_ctx->high_bus_bw_request |= (1 << adapter->vdev_id);
 	else
-		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;
+		hdd_ctx->high_bus_bw_request &= ~(1 << adapter->vdev_id);
 
 	if (latency_host_flags & WLM_HOST_RX_THREAD_FLAG)
-		ucfg_dp_runtime_disable_rx_thread(vdev, true);
+		adapter->runtime_disable_rx_thread = true;
 	else
-		ucfg_dp_runtime_disable_rx_thread(vdev, false);
-
-	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+		adapter->runtime_disable_rx_thread = false;
 }
 
 #ifdef MULTI_CLIENT_LL_SUPPORT
@@ -15346,11 +15327,13 @@ 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 wlan_objmgr_vdev *vdev;
+	struct set_arp_stats_params arp_stats_params = {0};
 	int err = 0;
+	mac_handle_t mac_handle;
 
 	hdd_enter();
 
@@ -15381,13 +15364,81 @@ static int __wlan_hdd_cfg80211_set_nud_stats(struct wiphy *wiphy,
 	if (hdd_is_roaming_in_progress(hdd_ctx))
 		return -EINVAL;
 
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (!vdev)
-		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;
+	}
 
-	err = osif_dp_set_nud_stats(wiphy, vdev, data, data_len);
+	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;
 
-	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+			/*
+			 * 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);
+
+	arp_stats_params.vdev_id = adapter->vdev_id;
+
+	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_exit();
 
@@ -15795,7 +15846,17 @@ 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 wlan_objmgr_vdev *vdev;
+	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;
 
 	hdd_enter();
 
@@ -15817,14 +15878,102 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (!vdev)
-		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_dp_get_nud_stats(wiphy, vdev, data, data_len);
+	err = osif_request_wait_for_response(request);
+	if (err) {
+		hdd_err("SME timedout while retrieving NUD stats");
+		err = -ETIMEDOUT;
+		goto exit;
+	}
 
-	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	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);
 
+	/* ARP tracking is done above. */
+	pkt_type_bitmap &= ~CONNECTIVITY_CHECK_SET_ARP;
+
+	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;
 }
 
@@ -21012,16 +21161,9 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 								     param)))
 			goto fn_end;
 	} else {
-		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);
-			}
-		}
+		if (param->reason_code == REASON_1X_AUTH_FAILURE)
+			hdd_softap_check_wait_for_tx_eap_pkt(
+					adapter, (struct qdf_mac_addr *)mac);
 
 		sta_info = hdd_get_sta_info_by_mac(
 						&adapter->sta_info_list,

core/hdd/src/wlan_hdd_cm_connect.c

@@ -52,7 +52,6 @@
 #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)
 {
@@ -261,12 +260,13 @@ 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));
-	ucfg_dp_add_latency_critical_client(vdev,
+	hdd_add_latency_critical_client(
+			adapter,
 			hdd_convert_cfgdot11mode_to_80211mode(
 				sta_ctx->conn_info.dot11mode));
 
-	ucfg_dp_bus_bw_compute_prev_txrx_stats(vdev);
-	ucfg_dp_bus_bw_compute_timer_start(hdd_ctx->psoc);
+	hdd_bus_bw_compute_prev_txrx_stats(adapter);
+	hdd_bus_bw_compute_timer_start(hdd_ctx);
 
 	if (ucfg_pkt_capture_get_pktcap_mode(hdd_ctx->psoc))
 		ucfg_pkt_capture_record_channel(adapter->vdev);
@@ -704,7 +704,6 @@ 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");
@@ -743,7 +742,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);
-	ucfg_dp_periodic_sta_stats_start(vdev);
+	hdd_periodic_sta_stats_start(adapter);
 	wlan_twt_concurrency_update(hdd_ctx);
 }
 
@@ -964,7 +963,6 @@ 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);
@@ -973,11 +971,6 @@ 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);
@@ -1037,10 +1030,10 @@ static void hdd_cm_save_connect_info(struct hdd_adapter *adapter,
 		return;
 	}
 	if (bcn_ie->ExtCap.present) {
-		p_ext_cap = (struct s_ext_cap *)bcn_ie->ExtCap.bytes;
+		struct s_ext_cap *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);
@@ -1050,11 +1043,6 @@ 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);
@@ -1314,7 +1302,7 @@ hdd_cm_connect_success_pre_user_update(struct wlan_objmgr_vdev *vdev,
 		QDF_PROTO_TYPE_MGMT, QDF_PROTO_MGMT_ASSOC));
 
 	if (is_roam)
-		ucfg_dp_nud_indicate_roam(vdev);
+		hdd_nud_indicate_roam(adapter);
 	 /* hdd_objmgr_set_peer_mlme_auth_state */
 }
 
@@ -1356,7 +1344,7 @@ hdd_cm_connect_success_post_user_update(struct wlan_objmgr_vdev *vdev,
 				      &rsp->bssid,
 				      TWT_ALL_SESSIONS_DIALOG_ID);
 	}
-	ucfg_dp_periodic_sta_stats_start(vdev);
+	hdd_periodic_sta_stats_start(adapter);
 	wlan_twt_concurrency_update(hdd_ctx);
 }
 
@@ -1532,13 +1520,7 @@ static void hdd_update_hlp_info(struct net_device *dev,
 	 */
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-	/*
-	 * 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);
+	status = hdd_rx_packet_cbk(adapter, skb);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Sending HLP packet fails");
 		return;

core/hdd/src/wlan_hdd_cm_disconnect.c

@@ -49,7 +49,6 @@
 #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)
@@ -57,7 +56,6 @@ 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);
 
@@ -73,17 +71,13 @@ void hdd_handle_disassociation_event(struct hdd_adapter *adapter,
 
 	hdd_lpass_notify_disconnect(adapter);
 
-	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);
+	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);
 	cdp_display_txrx_hw_info(soc);
 }
 
@@ -124,7 +118,6 @@ 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);
@@ -139,12 +132,7 @@ void __hdd_cm_disconnect_handler_pre_user_update(struct hdd_adapter *adapter)
 				  sta_ctx->conn_info.bssid.bytes,
 				  false);
 
-	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);
-	}
-
+	hdd_periodic_sta_stats_stop(adapter);
 	wlan_hdd_auto_shutdown_enable(hdd_ctx, true);
 
 	DPTRACE(qdf_dp_trace_mgmt_pkt(QDF_DP_TRACE_MGMT_PACKET_RECORD,
@@ -190,8 +178,6 @@ 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,
@@ -210,9 +196,9 @@ void __hdd_cm_disconnect_handler_post_user_update(struct hdd_adapter *adapter,
 	}
 	wlan_hdd_clear_link_layer_stats(adapter);
 
-	ucfg_dp_reset_cont_txtimeout_cnt(vdev);
+	adapter->hdd_stats.tx_rx_stats.cont_txtimeout_cnt = 0;
 
-	ucfg_dp_nud_reset_tracking(vdev);
+	hdd_nud_reset_tracking(adapter);
 	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_dp_ucfg_api.h"
+#include "wlan_hdd_bus_bandwidth.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 = ucfg_dp_get_current_throughput_level(hdd_ctx->psoc);
+		ret = hdd_get_current_throughput_level(hdd_ctx);
 
 	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 *)ucfg_dp_get_napi_enabled(hdd_ctx->psoc));
+				(void *)hdd_ctx->napi_enable);
 		}
 	}
 
@@ -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);
-	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+	hdd_bus_bw_compute_timer_stop(hdd_ctx);
 
 	/* 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;
 
-	ucfg_dp_wait_complete_tasks();
+	hdd_wait_for_dp_tx();
 	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;
-	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+	hdd_bbm_apply_independent_policy(hdd_ctx, &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;
-	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+	hdd_bbm_apply_independent_policy(hdd_ctx, &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)
-		ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+		hdd_bus_bw_compute_timer_stop(hdd_ctx);
 
 	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))
-			ucfg_dp_bus_bw_compute_timer_try_start(hdd_ctx->psoc);
+			hdd_bus_bw_compute_timer_try_start(hdd_ctx);
 	}
 
 	hdd_debug("Runtime resume done");

core/hdd/src/wlan_hdd_hostapd.c

@@ -2109,12 +2109,6 @@ 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);
@@ -2128,11 +2122,6 @@ 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 {
@@ -2187,11 +2176,6 @@ 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);
@@ -2275,12 +2259,6 @@ 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);
@@ -2344,13 +2322,6 @@ 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,
@@ -2414,13 +2385,6 @@ 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,
@@ -2600,12 +2564,8 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 
 		/* start timer in sap/p2p_go */
 		if (ap_ctx->ap_active == false) {
-			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);
+			hdd_bus_bw_compute_prev_txrx_stats(adapter);
+			hdd_bus_bw_compute_timer_start(hdd_ctx);
 		}
 		ap_ctx->ap_active = true;
 
@@ -2750,12 +2710,14 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 			}
 		}
 
-		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);
-		}
+		/* 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;
 
 		hdd_softap_deregister_sta(adapter, &stainfo);
 		hdd_put_sta_info_ref(&adapter->sta_info_list, &stainfo, true,
@@ -2829,12 +2791,8 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 
 		/*stop timer in sap/p2p_go */
 		if (ap_ctx->ap_active == false) {
-			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_bus_bw_compute_reset_prev_txrx_stats(adapter);
+			hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
 		}
 		hdd_son_deliver_assoc_disassoc_event(adapter,
 						     disassoc_comp->staMac,
@@ -3020,15 +2978,8 @@ QDF_STATUS hdd_hostapd_sap_event_cb(struct sap_event *sap_event,
 		 * channel flag to identify if the channel is DFS
 		 */
 		if (!wlan_reg_is_dfs_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 ==
@@ -3073,12 +3024,6 @@ 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
@@ -3133,7 +3078,7 @@ stopbss:
 		 */
 		if (eSAP_STOP_BSS_EVENT == event_id) {
 			qdf_event_set(&hostapd_state->qdf_stop_bss_event);
-			ucfg_dp_bus_bw_compute_timer_try_stop(hdd_ctx->psoc);
+			hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
 		}
 
 		hdd_ipa_set_tx_flow_info();
@@ -4072,7 +4017,6 @@ 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();
 
@@ -4142,9 +4086,7 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
 	qdf_atomic_init(&adapter->cache_sta_count);
 
 	/* Initialize the data path module */
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (vdev)
-		ucfg_dp_softap_init_txrx(vdev);
+	hdd_softap_init_tx_rx(adapter);
 
 	status = hdd_wmm_adapter_init(adapter);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -4169,8 +4111,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 && vdev)
-		wlan_vdev_mlme_feat_ext_cap_set(vdev,
+	if (is_6g_sap_fd_enabled)
+		wlan_vdev_mlme_feat_ext_cap_set(adapter->vdev,
 						WLAN_VDEV_FEXT_FILS_DISC_6G_SAP);
 
 	hdd_set_netdev_flags(adapter);
@@ -4188,19 +4130,13 @@ 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);
-	if (vdev) {
-		ucfg_dp_softap_deinit_txrx(vdev);
-		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
-	}
+	hdd_softap_deinit_tx_rx(adapter);
 error_deinit_sap_session:
 	hdd_hostapd_deinit_sap_session(adapter);
 error_release_vdev:
@@ -4212,8 +4148,6 @@ 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)) {
@@ -4229,12 +4163,7 @@ void hdd_deinit_ap_mode(struct hdd_context *hdd_ctx,
 		wlan_hdd_enable_roaming(adapter, RSO_SAP_CHANNEL_CHANGE);
 	}
 
-	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);
-	}
-
+	hdd_softap_deinit_tx_rx(adapter);
 	if (hdd_hostapd_deinit_sap_session(adapter))
 		hdd_err("Failed:hdd_hostapd_deinit_sap_session");
 
@@ -6404,8 +6333,6 @@ 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,7 +47,6 @@
 #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
 
@@ -962,7 +961,7 @@ static __iw_softap_setparam(struct net_device *dev,
 					sizeof(adapter->hdd_stats));
 			break;
 		case CDP_TXRX_HIST_STATS:
-			ucfg_wlan_dp_clear_tx_rx_histogram(hdd_ctx->psoc);
+			wlan_hdd_clear_tx_rx_histogram(hdd_ctx);
 			break;
 		case CDP_HDD_NETIF_OPER_HISTORY:
 			wlan_hdd_clear_netif_queue_history(hdd_ctx);

core/hdd/src/wlan_hdd_ipa.c

@@ -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;
-	bool delivered = false;
+	unsigned int cpu_index;
 	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)
-		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);
+		++stats->per_cpu[cpu_index].rx_delivered;
+	else
+		++stats->per_cpu[cpu_index].rx_refused;
+
 	/*
 	 * 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;
-		ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
-		ucfg_dp_set_current_throughput_level(hdd_ctx->psoc,
-						     PLD_BUS_WIDTH_VERY_HIGH);
+		hdd_bbm_apply_independent_policy(hdd_ctx, &param);
+		hdd_set_current_throughput_level(hdd_ctx,
+						 PLD_BUS_WIDTH_VERY_HIGH);
 	}
 
 	return ret;
@@ -3158,7 +3158,6 @@ 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);
@@ -3173,20 +3172,24 @@ static int __hdd_pktcapture_open(struct net_device *dev)
 		return -EINVAL;
 	}
 
-	vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
-	if (!vdev)
+	adapter->vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
+	if (!adapter->vdev) {
+		hdd_err("station interface is not up");
 		return -EINVAL;
+	}
 
 	hdd_mon_mode_ether_setup(dev);
 
-	status = ucfg_dp_register_pkt_capture_callbacks(vdev);
+	status = ucfg_pkt_capture_register_callbacks(adapter->vdev,
+						     hdd_mon_rx_packet_cbk,
+						     adapter);
 	ret = qdf_status_to_os_return(status);
 	if (ret) {
-		hdd_objmgr_put_vdev_by_user(vdev, WLAN_OSIF_ID);
+		hdd_objmgr_put_vdev_by_user(adapter->vdev, WLAN_OSIF_ID);
+		adapter->vdev = NULL;
 		return ret;
 	}
 
-	adapter->vdev = vdev;
 	set_bit(DEVICE_IFACE_OPENED, &adapter->event_flags);
 	sta_adapter->mon_adapter = adapter;
 
@@ -3250,7 +3253,6 @@ 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);
@@ -3267,20 +3269,21 @@ static void hdd_map_monitor_interface_vdev(struct hdd_adapter *sta_adapter)
 	if (!wlan_hdd_is_session_type_monitor(mon_adapter->device_mode))
 		return;
 
-	vdev = hdd_objmgr_get_vdev_by_user(sta_adapter, WLAN_OSIF_ID);
-	if (!vdev)
-		return;
+	mon_adapter->vdev = hdd_objmgr_get_vdev_by_user(sta_adapter,
+							WLAN_OSIF_ID);
 
-	status = ucfg_dp_register_pkt_capture_callbacks(vdev);
+	status = ucfg_pkt_capture_register_callbacks(mon_adapter->vdev,
+						     hdd_mon_rx_packet_cbk,
+						     mon_adapter);
 	ret = qdf_status_to_os_return(status);
 	if (ret) {
 		hdd_err("Failed registering packet capture callbacks");
-		hdd_objmgr_put_vdev_by_user(vdev,
+		hdd_objmgr_put_vdev_by_user(mon_adapter->vdev,
 					    WLAN_OSIF_ID);
+		mon_adapter->vdev = NULL;
 		return;
 	}
 
-	mon_adapter->vdev = vdev;
 	sta_adapter->mon_adapter = mon_adapter;
 }
 
@@ -4355,7 +4358,7 @@ static int hdd_register_notifiers(struct hdd_context *hdd_ctx)
 		goto unregister_ip6_notifier;
 	}
 
-	ret = osif_dp_nud_register_netevent_notifier(hdd_ctx->psoc);
+	ret = hdd_nud_register_netevent_notifier(hdd_ctx);
 	if (ret) {
 		hdd_err("Failed to register netevent notifier: %d",
 			ret);
@@ -4802,7 +4805,8 @@ 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_dp_reg_ipa_rsp_ind(hdd_ctx->pdev);
+	ucfg_ipa_reg_rps_enable_cb(hdd_ctx->pdev,
+				   hdd_adapter_set_rps);
 
 	if (!pld_get_thermal_state(hdd_ctx->parent_dev, &thermal_state,
 				   THERMAL_MONITOR_APPS)) {
@@ -6808,7 +6812,6 @@ 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;
@@ -6838,16 +6841,10 @@ 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;
 
-	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);
+	status = hdd_init_tx_rx(adapter);
 	if (QDF_STATUS_SUCCESS != status) {
-		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
-		hdd_err("ucfg_dp_init_tx_rx() failed, status code %d", status);
+		hdd_err("hdd_init_tx_rx() failed, status code %08d [x%08x]",
+			status, status);
 		goto error_init_txrx;
 	}
 
@@ -6896,13 +6893,11 @@ 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);
-	ucfg_dp_deinit_txrx(vdev);
-	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	hdd_deinit_tx_rx(adapter);
 error_init_txrx:
 	hdd_unregister_wext(adapter->dev);
 	QDF_BUG(!hdd_vdev_destroy(adapter));
@@ -7919,6 +7914,7 @@ 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);
@@ -8008,14 +8004,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.
 	 */
-	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+	hdd_bus_bw_compute_timer_stop(hdd_ctx);
 
 	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 */
-	ucfg_dp_bus_bw_compute_timer_try_start(hdd_ctx->psoc);
+	hdd_bus_bw_compute_timer_try_start(hdd_ctx);
 }
 
 void hdd_close_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held)
@@ -8231,6 +8227,10 @@ 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);
@@ -9706,7 +9706,7 @@ static QDF_STATUS hdd_abort_sched_scan_all_adapters(struct hdd_context *hdd_ctx)
  */
 void hdd_unregister_notifiers(struct hdd_context *hdd_ctx)
 {
-	osif_dp_nud_unregister_netevent_notifier(hdd_ctx->psoc);
+	hdd_nud_unregister_netevent_notifier(hdd_ctx);
 	hdd_wlan_unregister_ip6_notifier(hdd_ctx);
 
 	unregister_inetaddr_notifier(&hdd_ctx->ipv4_notifier);
@@ -9826,7 +9826,7 @@ static int hdd_context_deinit(struct hdd_context *hdd_ctx)
 
 	wlan_hdd_cfg80211_deinit(hdd_ctx->wiphy);
 
-	ucfg_dp_bbm_context_deinit(hdd_ctx->psoc);
+	hdd_bbm_context_deinit(hdd_ctx);
 
 	hdd_sap_context_destroy(hdd_ctx);
 
@@ -9896,7 +9896,7 @@ void hdd_wlan_exit(struct hdd_context *hdd_ctx)
 
 	hdd_enter();
 
-	ucfg_dp_wait_complete_tasks();
+	hdd_wait_for_dp_tx();
 	wlan_hdd_destroy_mib_stats_lock();
 	hdd_debugfs_ini_config_deinit(hdd_ctx);
 	hdd_debugfs_mws_coex_info_deinit(hdd_ctx);
@@ -11219,7 +11219,6 @@ 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,12 +11234,10 @@ 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 * bus_bw_compute_interval >=
+	if (adapter->mscs_counter * hdd_ctx->config->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);
@@ -12094,7 +12091,7 @@ int hdd_wlan_dump_stats(struct hdd_adapter *adapter, int stats_id)
 
 	switch (stats_id) {
 	case CDP_TXRX_HIST_STATS:
-		ucfg_wlan_dp_display_tx_rx_histogram(hdd_ctx->psoc);
+		wlan_hdd_display_tx_rx_histogram(hdd_ctx);
 		break;
 	case CDP_HDD_NETIF_OPER_HISTORY:
 		wlan_hdd_display_adapter_netif_queue_history(adapter);
@@ -12144,7 +12141,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:
-		ucfg_wlan_dp_clear_tx_rx_histogram(adapter->hdd_ctx->psoc);
+		wlan_hdd_clear_tx_rx_histogram(adapter->hdd_ctx);
 		break;
 	case CDP_HDD_NETIF_OPER_HISTORY:
 		wlan_hdd_clear_netif_queue_history(adapter->hdd_ctx);
@@ -13418,7 +13415,7 @@ static int hdd_context_init(struct hdd_context *hdd_ctx)
 	if (ret)
 		goto scan_destroy;
 
-	ret = ucfg_dp_bbm_context_init(hdd_ctx->psoc);
+	ret = hdd_bbm_context_init(hdd_ctx);
 	if (ret)
 		goto sap_destroy;
 
@@ -13437,7 +13434,7 @@ static int hdd_context_init(struct hdd_context *hdd_ctx)
 	return 0;
 
 bbm_destroy:
-	ucfg_dp_bbm_context_deinit(hdd_ctx->psoc);
+	hdd_bbm_context_deinit(hdd_ctx);
 
 sap_destroy:
 	hdd_sap_context_destroy(hdd_ctx);
@@ -14318,8 +14315,7 @@ 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 =
-		ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc);
+	cds_cfg->enable_dp_rx_threads = hdd_ctx->enable_dp_rx_threads;
 }
 #else
 static inline void hdd_txrx_populate_cds_config(struct cds_config_info
@@ -14394,8 +14390,7 @@ 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 =
-		ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc);
+	cds_cfg->enable_rxthread = hdd_ctx->enable_rxthread;
 	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;
@@ -15033,7 +15028,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 */
-	ucfg_dp_register_rx_mic_error_ind_handler(soc);
+	cdp_register_rx_mic_error_ind_handler(soc, hdd_rx_mic_error_ind);
 
 	/*
 	 * Note that the cds_pre_enable() sequence triggers the cfg download.
@@ -15476,7 +15471,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 (ucfg_dp_rx_ol_init(hdd_ctx->psoc, hdd_ctx->is_wifi3_0_target))
+	if (hdd_rx_ol_init(hdd_ctx))
 		hdd_err("Unable to initialize Rx LRO/GRO in fw");
 
 	if (hdd_adaptive_dwelltime_init(hdd_ctx))
@@ -15864,7 +15859,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 = ucfg_dp_set_rx_mode_rps;
+	dp_cbs.hdd_set_rx_mode_rps_cb = hdd_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;
@@ -15999,12 +15994,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);
 
-			ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+			hdd_bus_bw_compute_timer_stop(hdd_ctx);
 			return -EAGAIN;
 		}
 	}
 
-	ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+	hdd_bus_bw_compute_timer_stop(hdd_ctx);
 	hdd_deregister_policy_manager_callback(hdd_ctx->psoc);
 
 	/* free user wowl patterns */
@@ -16154,7 +16149,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;
-	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
 
 	hdd_deinit_adapter_ops_wq(hdd_ctx);
 	hdd_bus_bandwidth_deinit(hdd_ctx);
@@ -16780,7 +16775,8 @@ QDF_STATUS hdd_psoc_create_vdevs(struct hdd_context *hdd_ctx)
 		return status;
 	}
 
-	ucfg_dp_try_set_rps_cpu_mask(hdd_ctx->psoc);
+	if (hdd_ctx->rps)
+		hdd_set_rps_cpu_mask(hdd_ctx);
 
 	if (driver_mode != QDF_GLOBAL_FTM_MODE &&
 	    driver_mode != QDF_GLOBAL_EPPING_MODE)
@@ -17579,7 +17575,7 @@ exit:
 	}
 	param.policy = BBM_TPUT_POLICY;
 	param.policy_info.tput_level = TPUT_LEVEL_NONE;
-	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
 
 }
 
@@ -19110,7 +19106,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;
-	ucfg_dp_bbm_apply_independent_policy(hdd_ctx->psoc, &param);
+	hdd_bbm_apply_independent_policy(hdd_ctx, &param);
 
 	return 0;
 }
@@ -19431,7 +19427,7 @@ void hdd_driver_unload(void)
 		 * Runtime PM sync resume may have started the bus bandwidth
 		 * periodic work hence stop it.
 		 */
-		ucfg_dp_bus_bw_compute_timer_stop(hdd_ctx->psoc);
+		hdd_bus_bw_compute_timer_stop(hdd_ctx);
 	}
 
 	/*

core/hdd/src/wlan_hdd_nan_datapath.c

@@ -43,7 +43,6 @@
 #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
@@ -609,7 +608,6 @@ 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) {
@@ -633,16 +631,9 @@ int hdd_init_nan_data_mode(struct hdd_adapter *adapter)
 	hdd_roam_profile_init(adapter);
 	hdd_register_wext(wlan_dev);
 
-	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);
+	status = hdd_init_tx_rx(adapter);
 	if (QDF_STATUS_SUCCESS != status) {
-		hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
-		hdd_err("ucfg_dp_init_tx_rx() init failed, status %d", status);
+		hdd_err("hdd_init_tx_rx() init failed, status %d", status);
 		ret_val = -EAGAIN;
 		goto error_init_txrx;
 	}
@@ -672,13 +663,11 @@ 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);
-	ucfg_dp_deinit_txrx(vdev);
-	hdd_objmgr_put_vdev_by_user(vdev, WLAN_DP_ID);
+	hdd_deinit_tx_rx(adapter);
 
 error_init_txrx:
 	hdd_unregister_wext(wlan_dev);
@@ -1041,7 +1030,6 @@ 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)
@@ -1078,18 +1066,14 @@ 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 (ucfg_dp_is_ol_enabled(hdd_ctx->psoc) &&
+		if (hdd_ctx->ol_enable &&
 		    !NAN_CONCURRENCY_SUPPORTED(hdd_ctx->psoc)) {
 			hdd_debug("Disable LRO/GRO in NDI Mode");
 			hdd_rx_handle_concurrency(true);
 		}
 
-		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);
+		hdd_bus_bw_compute_prev_txrx_stats(adapter);
+		hdd_bus_bw_compute_timer_start(hdd_ctx);
 		sta_ctx->conn_info.conn_state = eConnectionState_NdiConnected;
 		hdd_wmm_connect(adapter, roam_info, eCSR_BSS_TYPE_NDI);
 		wlan_hdd_netif_queue_control(
@@ -1113,7 +1097,6 @@ 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");
@@ -1126,13 +1109,9 @@ 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);
-	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) &&
+	hdd_bus_bw_compute_reset_prev_txrx_stats(adapter);
+	hdd_bus_bw_compute_timer_try_stop(hdd_ctx);
+	if ((hdd_ctx->ol_enable &&
 	     !NAN_CONCURRENCY_SUPPORTED(hdd_ctx->psoc)) &&
 	    ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 0) ||
 	     ((policy_mgr_get_connection_count(hdd_ctx->psoc) == 1) &&
@@ -1141,9 +1120,7 @@ void hdd_cleanup_ndi(struct hdd_context *hdd_ctx,
 						PM_STA_MODE,
 						NULL) == 1)))) {
 		hdd_debug("Enable LRO/GRO");
-		ucfg_dp_rx_handle_concurrency(hdd_ctx->psoc,
-					      hdd_ctx->is_wifi3_0_target,
-					      false);
+		hdd_rx_handle_concurrency(false);
 	}
 }
 

core/hdd/src/wlan_hdd_napi.c

@@ -30,7 +30,6 @@
 #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;
@@ -140,7 +139,7 @@ int hdd_napi_create(void)
 	}
 
 	rc = hdd_napi_event(NAPI_EVT_INI_FILE,
-			    (void *)ucfg_dp_get_napi_enabled(hdd_ctx->psoc));
+			    (void *)hdd_ctx->napi_enable);
 	napid->user_cpu_affin_mask =
 		hdd_ctx->config->napi_cpu_affinity_mask;
 

core/hdd/src/wlan_hdd_nud_tracking.c

@@ -23,7 +23,6 @@
 
 #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>
@@ -339,7 +338,7 @@ static void __hdd_nud_failure_work(struct hdd_adapter *adapter)
 	}
 
 	if (adapter->device_mode == QDF_STA_MODE &&
-	    ucfg_dp_is_roam_after_nud_enabled(hdd_ctx->psoc)) {
+	    hdd_is_roam_after_nud_enabled(hdd_ctx->config)) {
 		hdd_handle_nud_fail_sta(hdd_ctx, adapter);
 		return;
 	}

core/hdd/src/wlan_hdd_ocb.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2011-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2022 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
@@ -44,7 +44,6 @@
 #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)
@@ -221,8 +220,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);
@@ -234,16 +233,14 @@ 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;
 
-	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_DP_ID);
-	if (!vdev)
-		return -EINVAL;
+	/* Register the vdev transmit and receive functions */
+	qdf_mem_zero(&txrx_ops, sizeof(txrx_ops));
+	txrx_ops.rx.rx = hdd_rx_packet_cbk;
 
-	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;
-	}
+	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 = 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,7 +54,6 @@
 #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)
@@ -818,11 +817,8 @@ struct wireless_dev *__wlan_hdd_add_virtual_intf(struct wiphy *wiphy,
 		goto close_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);
-	}
+	if (hdd_ctx->rps)
+		hdd_send_rps_ind(adapter);
 
 	hdd_exit();
 

core/hdd/src/wlan_hdd_power.c

@@ -90,7 +90,6 @@
 #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
@@ -1696,8 +1695,6 @@ 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);
@@ -1757,7 +1754,6 @@ 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))
@@ -2345,10 +2341,10 @@ static int __wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy)
 		goto exit_with_code;
 	}
 	/* Resume tlshim Rx thread */
-	if (ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc))
+	if (hdd_ctx->enable_rxthread)
 		wlan_hdd_rx_thread_resume(hdd_ctx);
 
-	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc))
+	if (hdd_ctx->enable_dp_rx_threads)
 		dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
 
 	if (ucfg_pkt_capture_get_mode(hdd_ctx->psoc) !=
@@ -2651,12 +2647,12 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	}
 	hdd_ctx->is_scheduler_suspended = true;
 
-	if (ucfg_dp_is_rx_common_thread_enabled(hdd_ctx->psoc)) {
+	if (hdd_ctx->enable_rxthread) {
 		if (wlan_hdd_rx_thread_suspend(hdd_ctx))
 			goto resume_ol_rx;
 	}
 
-	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc)) {
+	if (hdd_ctx->enable_dp_rx_threads) {
 		if (dp_txrx_suspend(cds_get_context(QDF_MODULE_ID_SOC)))
 			goto resume_ol_rx;
 	}
@@ -2695,7 +2691,7 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	return 0;
 
 resume_dp_thread:
-	if (ucfg_dp_is_rx_threads_enabled(hdd_ctx->psoc))
+	if (hdd_ctx->enable_dp_rx_threads)
 		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,7 +43,6 @@
 #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>
@@ -56,7 +55,6 @@
 #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
@@ -699,23 +697,101 @@ 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();
-	QDF_STATUS status;
+	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);
 
-	osif_dp_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;
+
+	hdd_softap_get_tx_resource(adapter, 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];
 
-	status = ucfg_dp_softap_start_xmit((qdf_nbuf_t)skb, adapter->vdev);
-	if (QDF_IS_STATUS_ERROR(status))
+	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));
+		++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,
@@ -744,8 +820,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,
@@ -781,14 +857,26 @@ static void __hdd_softap_tx_timeout(struct net_device *dev)
 
 	wlan_hdd_display_adapter_netif_queue_history(adapter);
 
-	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);
-	}
-
+	cdp_dump_flow_pool_info(cds_get_context(QDF_MODULE_ID_SOC));
 	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))
@@ -1176,7 +1264,6 @@ 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");
@@ -1219,12 +1306,7 @@ QDF_STATUS hdd_softap_deregister_sta(struct hdd_adapter *adapter,
 			hdd_debug("WLAN_CLIENT_DISCONNECT event failed");
 	}
 
-	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);
+	hdd_del_latency_critical_client(adapter, sta->dot11_mode);
 
 	ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(adapter);
 	if (!QDF_IS_ADDR_BROADCAST(sta->sta_mac.bytes) &&
@@ -1254,7 +1336,6 @@ 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;
@@ -1287,12 +1368,7 @@ QDF_STATUS hdd_softap_register_sta(struct hdd_adapter *adapter,
 	}
 
 	txrx_desc.is_qos_enabled = wmm_enabled;
-
-	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);
+	hdd_add_latency_critical_client(adapter, dot11mode);
 
 	if (is_macaddr_broadcast) {
 		/*
@@ -1301,11 +1377,29 @@ 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;
-		ucfg_dp_softap_register_txrx_ops(vdev, &txrx_ops);
+		cdp_vdev_register(soc,
+				  adapter->vdev_id,
+				  (ol_osif_vdev_handle)adapter,
+				  &txrx_ops);
+		adapter->tx_fn = txrx_ops.tx.tx;
 	}
-	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,7 +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"
+#include "wlan_hdd_eht.h"
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)) && !defined(WITH_BACKPORTS)
 #define HDD_INFO_SIGNAL                 STATION_INFO_SIGNAL
@@ -6450,7 +6450,7 @@ struct net_device_stats *hdd_get_stats(struct net_device *dev)
 {
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
 
-	return (struct net_device_stats *)ucfg_dp_get_dev_stats(&adapter->mac_addr);
+	return &adapter->stats;
 }
 
 

core/hdd/src/wlan_hdd_subnet_detect.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2015-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2022 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
@@ -33,8 +33,6 @@
 #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
@@ -76,7 +74,6 @@ 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);
 
@@ -154,11 +151,7 @@ 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);
 
-	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);
-	}
+	hdd_nud_set_gateway_addr(adapter, req.gw_mac_addr);
 
 	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

@@ -30,7 +30,6 @@
 #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
@@ -53,7 +52,7 @@ __hdd_sysfs_dp_aggregation_show(struct hdd_context *hdd_ctx,
 		return -EINVAL;
 
 	hdd_debug("dp_aggregation: %d",
-		  ucfg_dp_get_rx_aggregation_val(hdd_ctx->psoc));
+		  qdf_atomic_read(&hdd_ctx->dp_agg_param.rx_aggregation));
 
 	return 0;
 }
@@ -115,7 +114,7 @@ __hdd_sysfs_dp_aggregation_store(struct hdd_context *hdd_ctx,
 	hdd_debug("dp_aggregation: %d", value);
 
 	hdd_rx_skip_fisa(dp_soc, value);
-	ucfg_dp_set_rx_aggregation_val(hdd_ctx->psoc, !!value);
+	qdf_atomic_set(&hdd_ctx->dp_agg_param.rx_aggregation, !!value);
 
 	return count;
 }

core/hdd/src/wlan_hdd_sysfs_stats.c

@@ -30,8 +30,6 @@
 #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;
 
@@ -39,7 +37,6 @@ 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;
@@ -49,32 +46,17 @@ 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, rx_ol_con = 0, rx_ol_low_tput = 0;
+	uint8_t ac;
 	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 += 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;
+		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;
 		for (ac = 0; ac < WLAN_MAX_AC; ac++) {
 			total_tx_classified_ac[ac] +=
 					 stats->per_cpu[i].tx_classified_ac[ac];
@@ -105,25 +87,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(&dp_stats.rx_usolict_arp_n_mcast_drp),
+			qdf_atomic_read(&stats->rx_usolict_arp_n_mcast_drp),
 			total_rx_delv,
 			total_rx_refused,
-			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);
+			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));
 
 	for (i = 0; i < NUM_CPUS; i++) {
-		if (dp_stats.per_cpu[i].rx_packets == 0)
+		if (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, 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);
+				 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);
 	}
 
 	len += scnprintf(buffer + len, buf_len - len,

core/hdd/src/wlan_hdd_tx_rx.c

@@ -58,6 +58,7 @@
 #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"
@@ -73,8 +74,6 @@
 #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)
@@ -1147,24 +1146,6 @@ 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)
@@ -1181,23 +1162,127 @@ hdd_drop_tx_packet_on_ftm(struct sk_buff *skb)
 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();
-	bool granted;
-	sme_ac_enum_type ac;
-	enum sme_qos_wmmuptype up;
-	QDF_STATUS status;
+	uint16_t dump_level;
 
-	if (hdd_drop_tx_packet_on_ftm(skb))
+#ifdef QCA_WIFI_FTM
+	if (hdd_get_conparam() == QDF_GLOBAL_FTM_MODE) {
+		kfree_skb(skb);
 		return;
+	}
+#endif
+
+	++stats->per_cpu[cpu].tx_called;
+	stats->cont_txtimeout_cnt = 0;
 
-	osif_dp_mark_pkt_type(skb);
+	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);
 
 	/* 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
@@ -1225,13 +1310,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)) ||
-	    ((!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)))) {
+		(!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)))) {
 		granted = true;
 	} else {
 		status = hdd_wmm_acquire_access(adapter, ac, &granted);
@@ -1239,7 +1324,7 @@ static void __hdd_hard_start_xmit(struct sk_buff *skb,
 	}
 
 	if (!granted) {
-		bool is_default_ac = false;
+		bool isDefaultAc = false;
 		/*
 		 * ADDTS request for this AC is sent, for now
 		 * send this packet through next available lower
@@ -1264,29 +1349,111 @@ static void __hdd_hard_start_xmit(struct sk_buff *skb,
 			default:
 				ac = SME_AC_BK;
 				up = SME_QOS_WMM_UP_BK;
-				is_default_ac = true;
+				isDefaultAc = true;
 				break;
 			}
-			if (is_default_ac)
+			if (isDefaultAc)
 				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;
+	}
+
 	/*
-	 * 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 a transmit function is not registered, drop packet
 	 */
-	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 {
+	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);
 		++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];
 	}
 }
 
@@ -1326,7 +1493,8 @@ 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;
-	struct wlan_objmgr_vdev *vdev;
+	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+	u64 diff_jiffies;
 	int i = 0;
 
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
@@ -1358,10 +1526,47 @@ static void __hdd_tx_timeout(struct net_device *dev)
 
 	wlan_hdd_display_adapter_netif_queue_history(adapter);
 
-	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);
+	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);
 	}
 }
 
@@ -1799,33 +2004,6 @@ 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
@@ -1996,9 +2174,41 @@ void hdd_rx_handle_concurrency(bool is_concurrency)
 	if (!hdd_ctx)
 		return;
 
-	ucfg_dp_rx_handle_concurrency(hdd_ctx->psoc,
-				      hdd_ctx->is_wifi3_0_target,
-				      is_concurrency);
+	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);
+	}
 }
 
 void hdd_disable_rx_ol_for_low_tput(struct hdd_context *hdd_ctx, bool disable)
@@ -3267,26 +3477,16 @@ 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);
-
-	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);
-
+	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);
 	/* 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,8 +114,6 @@
 #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)
@@ -2790,7 +2788,6 @@ 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;
@@ -2800,32 +2797,17 @@ 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, rx_ol_con = 0, rx_ol_low_tput = 0;
+	uint8_t ac;
 	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 += 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;
+		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;
 		for (ac = 0; ac < WLAN_MAX_AC; ac++) {
 			total_tx_classified_ac[ac] +=
 					 stats->per_cpu[i].tx_classified_ac[ac];
@@ -2856,25 +2838,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(&dp_stats.rx_usolict_arp_n_mcast_drp),
+			qdf_atomic_read(&stats->rx_usolict_arp_n_mcast_drp),
 			total_rx_delv,
 			total_rx_refused,
-			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);
+			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));
 
 	for (i = 0; i < NUM_CPUS; i++) {
-		if (dp_stats.per_cpu[i].rx_packets == 0)
+		if (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, 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);
+				 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);
 	}
 
 	len += scnprintf(buffer + len, buf_len - len,

core/hdd/src/wlan_hdd_wmm.c

@@ -1806,6 +1806,7 @@ 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
@@ -1821,7 +1822,8 @@ hdd_check_and_upgrade_udp_qos(struct hdd_adapter *adapter,
  * Return: None
  */
 static
-void hdd_wmm_classify_critical_pkt(struct sk_buff *skb,
+void hdd_wmm_classify_critical_pkt(struct hdd_adapter *adapter,
+				   struct sk_buff *skb,
 				   enum sme_qos_wmmuptype *user_pri,
 				   bool *is_critical)
 {
@@ -1988,7 +1990,7 @@ void hdd_wmm_classify_pkt(struct hdd_adapter *adapter,
 			  enum sme_qos_wmmuptype *user_pri,
 			  bool *is_critical)
 {
-	hdd_wmm_classify_critical_pkt(skb, user_pri, is_critical);
+	hdd_wmm_classify_critical_pkt(adapter, skb, user_pri, is_critical);
 
 	if (!is_critical) {
 		hdd_wmm_get_user_priority_from_ip_tos(adapter, skb, user_pri);
@@ -2003,7 +2005,7 @@ void hdd_wmm_classify_pkt_cb(void *adapter,
 	enum sme_qos_wmmuptype user_pri;
 	bool is_critical;
 
-	hdd_wmm_classify_critical_pkt(skb, &user_pri, &is_critical);
+	hdd_wmm_classify_critical_pkt(adapter, skb, &user_pri, &is_critical);
 
 	if (is_critical) {
 		skb->priority = user_pri;