diff --git a/Kbuild b/Kbuild
index 081a726ff945..71021715cea4 100644
--- a/Kbuild
+++ b/Kbuild
@@ -53,7 +53,6 @@ HDD_OBJS := 	$(HDD_SRC_DIR)/wlan_hdd_assoc.o \
 		$(HDD_SRC_DIR)/wlan_hdd_p2p.o \
 		$(HDD_SRC_DIR)/wlan_hdd_power.o \
 		$(HDD_SRC_DIR)/wlan_hdd_regulatory.o \
-		$(HDD_SRC_DIR)/wlan_hdd_request_manager.o \
 		$(HDD_SRC_DIR)/wlan_hdd_scan.o \
 		$(HDD_SRC_DIR)/wlan_hdd_softap_tx_rx.o \
 		$(HDD_SRC_DIR)/wlan_hdd_stats.o \
diff --git a/core/hdd/src/wlan_hdd_apf.c b/core/hdd/src/wlan_hdd_apf.c
index 980c81126242..c19b4e4b877a 100644
--- a/core/hdd/src/wlan_hdd_apf.c
+++ b/core/hdd/src/wlan_hdd_apf.c
@@ -24,7 +24,7 @@
 
 #include "wlan_hdd_apf.h"
 #include "qca_vendor.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 
 struct hdd_apf_context apf_context;
 
@@ -84,21 +84,21 @@ struct apf_offload_priv {
 void hdd_get_apf_capabilities_cb(void *context,
 				 struct sir_apf_get_offload *data)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct apf_offload_priv *priv;
 
 	hdd_enter();
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->apf_get_offload = *data;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -159,21 +159,21 @@ static int hdd_get_apf_capabilities(struct hdd_context *hdd_ctx)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct apf_offload_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_APF,
 	};
 
 	hdd_enter();
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Unable to allocate request");
 		return -EINVAL;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_get_apf_capabilities(hdd_ctx->mac_handle,
 					  hdd_get_apf_capabilities_cb,
@@ -183,12 +183,12 @@ static int hdd_get_apf_capabilities(struct hdd_context *hdd_ctx)
 		ret = qdf_status_to_os_return(status);
 		goto cleanup;
 	}
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("Target response timed out");
 		goto cleanup;
 	}
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	ret = hdd_post_get_apf_capabilities_rsp(hdd_ctx,
 						&priv->apf_get_offload);
 	if (ret)
@@ -201,7 +201,7 @@ cleanup:
 	 * response from SME, and posted the response to userspace.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 	hdd_exit();
 
 	return ret;
diff --git a/core/hdd/src/wlan_hdd_cfg80211.c b/core/hdd/src/wlan_hdd_cfg80211.c
index 595f79a3dac0..c6e6bdc55acf 100644
--- a/core/hdd/src/wlan_hdd_cfg80211.c
+++ b/core/hdd/src/wlan_hdd_cfg80211.c
@@ -88,7 +88,7 @@
 #include "wlan_hdd_lpass.h"
 #include "wlan_hdd_nan_datapath.h"
 #include "wlan_hdd_disa.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "wlan_hdd_he.h"
 #ifdef FEATURE_WLAN_APF
 #include "wlan_hdd_apf.h"
@@ -11611,7 +11611,7 @@ struct hdd_sar_context {
 static void hdd_sar_cb(void *cookie,
 		       struct sar_limit_event *event)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_sar_context *context;
 
 	hdd_enter();
@@ -11621,16 +11621,16 @@ static void hdd_sar_cb(void *cookie,
 		return;
 	}
 
-	request = hdd_request_get(cookie);
+	request = osif_request_get(cookie);
 	if (!request) {
 		hdd_debug("Obsolete request");
 		return;
 	}
 
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 	context->event = *event;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 
 	hdd_exit();
 }
@@ -11768,13 +11768,13 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
 					   const void *data, int data_len)
 {
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_sar_context *context;
 	mac_handle_t mac_handle;
 	void *cookie;
 	QDF_STATUS status;
 	int ret;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*context),
 		.timeout_ms = WLAN_WAIT_TIME_SAR,
 	};
@@ -11789,13 +11789,13 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
 	if (wlan_hdd_validate_context(hdd_ctx))
 		return -EINVAL;
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
 
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	mac_handle = hdd_ctx->mac_handle;
 	status = sme_get_sar_power_limits(mac_handle, hdd_sar_cb, cookie);
@@ -11805,17 +11805,17 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
 		goto cleanup;
 	}
 
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("Target response timed out");
 		goto cleanup;
 	}
 
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 	ret = hdd_sar_send_response(wiphy, &context->event);
 
 cleanup:
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return ret;
 }
@@ -13114,8 +13114,8 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	uint32_t pkt_type_bitmap;
 	struct sk_buff *skb;
-	struct hdd_request *request = NULL;
-	static const struct hdd_request_params params = {
+	struct osif_request *request = NULL;
+	static const struct osif_request_params params = {
 		.priv_size = 0,
 		.timeout_ms = WLAN_WAIT_TIME_NUD_STATS,
 	};
@@ -13141,13 +13141,13 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
 
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	arp_stats_params.pkt_type = WLAN_NUD_STATS_ARP_PKT_TYPE;
 	arp_stats_params.vdev_id = adapter->session_id;
@@ -13178,7 +13178,7 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 		goto exit;
 	}
 
-	err = hdd_request_wait_for_response(request);
+	err = osif_request_wait_for_response(request);
 	if (err) {
 		hdd_err("SME timedout while retrieving NUD stats");
 		err = -ETIMEDOUT;
@@ -13233,7 +13233,7 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
 
 	cfg80211_vendor_cmd_reply(skb);
 exit:
-	hdd_request_put(request);
+	osif_request_put(request);
 	return err;
 }
 
@@ -13333,21 +13333,21 @@ struct chain_rssi_priv {
 static void hdd_get_chain_rssi_cb(void *context,
 				  struct chain_rssi_result *data)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct chain_rssi_priv *priv;
 
 	hdd_enter();
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->chain_rssi = *data;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -13416,9 +13416,9 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
 	QDF_STATUS status;
 	int retval;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct chain_rssi_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -13449,12 +13449,12 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
 		QDF_MAC_ADDR_SIZE);
 	req_msg.session_id = adapter->session_id;
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	mac_handle = hdd_ctx->mac_handle;
 	status = sme_get_chain_rssi(mac_handle,
@@ -13465,18 +13465,18 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
 		hdd_err("Unable to get chain rssi");
 		retval = qdf_status_to_os_return(status);
 	} else {
-		retval = hdd_request_wait_for_response(request);
+		retval = osif_request_wait_for_response(request);
 		if (retval) {
 			hdd_err("Target response timed out");
 		} else {
-			priv = hdd_request_priv(request);
+			priv = osif_request_priv(request);
 			retval = hdd_post_get_chain_rssi_rsp(hdd_ctx,
 					&priv->chain_rssi);
 			if (retval)
 				hdd_err("Failed to post chain rssi");
 		}
 	}
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	hdd_exit();
 	return retval;
diff --git a/core/hdd/src/wlan_hdd_debugfs.c b/core/hdd/src/wlan_hdd_debugfs.c
index 9035cd8d562b..db1ea4d1c322 100644
--- a/core/hdd/src/wlan_hdd_debugfs.c
+++ b/core/hdd/src/wlan_hdd_debugfs.c
@@ -28,7 +28,7 @@
 #ifdef WLAN_OPEN_SOURCE
 #include <wlan_hdd_includes.h>
 #include <wlan_hdd_debugfs.h>
-#include <wlan_hdd_request_manager.h>
+#include <wlan_osif_request_manager.h>
 #include <wlan_hdd_wowl.h>
 #include <cds_sched.h>
 #include <wlan_hdd_debugfs_llstat.h>
@@ -394,20 +394,20 @@ static void hdd_power_debugstats_dealloc(void *priv)
 static void hdd_power_debugstats_cb(struct power_stats_response *response,
 				    void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct power_stats_priv *priv;
 	uint32_t *debug_registers;
 	uint32_t debug_registers_len;
 
 	hdd_enter();
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 
 	/* copy fixed-sized data */
 	priv->power_stats = *response;
@@ -427,8 +427,8 @@ static void hdd_power_debugstats_cb(struct power_stats_response *response,
 			priv->power_stats.num_debug_register = 0;
 		}
 	}
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 }
 
@@ -454,9 +454,9 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
 	unsigned int len = 0;
 	char *power_debugfs_buf = NULL;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct power_stats_priv	*priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 		.dealloc = hdd_power_debugstats_dealloc,
@@ -477,12 +477,12 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
 	if (!wlan_hdd_validate_modules_state(hdd_ctx))
 		return -EINVAL;
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_power_debug_stats_req(hdd_ctx->mac_handle,
 					   hdd_power_debugstats_cb,
@@ -493,14 +493,14 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
 		goto cleanup;
 	}
 
-	ret_cnt = hdd_request_wait_for_response(request);
+	ret_cnt = osif_request_wait_for_response(request);
 	if (ret_cnt) {
 		hdd_err("Target response timed out Power stats");
 		ret_cnt = -ETIMEDOUT;
 		goto cleanup;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	chip_power_stats = &priv->power_stats;
 
 	power_debugfs_buf = qdf_mem_malloc(POWER_DEBUGFS_BUFFER_MAX_LEN);
@@ -540,7 +540,7 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
 
  cleanup:
 	qdf_mem_free(power_debugfs_buf);
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return ret_cnt;
 }
diff --git a/core/hdd/src/wlan_hdd_disa.c b/core/hdd/src/wlan_hdd_disa.c
index 59ce7e237349..b85ccbd8e7cf 100644
--- a/core/hdd/src/wlan_hdd_disa.c
+++ b/core/hdd/src/wlan_hdd_disa.c
@@ -25,7 +25,7 @@
 
 #include "wlan_hdd_disa.h"
 #include "wlan_disa_ucfg_api.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "sme_api.h"
 #include <qca_vendor.h>
 
@@ -55,7 +55,7 @@ struct hdd_encrypt_decrypt_msg_context {
 static void hdd_encrypt_decrypt_msg_cb(void *cookie,
 	struct disa_encrypt_decrypt_resp_params *resp)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_encrypt_decrypt_msg_context *context;
 
 	hdd_enter();
@@ -65,7 +65,7 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
 		return;
 	}
 
-	request = hdd_request_get(cookie);
+	request = osif_request_get(cookie);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
@@ -81,7 +81,7 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
 		resp->status,
 		resp->data_len);
 
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 	context->response = *resp;
 	context->status = 0;
 	if (resp->data_len) {
@@ -101,8 +101,8 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
 		context->response.data = NULL;
 	}
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 }
 
@@ -361,27 +361,27 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
 	QDF_STATUS qdf_status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_encrypt_decrypt_msg_context *context;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*context),
 		.timeout_ms = WLAN_WAIT_TIME_ENCRYPT_DECRYPT,
 		.dealloc = hdd_encrypt_decrypt_context_dealloc,
 	};
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 
 	ret = hdd_fill_encrypt_decrypt_params(&context->request, adapter,
 					      data, data_len);
 	if (ret)
 		goto cleanup;
 
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	qdf_status = ucfg_disa_encrypt_decrypt_req(hdd_ctx->hdd_psoc,
 				&context->request,
@@ -394,7 +394,7 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
 		goto cleanup;
 	}
 
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("Target response timed out");
 		goto cleanup;
@@ -411,7 +411,7 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
 		hdd_err("Failed to post encrypt/decrypt message response");
 
 cleanup:
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	hdd_exit();
 	return ret;
diff --git a/core/hdd/src/wlan_hdd_fips.c b/core/hdd/src/wlan_hdd_fips.c
index fe75a958570b..a2bf8ced2dd7 100644
--- a/core/hdd/src/wlan_hdd_fips.c
+++ b/core/hdd/src/wlan_hdd_fips.c
@@ -24,7 +24,7 @@
 
 #include "wlan_hdd_main.h"
 #include "wlan_hdd_fips.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "qdf_mem.h"
 #include "sme_api.h"
 
@@ -81,7 +81,7 @@ static int hdd_fips_event_dup(struct wmi_host_fips_event_param *dest,
 static void hdd_fips_cb(void *cookie,
 			struct wmi_host_fips_event_param *response)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_fips_context *context;
 
 	hdd_enter();
@@ -91,7 +91,7 @@ static void hdd_fips_cb(void *cookie,
 		return;
 	}
 
-	request = hdd_request_get(cookie);
+	request = osif_request_get(cookie);
 	if (!request) {
 		hdd_debug("Obsolete request");
 		return;
@@ -104,7 +104,7 @@ static void hdd_fips_cb(void *cookie,
 	qdf_trace_hex_dump(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
 			   response->data, response->data_len);
 
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 	if (response->error_status) {
 		context->status = -ETIMEDOUT;
 	} else {
@@ -112,8 +112,8 @@ static void hdd_fips_cb(void *cookie,
 						     response);
 	}
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 }
 
@@ -175,11 +175,11 @@ static int __hdd_fips_test(struct net_device *dev,
 	int ret;
 	QDF_STATUS qdf_status;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_fips_context *context;
 	struct fips_params *fips_request;
 	struct wmi_host_fips_event_param *fips_response;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*context),
 		.timeout_ms = WLAN_WAIT_TIME_FIPS,
 		.dealloc = hdd_fips_context_dealloc,
@@ -199,12 +199,12 @@ static int __hdd_fips_test(struct net_device *dev,
 	if (ret)
 		return ret;
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	context = hdd_request_priv(request);
+	context = osif_request_priv(request);
 	fips_request = &context->request;
 	fips_request->key = &user_request->key[0];
 	fips_request->key_len = user_request->key_len;
@@ -214,7 +214,7 @@ static int __hdd_fips_test(struct net_device *dev,
 	fips_request->op = user_request->operation;
 	fips_request->pdev_id = WMI_PDEV_ID_1ST;
 
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 	qdf_status = sme_fips_request(hdd_ctx->mac_handle, &context->request,
 				      hdd_fips_cb, cookie);
 
@@ -224,7 +224,7 @@ static int __hdd_fips_test(struct net_device *dev,
 		goto cleanup;
 	}
 
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("Target response timed out");
 		goto cleanup;
@@ -269,7 +269,7 @@ static int __hdd_fips_test(struct net_device *dev,
 		ret = -EFAULT;
 
 cleanup:
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	hdd_exit();
 	return ret;
diff --git a/core/hdd/src/wlan_hdd_ioctl.c b/core/hdd/src/wlan_hdd_ioctl.c
index e029f9b60837..7e0764c0e245 100644
--- a/core/hdd/src/wlan_hdd_ioctl.c
+++ b/core/hdd/src/wlan_hdd_ioctl.c
@@ -25,7 +25,7 @@
 #include "wlan_hdd_ioctl.h"
 #include "wlan_hdd_power.h"
 #include "wlan_hdd_regulatory.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "wlan_hdd_driver_ops.h"
 #include "wlan_policy_mgr_api.h"
 #include "wlan_hdd_hostapd.h"
@@ -155,18 +155,18 @@ struct tsm_priv {
 static void hdd_get_tsm_stats_cb(tAniTrafStrmMetrics tsm_metrics,
 				 const uint32_t staId, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct tsm_priv *priv;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->tsm_metrics = tsm_metrics;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 
 }
@@ -180,9 +180,9 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct tsm_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -195,12 +195,12 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_get_tsm_stats(hdd_ctx->mac_handle, hdd_get_tsm_stats_cb,
 				   hdd_sta_ctx->conn_info.staId[0],
@@ -212,17 +212,17 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
 		goto cleanup;
 	}
 
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("SME timed out while retrieving tsm statistics");
 		goto cleanup;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	*tsm_metrics = priv->tsm_metrics;
 
  cleanup:
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return ret;
 }
@@ -2482,19 +2482,19 @@ sme_config_free:
 
 static void hdd_get_link_status_cb(uint8_t status, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct link_status_priv *priv;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->link_status = status;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -2515,9 +2515,9 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct link_status_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_LINK_STATUS,
 	};
@@ -2545,12 +2545,12 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
 		return 0;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return 0;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_get_link_status(adapter->hdd_ctx->mac_handle,
 				     hdd_get_link_status_cb,
@@ -2560,13 +2560,13 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
 		/* return a cached value */
 	} else {
 		/* request is sent -- wait for the response */
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_err("SME timed out while retrieving link status");
 			/* return a cached value */
 		} else {
 			/* update the adapter with the fresh results */
-			priv = hdd_request_priv(request);
+			priv = osif_request_priv(request);
 			adapter->link_status = priv->link_status;
 		}
 	}
@@ -2576,7 +2576,7 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	/* either callback updated adapter stats or it has cached data */
 	return adapter->link_status;
diff --git a/core/hdd/src/wlan_hdd_main.c b/core/hdd/src/wlan_hdd_main.c
index ff3b15bb9cd9..cbcbe66a9770 100644
--- a/core/hdd/src/wlan_hdd_main.c
+++ b/core/hdd/src/wlan_hdd_main.c
@@ -45,7 +45,6 @@
 #include "wlan_hdd_power.h"
 #include "wlan_hdd_stats.h"
 #include "wlan_hdd_scan.h"
-#include "wlan_hdd_request_manager.h"
 #include <wlan_osif_request_manager.h>
 #ifdef CONFIG_LEAK_DETECTION
 #include "qdf_debug_domain.h"
@@ -6905,7 +6904,6 @@ static void hdd_wlan_exit(struct hdd_context *hdd_ctx)
 	qdf_spinlock_destroy(&hdd_ctx->sta_update_info_lock);
 	qdf_spinlock_destroy(&hdd_ctx->connection_status_lock);
 
-	hdd_request_manager_deinit();
 	osif_request_manager_deinit();
 
 	hdd_close_all_adapters(hdd_ctx, false);
@@ -10912,7 +10910,6 @@ int hdd_wlan_startup(struct device *dev)
 #endif
 
 	osif_request_manager_init();
-	hdd_request_manager_init();
 	qdf_atomic_init(&hdd_ctx->con_mode_flag);
 
 	hdd_driver_memdump_init();
@@ -11029,7 +11026,6 @@ err_stop_modules:
 err_memdump_deinit:
 	hdd_driver_memdump_deinit();
 
-	hdd_request_manager_deinit();
 	osif_request_manager_deinit();
 	hdd_exit_netlink_services(hdd_ctx);
 
@@ -11076,7 +11072,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
 	struct hdd_context *hdd_ctx = (struct hdd_context *)data;
 	int status;
 	struct hdd_adapter *adapter = NULL;
-	struct hdd_request *request = NULL;
+	struct osif_request *request = NULL;
 
 	hdd_enter();
 
@@ -11089,7 +11085,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
 	if (status != 0)
 		return;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("obselete request");
 		return;
@@ -11098,7 +11094,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
 	adapter = hdd_get_adapter_by_vdev(hdd_ctx, rsp->vdev_id);
 	if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
 		hdd_err("Invalid adapter or adapter has invalid magic");
-		hdd_request_put(request);
+		osif_request_put(request);
 		return;
 	}
 
@@ -11126,8 +11122,8 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
 							rsp->icmpv4_rsp_recvd;
 	}
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 
 	hdd_exit();
 }
diff --git a/core/hdd/src/wlan_hdd_ocb.c b/core/hdd/src/wlan_hdd_ocb.c
index 586fa3054215..e7d876f1ddb9 100644
--- a/core/hdd/src/wlan_hdd_ocb.c
+++ b/core/hdd/src/wlan_hdd_ocb.c
@@ -27,7 +27,7 @@
 #include "wlan_hdd_main.h"
 #include "wlan_hdd_ocb.h"
 #include "wlan_hdd_trace.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "wlan_tgt_def_config.h"
 #include "sch_api.h"
 #include "wma_api.h"
@@ -352,16 +352,16 @@ struct hdd_ocb_set_config_priv {
  */
 static void hdd_ocb_set_config_callback(void *context_ptr, void *response_ptr)
 {
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_ocb_set_config_priv *priv;
 	struct ocb_set_config_response *response = response_ptr;
 
-	hdd_request = hdd_request_get(context_ptr);
-	if (!hdd_request) {
+	request = osif_request_get(context_ptr);
+	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 
 	if (response && response->status)
 		hdd_warn("Operation failed: %d", response->status);
@@ -371,8 +371,8 @@ static void hdd_ocb_set_config_callback(void *context_ptr, void *response_ptr)
 	else
 		priv->status = -EINVAL;
 
-	hdd_request_complete(hdd_request);
-	hdd_request_put(hdd_request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -388,9 +388,9 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
 	int rc;
 	QDF_STATUS status;
 	void *cookie;
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_ocb_set_config_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
 	};
@@ -400,12 +400,12 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
 		return -EINVAL;
 	}
 
-	hdd_request = hdd_request_alloc(&params);
-	if (!hdd_request) {
+	request = osif_request_alloc(&params);
+	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(hdd_request);
+	cookie = osif_request_cookie(request);
 
 	hdd_debug("Disabling queues");
 	wlan_hdd_netif_queue_control(adapter,
@@ -422,13 +422,13 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
 	}
 
 	/* Wait for the function to complete. */
-	rc = hdd_request_wait_for_response(hdd_request);
+	rc = osif_request_wait_for_response(request);
 	if (rc) {
 		hdd_err("Operation timed out");
 		goto end;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	rc = priv->status;
 	if (rc) {
 		hdd_err("Operation failed: %d", rc);
@@ -446,7 +446,7 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
 
 	/* fall through */
 end:
-	hdd_request_put(hdd_request);
+	osif_request_put(request);
 
 	return rc;
 }
@@ -1298,25 +1298,25 @@ struct hdd_ocb_get_tsf_timer_priv {
 static void hdd_ocb_get_tsf_timer_callback(void *context_ptr,
 					   void *response_ptr)
 {
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_ocb_get_tsf_timer_priv *priv;
 	struct ocb_get_tsf_timer_response *response = response_ptr;
 
-	hdd_request = hdd_request_get(context_ptr);
-	if (!hdd_request) {
+	request = osif_request_get(context_ptr);
+	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	if (response) {
 		priv->response = *response;
 		priv->status = 0;
 	} else {
 		priv->status = -EINVAL;
 	}
-	hdd_request_complete(hdd_request);
-	hdd_request_put(hdd_request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 static int
@@ -1384,9 +1384,9 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
 	struct ocb_get_tsf_timer_param request = {0};
 	QDF_STATUS status;
 	void *cookie;
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_ocb_get_tsf_timer_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
 	};
@@ -1407,12 +1407,12 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	hdd_request = hdd_request_alloc(&params);
-	if (!hdd_request) {
+	request = osif_request_alloc(&params);
+	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(hdd_request);
+	cookie = osif_request_cookie(request);
 
 	request.vdev_id = adapter->session_id;
 	status = ucfg_ocb_get_tsf_timer(adapter->hdd_vdev, &request,
@@ -1424,13 +1424,13 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
 		goto end;
 	}
 
-	rc = hdd_request_wait_for_response(hdd_request);
+	rc = osif_request_wait_for_response(request);
 	if (rc) {
 		hdd_err("Operation timed out");
 		goto end;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	rc = priv->status;
 	if (rc) {
 		hdd_err("Operation failed: %d", rc);
@@ -1450,7 +1450,7 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
 
 	/* fall through */
 end:
-	hdd_request_put(hdd_request);
+	osif_request_put(request);
 
 	return rc;
 }
@@ -1499,18 +1499,18 @@ static void hdd_dcc_get_stats_dealloc(void *context_ptr)
  */
 static void hdd_dcc_get_stats_callback(void *context_ptr, void *response_ptr)
 {
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_dcc_stats_priv *priv;
 	struct ocb_dcc_get_stats_response *response = response_ptr;
 	struct ocb_dcc_get_stats_response *hdd_resp;
 
-	hdd_request = hdd_request_get(context_ptr);
-	if (!hdd_request) {
+	request = osif_request_get(context_ptr);
+	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	if (!response) {
 		priv->status = -EINVAL;
 		goto end;
@@ -1532,8 +1532,8 @@ static void hdd_dcc_get_stats_callback(void *context_ptr, void *response_ptr)
 	priv->status = 0;
 
 end:
-	hdd_request_complete(hdd_request);
-	hdd_request_put(hdd_request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 static int
@@ -1606,9 +1606,9 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
 	struct ocb_dcc_get_stats_param request = {0};
 	QDF_STATUS status;
 	void *cookie;
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_dcc_stats_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
 		.dealloc = hdd_dcc_get_stats_dealloc,
@@ -1652,12 +1652,12 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
 	request_array = nla_data(
 		tb[QCA_WLAN_VENDOR_ATTR_DCC_GET_STATS_REQUEST_ARRAY]);
 
-	hdd_request = hdd_request_alloc(&params);
-	if (!hdd_request) {
+	request = osif_request_alloc(&params);
+	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(hdd_request);
+	cookie = osif_request_cookie(request);
 
 	request.vdev_id = adapter->session_id;
 	request.channel_count = channel_count;
@@ -1674,13 +1674,13 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
 	}
 
 	/* Wait for the function to complete. */
-	rc = hdd_request_wait_for_response(hdd_request);
+	rc = osif_request_wait_for_response(request);
 	if (rc) {
 		hdd_err("Operation timed out");
 		goto end;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	rc = priv->status;
 	if (rc) {
 		hdd_err("Operation failed: %d", rc);
@@ -1696,7 +1696,7 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
 
 	/* fall through */
 end:
-	hdd_request_put(hdd_request);
+	osif_request_put(request);
 
 	return rc;
 }
@@ -1820,23 +1820,23 @@ struct hdd_dcc_update_ndl_priv {
  */
 static void hdd_dcc_update_ndl_callback(void *context_ptr, void *response_ptr)
 {
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_dcc_update_ndl_priv *priv;
 	struct ocb_dcc_update_ndl_response *response = response_ptr;
 
-	hdd_request = hdd_request_get(context_ptr);
-	if (!hdd_request) {
+	request = osif_request_get(context_ptr);
+	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	if (response && (0 == response->status)) {
 		priv->status = 0;
 	} else {
 		priv->status = -EINVAL;
 	}
-	hdd_request_complete(hdd_request);
-	hdd_request_put(hdd_request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -1866,9 +1866,9 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
 	int rc;
 	QDF_STATUS status;
 	void *cookie;
-	struct hdd_request *hdd_request;
+	struct osif_request *request;
 	struct hdd_dcc_update_ndl_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
 	};
@@ -1916,12 +1916,12 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
 	ndl_active_state_array = nla_data(
 		tb[QCA_WLAN_VENDOR_ATTR_DCC_UPDATE_NDL_ACTIVE_STATE_ARRAY]);
 
-	hdd_request = hdd_request_alloc(&params);
-	if (!hdd_request) {
+	request = osif_request_alloc(&params);
+	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(hdd_request);
+	cookie = osif_request_cookie(request);
 
 	/* Copy the parameters to the request structure. */
 	request.vdev_id = adapter->session_id;
@@ -1941,13 +1941,13 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
 	}
 
 	/* Wait for the function to complete. */
-	rc = hdd_request_wait_for_response(hdd_request);
+	rc = osif_request_wait_for_response(request);
 	if (rc) {
 		hdd_err("Operation timed out");
 		goto end;
 	}
 
-	priv = hdd_request_priv(hdd_request);
+	priv = osif_request_priv(request);
 	rc = priv->status;
 	if (rc) {
 		hdd_err("Operation failed: %d", rc);
@@ -1956,7 +1956,7 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
 
 	/* fall through */
 end:
-	hdd_request_put(hdd_request);
+	osif_request_put(request);
 
 	return rc;
 }
diff --git a/core/hdd/src/wlan_hdd_request_manager.c b/core/hdd/src/wlan_hdd_request_manager.c
deleted file mode 100644
index 8eaaa252252c..000000000000
--- a/core/hdd/src/wlan_hdd_request_manager.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Permission to use, copy, modify, and/or distribute this software for
- * any purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <linux/kernel.h>
-#include "wlan_hdd_request_manager.h"
-#include "wlan_hdd_main.h"
-#include "qdf_list.h"
-#include "qdf_event.h"
-#include "qdf_mem.h"
-
-/* arbitrary value */
-#define MAX_NUM_REQUESTS 20
-
-static bool is_initialized;
-static qdf_list_t requests;
-static qdf_spinlock_t spinlock;
-static void *cookie;
-
-struct hdd_request {
-	qdf_list_node_t node;
-	void *cookie;
-	uint32_t reference_count;
-	struct hdd_request_params params;
-	qdf_event_t completed;
-};
-
-/* must be called with spinlock held */
-static void hdd_request_unlink(struct hdd_request *request)
-{
-	qdf_list_remove_node(&requests, &request->node);
-}
-
-static void hdd_request_destroy(struct hdd_request *request)
-{
-	struct hdd_request_params *params;
-
-	params = &request->params;
-	if (params->dealloc) {
-		void *priv = hdd_request_priv(request);
-
-		params->dealloc(priv);
-	}
-	qdf_event_destroy(&request->completed);
-	qdf_mem_free(request);
-}
-
-/* must be called with spinlock held */
-static struct hdd_request *hdd_request_find(void *cookie)
-{
-	QDF_STATUS status;
-	struct hdd_request *request;
-	qdf_list_node_t *node;
-
-	status = qdf_list_peek_front(&requests, &node);
-	while (QDF_IS_STATUS_SUCCESS(status)) {
-		request = qdf_container_of(node, struct hdd_request, node);
-		if (request->cookie == cookie)
-			return request;
-		status = qdf_list_peek_next(&requests, node, &node);
-	}
-
-	return NULL;
-}
-
-struct hdd_request *hdd_request_alloc(const struct hdd_request_params *params)
-{
-	size_t length;
-	struct hdd_request *request;
-
-	if (!is_initialized) {
-		hdd_err("invoked when not initialized from %pS",
-			(void *)_RET_IP_);
-		return NULL;
-	}
-
-	length = sizeof(*request) + params->priv_size;
-	request = qdf_mem_malloc(length);
-	if (!request) {
-		hdd_err("allocation failed for %pS", (void *)_RET_IP_);
-		return NULL;
-	}
-	request->reference_count = 1;
-	request->params = *params;
-	qdf_event_create(&request->completed);
-	qdf_spin_lock_bh(&spinlock);
-	request->cookie = cookie++;
-	qdf_list_insert_back(&requests, &request->node);
-	qdf_spin_unlock_bh(&spinlock);
-	hdd_debug("request %pK, cookie %pK, caller %pS",
-		  request, request->cookie, (void *)_RET_IP_);
-
-	return request;
-}
-
-void *hdd_request_priv(struct hdd_request *request)
-{
-	/* private data area immediately follows the struct hdd_request */
-	return request + 1;
-}
-
-void *hdd_request_cookie(struct hdd_request *request)
-{
-	return request->cookie;
-}
-
-struct hdd_request *hdd_request_get(void *cookie)
-{
-	struct hdd_request *request;
-
-	if (!is_initialized) {
-		hdd_err("invoked when not initialized from %pS",
-			(void *)_RET_IP_);
-		return NULL;
-	}
-	qdf_spin_lock_bh(&spinlock);
-	request = hdd_request_find(cookie);
-	if (request)
-		request->reference_count++;
-	qdf_spin_unlock_bh(&spinlock);
-	hdd_debug("cookie %pK, request %pK, caller %pS",
-		  cookie, request, (void *)_RET_IP_);
-
-	return request;
-}
-
-void hdd_request_put(struct hdd_request *request)
-{
-	bool unlinked = false;
-
-	hdd_debug("request %pK, cookie %pK, caller %pS",
-		  request, request->cookie, (void *)_RET_IP_);
-	qdf_spin_lock_bh(&spinlock);
-	request->reference_count--;
-	if (0 == request->reference_count) {
-		hdd_request_unlink(request);
-		unlinked = true;
-	}
-	qdf_spin_unlock_bh(&spinlock);
-	if (unlinked)
-		hdd_request_destroy(request);
-}
-
-int hdd_request_wait_for_response(struct hdd_request *request)
-{
-	QDF_STATUS status;
-
-	status = qdf_wait_for_event_completion(&request->completed,
-				       request->params.timeout_ms);
-
-	return qdf_status_to_os_return(status);
-}
-
-void hdd_request_complete(struct hdd_request *request)
-{
-	(void) qdf_event_set(&request->completed);
-}
-
-void hdd_request_manager_init(void)
-{
-	hdd_debug("%pS", (void *)_RET_IP_);
-	if (is_initialized)
-		return;
-
-	qdf_list_create(&requests, MAX_NUM_REQUESTS);
-	qdf_spinlock_create(&spinlock);
-	is_initialized = true;
-}
-
-/*
- * hdd_request_manager_deinit implementation note:
- * It is intentional that we do not destroy the list or the spinlock.
- * This allows threads to still access the infrastructure even when it
- * has been deinitialized. Since neither lists nor spinlocks consume
- * resources this does not result in a resource leak.
- */
-void hdd_request_manager_deinit(void)
-{
-	hdd_debug("%pS", (void *)_RET_IP_);
-	is_initialized = false;
-}
diff --git a/core/hdd/src/wlan_hdd_request_manager.h b/core/hdd/src/wlan_hdd_request_manager.h
deleted file mode 100644
index 67d229e83b82..000000000000
--- a/core/hdd/src/wlan_hdd_request_manager.h
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Permission to use, copy, modify, and/or distribute this software for
- * any purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef __WLAN_HDD_REQUEST_MANAGER_H__
-#define __WLAN_HDD_REQUEST_MANAGER_H__
-
-/**
- * DOC: WLAN HDD REQUEST MANAGER
- *
- * Many operations within the wlan driver occur in an asynchronous
- * manner. Requests are received by HDD via one of the kernel
- * interfaces (ioctl, nl80211, virtual file system, etc.). The
- * requests are translated to an internal format and are then passed
- * to lower layers, usually via SME, for processing. For requests
- * which require a response, that response comes up from the lower
- * layers in a separate thread of execution, ultimately resulting in a
- * call to a callback function that was provided by HDD as part of the
- * initial request. So a mechanism is needed to synchronize the
- * request and response. This framework provides that mechanism.
- *
- * Once the framework has been initialized, the typical sequence of
- * events is as follows:
- *
- * Request Thread:
- * 1. Create a &struct hdd_request_params which describes the request.
- * 2. Call hdd_request_alloc() to allocate a &struct hdd_request.
- * 3. Call hdd_request_priv() to get a pointer to the private data.
- * 4. Place any information which must be shared with the Response
- *    Callback in the private data area.
- * 5. Call hdd_request_cookie() to get the unique cookie assigned
- *    to the request.
- * 6. Call the underlying request handling API, passing the cookie
- *    as the callback's private context.
- * 7. Call hdd_request_wait_for_response() to wait for the response
- *    (or for the request to time out).
- * 8. Use the return status to see if the request was successful. If
- *    it was, retrieve any response information from the private
- *    structure and prepare a response for userspace.
- * 9. Call hdd_request_put() to relinquish access to the request.
- * 10. Return status to the caller.
- *
- * Response Callback:
- * 1. Call hdd_request_get() with the provided cookie to see if the
- *    request structure is still valid.  If it returns %NULL then
- *    return since this means the request thread has already timed
- *    out.
- * 2. Call hdd_request_priv() to get access to the private data area.
- * 3. Write response data into the private data area.
- * 4. Call hdd_request_complete() to indicate that the response is
- *    ready to be processed by the request thread.
- * 5. Call hdd_request_put() to relinquish the callback function's
- *    reference to the request.
- */
-
-/* this is opaque to clients */
-struct hdd_request;
-
-/**
- * typedef hdd_request_dealloc - Private data deallocation function
- */
-typedef void (*hdd_request_dealloc)(void *priv);
-
-/**
- * struct hdd_request_params - HDD request parameters
- * @priv_size: Size of the private data area required to pass
- *      information between the request thread and the response callback.
- * @timeout_ms: The amount of time to wait for a response in milliseconds.
- * @dealloc: Function to be called when the request is destroyed to
- *      deallocate any allocations made in the private area of the
- *      request struct. Can be %NULL if no private allocations are
- *      made.
- */
-struct hdd_request_params {
-	uint32_t priv_size;
-	uint32_t timeout_ms;
-	hdd_request_dealloc dealloc;
-};
-
-/**
- * hdd_request_alloc() - Allocate a request struct
- * @params: parameter block that specifies the attributes of the
- *      request
- *
- * This function will attempt to allocate a &struct hdd_request with
- * the specified @params. If successful, the caller can then use
- * request struct to make an asynchronous request. Once the request is
- * no longer needed, the reference should be relinquished via a call
- * to hdd_request_put().
- *
- * Return: A pointer to an allocated &struct hdd_request (which also
- * contains room for the private buffer) if the allocation is
- * successful, %NULL if the allocation fails.
- */
-struct hdd_request *hdd_request_alloc(const struct hdd_request_params *params);
-
-/**
- * hdd_request_priv() - Get pointer to request private data
- * @request: The request struct that contains the private data
- *
- * This function will return a pointer to the private data area that
- * is part of the request struct. The caller must already have a valid
- * reference to @request from either hdd_request_alloc() or
- * hdd_request_get().
- *
- * Returns: pointer to the private data area. Note that this pointer
- * will always be an offset from the input @request pointer and hence
- * this function will never return %NULL.
- */
-void *hdd_request_priv(struct hdd_request *request);
-
-/**
- * hdd_request_cookie() - Get cookie of a request
- * @request: The request struct associated with the request
- *
- * This function will return the unique cookie that has been assigned
- * to the request. This cookie can subsequently be passed to
- * hdd_request_get() to retrieve the request.
- *
- * Note that the cookie is defined as a void pointer as it is intended
- * to be passed as an opaque context pointer from HDD to underlying
- * layers when making a request, and subsequently passed back to HDD
- * as an opaque pointer in an asynchronous callback.
- *
- * Returns: The cookie assigned to the request.
- */
-void *hdd_request_cookie(struct hdd_request *request);
-
-/**
- * hdd_request_get() - Get a reference to a request struct
- * @cookie: The cookie of the request struct that needs to be
- *      referenced
- *
- * This function will use the cookie to determine if the associated
- * request struct is valid, and if so, will increment the reference
- * count of the struct. This means the caller is guaranteed that the
- * request struct is valid and the underlying private data can be
- * dereferenced.
- *
- * Returns: The pointer to the request struct associated with @cookie
- * if the request is still valid, %NULL if the underlying request
- * struct is no longer valid.
- */
-struct hdd_request *hdd_request_get(void *cookie);
-
-/**
- * hdd_request_put() - Release a reference to a request struct
- * @request: The request struct that no longer needs to be referenced
- *
- * This function will decrement the reference count of the struct, and
- * will clean up the request if this is the last reference. The caller
- * must already have a valid reference to @request, either from
- * hdd_request_alloc() or hdd_request_get().
- *
- * Returns: Nothing
- */
-void hdd_request_put(struct hdd_request *request);
-
-/**
- * hdd_request_wait_for_response() - Wait for a response
- * @request: The request struct associated with the request
- *
- * This function will wait until either a response is received and
- * communicated via hdd_request_complete(), or until the request
- * timeout period expires.
- *
- * Returns: 0 if a response was received, -ETIMEDOUT if the response
- * timed out.
- */
-int hdd_request_wait_for_response(struct hdd_request *request);
-
-/**
- * hdd_request_complete() - Complete a request
- * @request: The request struct associated with the request
- *
- * This function is used to indicate that a response has been received
- * and that any information required by the request thread has been
- * copied into the private data area of the request struct. This will
- * unblock any hdd_request_wait_for_response() that is pending on this
- * @request.
- *
- * Returns: Nothing
- */
-void hdd_request_complete(struct hdd_request *request);
-
-/**
- * hdd_request_manager_init() - Initialize the HDD Request Manager
- *
- * This function must be called during system initialization to
- * initialize the HDD Request Manager.
- *
- * Returns: Nothing
- */
-void hdd_request_manager_init(void);
-
-/**
- * hdd_request_manager_deinit() - Deinitialize the HDD Request Manager
- *
- * This function must be called during system shutdown to deinitialize
- * the HDD Request Manager.
- *
- * Returns: Nothing
- */
-void hdd_request_manager_deinit(void);
-
-#endif /* __WLAN_HDD_REQUEST_MANAGER_H__ */
diff --git a/core/hdd/src/wlan_hdd_stats.c b/core/hdd/src/wlan_hdd_stats.c
index ee26d1a4d388..3be1860ffc6e 100644
--- a/core/hdd/src/wlan_hdd_stats.c
+++ b/core/hdd/src/wlan_hdd_stats.c
@@ -32,7 +32,7 @@
 #include <qca_vendor.h>
 #include "wma_api.h"
 #include "wlan_hdd_hostapd.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "wlan_hdd_debugfs_llstat.h"
 #include "wlan_reg_services_api.h"
 #include <wlan_cfg80211_mc_cp_stats.h>
@@ -4851,7 +4851,7 @@ static bool hdd_is_rcpi_applicable(struct hdd_adapter *adapter,
 static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
 				 int32_t rcpi, QDF_STATUS status)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct rcpi_info *priv;
 
 	if (!context) {
@@ -4859,13 +4859,13 @@ static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
 		return;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete RCPI request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->mac_addr = mac_addr;
 
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -4875,8 +4875,8 @@ static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
 		priv->rcpi = rcpi;
 	}
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 /**
@@ -4900,8 +4900,8 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
 	struct sme_rcpi_req *rcpi_req;
 	void *cookie;
 	struct rcpi_info *priv;
-	struct hdd_request *request;
-	static const struct hdd_request_params params = {
+	struct osif_request *request;
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_RCPI,
 	};
@@ -4950,13 +4950,13 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
 		return -EINVAL;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		qdf_mem_free(rcpi_req);
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	rcpi_req->mac_addr = mac_addr;
 	rcpi_req->session_id = adapter->session_id;
@@ -4972,7 +4972,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
 	}
 
 	/* request was sent -- wait for the response */
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("SME timed out while retrieving RCPI");
 		status = -EINVAL;
@@ -4980,7 +4980,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
 	}
 
 	/* update the adapter with the fresh results */
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	adapter->rcpi.mac_addr = priv->mac_addr;
 	adapter->rcpi.rcpi = priv->rcpi;
 	if (qdf_mem_cmp(&mac_addr, &priv->mac_addr, sizeof(mac_addr))) {
@@ -4993,7 +4993,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
 	hdd_debug("RCPI = %d", *rcpi_value);
 out:
 	qdf_mem_free(rcpi_req);
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	hdd_exit();
 	return status;
@@ -5086,19 +5086,19 @@ struct rssi_priv {
  */
 static void hdd_get_rssi_cb(int8_t rssi, uint32_t sta_id, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct rssi_priv *priv;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->rssi = rssi;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
@@ -5108,9 +5108,9 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct rssi_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5143,13 +5143,13 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
 		return QDF_STATUS_SUCCESS;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure, return cached RSSI");
 		*rssi_value = adapter->rssi;
 		return QDF_STATUS_SUCCESS;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_get_rssi(hdd_ctx->mac_handle, hdd_get_rssi_cb,
 			      sta_ctx->conn_info.staId[0],
@@ -5160,13 +5160,13 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
 		/* we'll returned a cached value below */
 	} else {
 		/* request was sent -- wait for the response */
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_warn("SME timed out while retrieving RSSI");
 			/* we'll returned a cached value below */
 		} else {
 			/* update the adapter with the fresh results */
-			priv = hdd_request_priv(request);
+			priv = osif_request_priv(request);
 
 			adapter->rssi = priv->rssi;
 
@@ -5187,7 +5187,7 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	*rssi_value = adapter->rssi;
 	hdd_debug("RSSI = %d", *rssi_value);
@@ -5211,20 +5211,20 @@ struct snr_priv {
  */
 static void hdd_get_snr_cb(int8_t snr, uint32_t sta_id, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct snr_priv *priv;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
 	/* propagate response back to requesting thread */
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->snr = snr;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
@@ -5234,9 +5234,9 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct snr_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5256,12 +5256,12 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
 
 	sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return QDF_STATUS_E_FAULT;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	status = sme_get_snr(hdd_ctx->mac_handle, hdd_get_snr_cb,
 			     sta_ctx->conn_info.staId[0],
@@ -5271,13 +5271,13 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
 		/* we'll returned a cached value below */
 	} else {
 		/* request was sent -- wait for the response */
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_err("SME timed out while retrieving SNR");
 			/* we'll now returned a cached value below */
 		} else {
 			/* update the adapter with the fresh results */
-			priv = hdd_request_priv(request);
+			priv = osif_request_priv(request);
 			adapter->snr = priv->snr;
 		}
 	}
@@ -5287,7 +5287,7 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	*snr = adapter->snr;
 	hdd_exit();
@@ -5301,7 +5301,7 @@ struct linkspeed_priv {
 static void
 hdd_get_link_speed_cb(tSirLinkSpeedInfo *linkspeed_info, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct linkspeed_priv *priv;
 
 	if (!linkspeed_info) {
@@ -5309,16 +5309,16 @@ hdd_get_link_speed_cb(tSirLinkSpeedInfo *linkspeed_info, void *context)
 		return;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->linkspeed_info = *linkspeed_info;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
@@ -5329,9 +5329,9 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
 	QDF_STATUS status;
 	void *cookie;
 	tSirLinkSpeedInfo *linkspeed_info;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct linkspeed_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5341,15 +5341,15 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
 		return -EINVAL;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		ret = -ENOMEM;
 		goto return_cached_value;
 	}
 
-	cookie = hdd_request_cookie(request);
-	priv = hdd_request_priv(request);
+	cookie = osif_request_cookie(request);
+	priv = osif_request_priv(request);
 
 	linkspeed_info = &priv->linkspeed_info;
 	qdf_copy_macaddr(&linkspeed_info->peer_macaddr, mac_address);
@@ -5361,7 +5361,7 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
 		ret = qdf_status_to_os_return(status);
 		goto cleanup;
 	}
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("SME timed out while retrieving link speed");
 		goto cleanup;
@@ -5374,7 +5374,7 @@ cleanup:
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 return_cached_value:
 	*linkspeed = adapter->estimated_linkspeed;
@@ -5437,7 +5437,7 @@ struct peer_rssi_priv {
 static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
 				 void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct peer_rssi_priv *priv;
 	struct sir_peer_info *rssi_info;
 	uint8_t peer_num;
@@ -5447,13 +5447,13 @@ static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
 		return;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 
 	peer_num = sta_rssi->count;
 	rssi_info = sta_rssi->info;
@@ -5469,8 +5469,8 @@ static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
 		     peer_num * sizeof(*rssi_info));
 	priv->peer_sta_info.sta_num = peer_num;
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 
 }
 
@@ -5482,9 +5482,9 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
 	void *cookie;
 	int ret;
 	struct sir_peer_info_req rssi_req;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct peer_rssi_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5495,14 +5495,14 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
 		return -EFAULT;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
 
-	cookie = hdd_request_cookie(request);
-	priv = hdd_request_priv(request);
+	cookie = osif_request_cookie(request);
+	priv = osif_request_priv(request);
 
 	qdf_mem_copy(&rssi_req.peer_macaddr, macaddress,
 		     QDF_MAC_ADDR_SIZE);
@@ -5515,7 +5515,7 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
 		hdd_err("Unable to retrieve statistics for rssi");
 		ret = -EFAULT;
 	} else {
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_err("SME timed out while retrieving rssi");
 			ret = -EFAULT;
@@ -5525,7 +5525,7 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
 		}
 	}
 
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return ret;
 }
@@ -5545,7 +5545,7 @@ struct peer_info_priv {
 static void wlan_hdd_get_peer_info_cb(struct sir_peer_info_ext_resp *sta_info,
 				      void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct peer_info_priv *priv;
 	uint8_t sta_num;
 
@@ -5567,21 +5567,21 @@ static void wlan_hdd_get_peer_info_cb(struct sir_peer_info_ext_resp *sta_info,
 		sta_num = sta_info->count;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 
 	priv->peer_sta_ext_info.sta_num = sta_num;
 	qdf_mem_copy(&priv->peer_sta_ext_info.info,
 		     sta_info->info,
 		     sta_num * sizeof(sta_info->info[0]));
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
@@ -5592,9 +5592,9 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
 	void *cookie;
 	int ret;
 	struct sir_peer_info_ext_req peer_info_req;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct peer_info_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5604,14 +5604,14 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
 		return -EFAULT;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
 
-	cookie = hdd_request_cookie(request);
-	priv = hdd_request_priv(request);
+	cookie = osif_request_cookie(request);
+	priv = osif_request_priv(request);
 
 	qdf_mem_copy(&peer_info_req.peer_macaddr, &macaddress,
 		     QDF_MAC_ADDR_SIZE);
@@ -5625,7 +5625,7 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
 		hdd_err("Unable to retrieve statistics for peer info");
 		ret = -EFAULT;
 	} else {
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_err("SME timed out while retrieving peer info");
 			ret = -EFAULT;
@@ -5636,7 +5636,7 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
 		}
 	}
 
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return ret;
 }
@@ -5656,7 +5656,7 @@ struct class_a_stats {
  */
 static void hdd_get_class_a_statistics_cb(void *stats, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct class_a_stats *priv;
 	tCsrGlobalClassAStatsInfo *returned_stats;
 
@@ -5666,17 +5666,17 @@ static void hdd_get_class_a_statistics_cb(void *stats, void *context)
 		return;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
 	returned_stats = stats;
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->class_a_stats = *returned_stats;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 }
 
@@ -5686,9 +5686,9 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct class_a_stats *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5703,12 +5703,12 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
 		return QDF_STATUS_SUCCESS;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return QDF_STATUS_E_NOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	/* query only for Class A statistics (which include link speed) */
 	status = sme_get_statistics(adapter->hdd_ctx->mac_handle,
@@ -5722,14 +5722,14 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
 	}
 
 	/* request was sent -- wait for the response */
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_warn("SME timed out while retrieving Class A statistics");
 		goto return_cached_results;
 	}
 
 	/* update the adapter with the fresh results */
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	adapter->hdd_stats.class_a_stat = priv->class_a_stats;
 
 return_cached_results:
@@ -5738,7 +5738,7 @@ return_cached_results:
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -5827,7 +5827,7 @@ struct station_stats {
  */
 static void hdd_get_station_statistics_cb(void *stats, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct station_stats *priv;
 	tCsrSummaryStatsInfo *summary_stats;
 	tCsrGlobalClassAStatsInfo *class_a_stats;
@@ -5839,7 +5839,7 @@ static void hdd_get_station_statistics_cb(void *stats, void *context)
 		return;
 	}
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
@@ -5849,15 +5849,15 @@ static void hdd_get_station_statistics_cb(void *stats, void *context)
 	class_a_stats = (tCsrGlobalClassAStatsInfo *) (summary_stats + 1);
 	per_chain_rssi_stats = (struct csr_per_chain_rssi_stats_info *)
 				(class_a_stats + 1);
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 
 	/* copy over the stats. do so as a struct copy */
 	priv->summary_stats = *summary_stats;
 	priv->class_a_stats = *class_a_stats;
 	priv->per_chain_rssi_stats = *per_chain_rssi_stats;
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
@@ -5866,9 +5866,9 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
 	QDF_STATUS status;
 	int errno;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct station_stats *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5878,12 +5878,12 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
 		return 0;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 
 	/* query only for Summary & Class A statistics */
 	status = sme_get_statistics(adapter->hdd_ctx->mac_handle,
@@ -5901,14 +5901,14 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
 	}
 
 	/* request was sent -- wait for the response */
-	errno = hdd_request_wait_for_response(request);
+	errno = osif_request_wait_for_response(request);
 	if (errno) {
 		hdd_err("Failed to wait for statistics, errno %d", errno);
 		goto put_request;
 	}
 
 	/* update the adapter with the fresh results */
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	adapter->hdd_stats.summary_stat = priv->summary_stats;
 	adapter->hdd_stats.class_a_stat = priv->class_a_stats;
 	adapter->hdd_stats.per_chain_rssi_stats = priv->per_chain_rssi_stats;
@@ -5919,7 +5919,7 @@ put_request:
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	/* either callback updated adapter stats or it has cached data */
 	return 0;
@@ -5943,21 +5943,21 @@ struct temperature_priv {
  */
 static void hdd_get_temperature_cb(int temperature, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct temperature_priv *priv;
 
 	hdd_enter();
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	priv->temperature = temperature;
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 	hdd_exit();
 }
 
@@ -5966,9 +5966,9 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
 	QDF_STATUS status;
 	int ret;
 	void *cookie;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct temperature_priv *priv;
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
@@ -5979,23 +5979,23 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
 		return -EPERM;
 	}
 
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_err("Request allocation failure");
 		return -ENOMEM;
 	}
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 	status = sme_get_temperature(adapter->hdd_ctx->mac_handle, cookie,
 				     hdd_get_temperature_cb);
 	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("Unable to retrieve temperature");
 	} else {
-		ret = hdd_request_wait_for_response(request);
+		ret = osif_request_wait_for_response(request);
 		if (ret) {
 			hdd_err("SME timed out while retrieving temperature");
 		} else {
 			/* update the adapter with the fresh results */
-			priv = hdd_request_priv(request);
+			priv = osif_request_priv(request);
 			if (priv->temperature)
 				adapter->temperature = priv->temperature;
 		}
@@ -6006,7 +6006,7 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 
 	*temperature = adapter->temperature;
 	hdd_exit();
diff --git a/core/hdd/src/wlan_hdd_wext.c b/core/hdd/src/wlan_hdd_wext.c
index 5cdfac896b29..08bfe00e8248 100644
--- a/core/hdd/src/wlan_hdd_wext.c
+++ b/core/hdd/src/wlan_hdd_wext.c
@@ -87,7 +87,7 @@
 #endif
 #include "wlan_hdd_lro.h"
 #include "cds_utils.h"
-#include "wlan_hdd_request_manager.h"
+#include "wlan_osif_request_manager.h"
 #include "os_if_wifi_pos.h"
 #include <cdp_txrx_stats.h>
 #include <cds_api.h>
@@ -8213,19 +8213,19 @@ struct hdd_statistics_priv {
  */
 static void hdd_statistics_cb(void *stats, void *context)
 {
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_statistics_priv *priv;
 	tCsrSummaryStatsInfo *summary_stats;
 	tCsrGlobalClassAStatsInfo *class_a_stats;
 	tCsrGlobalClassDStatsInfo *class_d_stats;
 
-	request = hdd_request_get(context);
+	request = osif_request_get(context);
 	if (!request) {
 		hdd_err("Obsolete request");
 		return;
 	}
 
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 
 	summary_stats = (tCsrSummaryStatsInfo *)stats;
 	priv->summary_stats = *summary_stats;
@@ -8236,8 +8236,8 @@ static void hdd_statistics_cb(void *stats, void *context)
 	class_d_stats = (tCsrGlobalClassDStatsInfo *)(class_a_stats + 1);
 	priv->class_d_stats = *class_d_stats;
 
-	hdd_request_complete(request);
-	hdd_request_put(request);
+	osif_request_complete(request);
+	osif_request_put(request);
 }
 
 static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
@@ -8245,23 +8245,23 @@ static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
 	int ret = 0;
 	void *cookie;
 	QDF_STATUS status;
-	struct hdd_request *request;
+	struct osif_request *request;
 	struct hdd_station_ctx *sta_ctx;
 	struct hdd_statistics_priv *priv;
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
-	static const struct hdd_request_params params = {
+	static const struct osif_request_params params = {
 		.priv_size = sizeof(*priv),
 		.timeout_ms = WLAN_WAIT_TIME_STATS,
 	};
 
 	sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
-	request = hdd_request_alloc(&params);
+	request = osif_request_alloc(&params);
 	if (!request) {
 		hdd_warn("request allocation failed");
 		return -EINVAL;
 	}
 
-	cookie = hdd_request_cookie(request);
+	cookie = osif_request_cookie(request);
 	status = sme_get_statistics(hdd_ctx->mac_handle, eCSR_HDD,
 				    SME_SUMMARY_STATS |
 				    SME_GLOBAL_CLASSA_STATS |
@@ -8276,14 +8276,14 @@ static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
 	}
 
 	/* request was sent -- wait for the response */
-	ret = hdd_request_wait_for_response(request);
+	ret = osif_request_wait_for_response(request);
 	if (ret) {
 		hdd_err("Failed to wait for statistics, errno %d", ret);
 		goto put_request;
 	}
 
 	/* update the adapter cache with the fresh results */
-	priv = hdd_request_priv(request);
+	priv = osif_request_priv(request);
 	adapter->hdd_stats.summary_stat = priv->summary_stats;
 	adapter->hdd_stats.class_a_stat = priv->class_a_stats;
 	adapter->hdd_stats.class_d_stat = priv->class_d_stats;
@@ -8294,7 +8294,7 @@ put_request:
 	 * received a response or we sent a request and timed out.
 	 * regardless we are done with the request.
 	 */
-	hdd_request_put(request);
+	osif_request_put(request);
 	return ret;
 }
 #endif /* QCA_SUPPORT_CP_STATS */