qcacld-3.0: Remove kernel includes from datapath

To abstract kernel header inclusion, create new QDF APIs for all IPA
APIs and redirect all IPA API calls through QDF interfaces.

Change-Id: I7bff975ad7cb32fc128320c124633594471e0a1f
CRs-Fixed: 2098903

core/dp/txrx/ol_rx_defrag.c

@@ -61,7 +61,6 @@
 #include <ol_ctrl_txrx_api.h>
 #include <ol_txrx_peer_find.h>
 #include <qdf_nbuf.h>
-#include <linux/ieee80211.h>
 #include <qdf_util.h>
 #include <athdefs.h>
 #include <qdf_mem.h>

core/dp/txrx/ol_rx_reorder.c

@@ -30,8 +30,6 @@
 #include <qdf_nbuf.h>           /* qdf_nbuf_t, etc. */
 #include <qdf_mem.h>         /* qdf_mem_malloc */
 
-#include <linux/ieee80211.h>          /* IEEE80211_SEQ_MAX */
-
 /* external interfaces */
 #include <ol_txrx_api.h>        /* ol_txrx_pdev_handle */
 #include <ol_txrx_htt_api.h>    /* ol_rx_addba_handler, etc. */

core/dp/txrx/ol_tx_send.c

@@ -33,7 +33,6 @@
 
 #include <cds_queue.h>          /* TAILQ */
 #ifdef QCA_COMPUTE_TX_DELAY
-#include <linux/ieee80211.h>          /* ieee80211_frame, etc. */
 #include <enet.h>               /* ethernet_hdr_t, etc. */
 #include <ipv6_defs.h>          /* ipv6_traffic_class */
 #endif

core/dp/txrx/ol_txrx_encap.c

@@ -37,7 +37,6 @@
 
 #include <qdf_nbuf.h>           /* qdf_nbuf_t, etc. */
 #include <cds_ieee80211_common.h>   /* ieee80211_frame */
-#include <linux/net.h>              /* struct llc, struct ether_header, etc. */
 #include <ol_txrx_internal.h>   /* TXRX_ASSERT1 */
 #include <ol_txrx_encap.h>      /* struct ol_rx_decap_info_t */
 

core/dp/txrx/ol_txrx_internal.h

@@ -39,7 +39,6 @@
 #include <ol_txrx_dbg.h>
 #include <enet.h>               /* ETHERNET_HDR_LEN, etc. */
 #include <ipv4.h>               /* IPV4_HDR_LEN, etc. */
-#include <linux/ipv6.h>               /* IPV6_HDR_LEN, etc. */
 #include <ip_prot.h>            /* IP_PROTOCOL_TCP, etc. */
 
 #ifdef ATH_11AC_TXCOMPACT

core/dp/txrx/ol_txrx_ipa.c

@@ -303,39 +303,45 @@ QDF_STATUS ol_txrx_ipa_setup(struct cdp_pdev *ppdev, void *ipa_i2w_cb,
 {
 	ol_txrx_pdev_handle pdev = (ol_txrx_pdev_handle)ppdev;
 	struct ol_txrx_ipa_resources *ipa_res = &pdev->ipa_resource;
-	struct ipa_wdi_in_params pipe_in;
-	struct ipa_wdi_out_params pipe_out;
+	qdf_ipa_wdi_in_params_t pipe_in;
+	qdf_ipa_wdi_out_params_t pipe_out;
+
 	int ret;
 
-	qdf_mem_zero(&pipe_in, sizeof(struct ipa_wdi_in_params));
-	qdf_mem_zero(&pipe_out, sizeof(struct ipa_wdi_out_params));
+	qdf_mem_zero(&pipe_in, sizeof(pipe_in));
+	qdf_mem_zero(&pipe_out, sizeof(pipe_out));
+
 
 	/* TX PIPE */
-	pipe_in.sys.ipa_ep_cfg.nat.nat_en = IPA_BYPASS_NAT;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_len = OL_TXRX_IPA_UC_WLAN_TX_HDR_LEN;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_ofst_pkt_size_valid = 1;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_ofst_pkt_size = 0;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_additional_const_len =
+	QDF_IPA_PIPE_IN_NAT_EN(&pipe_in) = IPA_BYPASS_NAT;
+	QDF_IPA_PIPE_IN_HDR_LEN(&pipe_in) = OL_TXRX_IPA_UC_WLAN_TX_HDR_LEN;
+	QDF_IPA_PIPE_IN_HDR_OFST_PKT_SIZE_VALID(&pipe_in) = 1;
+	QDF_IPA_PIPE_IN_HDR_OFST_PKT_SIZE(&pipe_in) = 0;
+	QDF_IPA_PIPE_IN_HDR_ADDITIONAL_CONST_LEN(&pipe_in) =
 		OL_TXRX_IPA_UC_WLAN_8023_HDR_SIZE;
-	pipe_in.sys.ipa_ep_cfg.mode.mode = IPA_BASIC;
-	pipe_in.sys.client = IPA_CLIENT_WLAN1_CONS;
-	pipe_in.sys.desc_fifo_sz = ipa_desc_size;
-	pipe_in.sys.priv = ipa_priv;
-	pipe_in.sys.ipa_ep_cfg.hdr_ext.hdr_little_endian = true;
-	pipe_in.sys.notify = ipa_i2w_cb;
+	QDF_IPA_PIPE_IN_MODE(&pipe_in) = IPA_BASIC;
+	QDF_IPA_PIPE_IN_CLIENT(&pipe_in) = IPA_CLIENT_WLAN1_CONS;
+	QDF_IPA_PIPE_IN_DESC_FIFO_SZ(&pipe_in) = ipa_desc_size;
+	QDF_IPA_PIPE_IN_PRIV(&pipe_in) = ipa_priv;
+	QDF_IPA_PIPE_IN_HDR_LITTLE_ENDIAN(&pipe_in) = true;
+	QDF_IPA_PIPE_IN_NOTIFY(&pipe_in) = ipa_i2w_cb;
+
 	if (!is_rm_enabled) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 			    "%s: IPA RM DISABLED, IPA AWAKE", __func__);
-		pipe_in.sys.keep_ipa_awake = true;
+		QDF_IPA_PIPE_IN_KEEP_IPA_AWAKE(&pipe_in) = true;
 	}
 
-	pipe_in.u.dl.comp_ring_base_pa = ipa_res->tx_comp_ring_base_paddr;
-	pipe_in.u.dl.comp_ring_size = ipa_res->tx_comp_ring_size *
-				      sizeof(qdf_dma_addr_t);
-	pipe_in.u.dl.ce_ring_base_pa = ipa_res->ce_sr_base_paddr;
-	pipe_in.u.dl.ce_door_bell_pa = ipa_res->ce_reg_paddr;
-	pipe_in.u.dl.ce_ring_size = ipa_res->ce_sr_ring_size;
-	pipe_in.u.dl.num_tx_buffers = ipa_res->tx_num_alloc_buffer;
+	QDF_IPA_PIPE_IN_DL_COMP_RING_BASE_PA(&pipe_in) =
+		ipa_res->tx_comp_ring_base_paddr;
+	QDF_IPA_PIPE_IN_DL_COMP_RING_SIZE(&pipe_in) =
+		ipa_res->tx_comp_ring_size * sizeof(qdf_dma_addr_t);
+	QDF_IPA_PIPE_IN_DL_CE_RING_BASE_PA(&pipe_in) =
+		ipa_res->ce_sr_base_paddr;
+	QDF_IPA_PIPE_IN_DL_CE_DOOR_BELL_PA(&pipe_in) = ipa_res->ce_reg_paddr;
+	QDF_IPA_PIPE_IN_DL_CE_RING_SIZE(&pipe_in) = ipa_res->ce_sr_ring_size;
+	QDF_IPA_PIPE_IN_DL_NUM_TX_BUFFERS(&pipe_in) =
+		ipa_res->tx_num_alloc_buffer;
 
 	/* Connect WDI IPA PIPE */
 	ret = ipa_connect_wdi_pipe(&pipe_in, &pipe_out);
@@ -347,52 +353,56 @@ QDF_STATUS ol_txrx_ipa_setup(struct cdp_pdev *ppdev, void *ipa_i2w_cb,
 
 	/* Micro Controller Doorbell register */
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
-		"%s CONS DB pipe out 0x%x TX PIPE Handle 0x%x",
-		__func__, (unsigned int)pipe_out.uc_door_bell_pa,
+		"%s CONS DB pipe out 0x%x TX PIPE Handle 0x%x", __func__,
+		(unsigned int)QDF_IPA_PIPE_OUT_UC_DOOR_BELL_PA(&pipe_out),
 		pipe_out.clnt_hdl);
-	ipa_res->tx_comp_doorbell_paddr = pipe_out.uc_door_bell_pa;
+	ipa_res->tx_comp_doorbell_paddr =
+		QDF_IPA_PIPE_OUT_UC_DOOR_BELL_PA(&pipe_out);
 	/* WLAN TX PIPE Handle */
-	ipa_res->tx_pipe_handle = pipe_out.clnt_hdl;
-	*p_tx_pipe_handle = pipe_out.clnt_hdl;
+	ipa_res->tx_pipe_handle = QDF_IPA_PIPE_OUT_CLNT_HDL(&pipe_out);
+	*p_tx_pipe_handle = QDF_IPA_PIPE_OUT_CLNT_HDL(&pipe_out);
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 		"TX: %s 0x%x, %s %d, %s 0x%x, %s 0x%x, %s %d, %sNB %d, %s 0x%x",
 		"comp_ring_base_pa",
-		(unsigned int)pipe_in.u.dl.comp_ring_base_pa,
+		(unsigned int)QDF_IPA_PIPE_IN_DL_COMP_RING_BASE_PA(&pipe_in),
 		"comp_ring_size",
-		pipe_in.u.dl.comp_ring_size,
+		QDF_IPA_PIPE_IN_DL_COMP_RING_SIZE(&pipe_in),
 		"ce_ring_base_pa",
-		(unsigned int)pipe_in.u.dl.ce_ring_base_pa,
+		(unsigned int)QDF_IPA_PIPE_IN_DL_CE_RING_BASE_PA(&pipe_in),
 		"ce_door_bell_pa",
-		(unsigned int)pipe_in.u.dl.ce_door_bell_pa,
+		(unsigned int)QDF_IPA_PIPE_IN_DL_CE_DOOR_BELL_PA(&pipe_in),
 		"ce_ring_size",
-		pipe_in.u.dl.ce_ring_size,
+		QDF_IPA_PIPE_IN_DL_CE_RING_SIZE(&pipe_in),
 		"num_tx_buffers",
-		pipe_in.u.dl.num_tx_buffers,
+		QDF_IPA_PIPE_IN_DL_NUM_TX_BUFFERS(&pipe_in),
 		"tx_comp_doorbell_paddr",
 		(unsigned int)ipa_res->tx_comp_doorbell_paddr);
 
 	/* RX PIPE */
-	pipe_in.sys.ipa_ep_cfg.nat.nat_en = IPA_BYPASS_NAT;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_len = OL_TXRX_IPA_UC_WLAN_RX_HDR_LEN;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_ofst_metadata_valid = 0;
-	pipe_in.sys.ipa_ep_cfg.hdr.hdr_metadata_reg_valid = 1;
-	pipe_in.sys.ipa_ep_cfg.mode.mode = IPA_BASIC;
-	pipe_in.sys.client = IPA_CLIENT_WLAN1_PROD;
-	pipe_in.sys.desc_fifo_sz = ipa_desc_size + sizeof(struct sps_iovec);
-	pipe_in.sys.notify = ipa_w2i_cb;
+	QDF_IPA_PIPE_IN_NAT_EN(&pipe_in) = IPA_BYPASS_NAT;
+	QDF_IPA_PIPE_IN_HDR_LEN(&pipe_in) = OL_TXRX_IPA_UC_WLAN_RX_HDR_LEN;
+	QDF_IPA_PIPE_IN_HDR_OFST_METADATA_VALID(&pipe_in) = 0;
+	QDF_IPA_PIPE_IN_HDR_METADATA_REG_VALID(&pipe_in) = 1;
+	QDF_IPA_PIPE_IN_MODE(&pipe_in) = IPA_BASIC;
+	QDF_IPA_PIPE_IN_CLIENT(&pipe_in) = IPA_CLIENT_WLAN1_PROD;
+	QDF_IPA_PIPE_IN_DESC_FIFO_SZ(&pipe_in) =
+		ipa_desc_size + sizeof(struct sps_iovec);
+	QDF_IPA_PIPE_IN_NOTIFY(&pipe_in) = ipa_w2i_cb;
 	if (!is_rm_enabled) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			    "%s: IPA RM DISABLED, IPA AWAKE", __func__);
-		pipe_in.sys.keep_ipa_awake = true;
+		QDF_IPA_PIPE_IN_KEEP_IPA_AWAKE(&pipe_in) = true;
 	}
 
-	pipe_in.u.ul.rdy_ring_base_pa = ipa_res->rx_rdy_ring_base_paddr;
-	pipe_in.u.ul.rdy_ring_size = ipa_res->rx_rdy_ring_size;
-	pipe_in.u.ul.rdy_ring_rp_pa = ipa_res->rx_proc_done_idx_paddr;
+	QDF_IPA_PIPE_IN_UL_RDY_RING_BASE_PA(&pipe_in) =
+		ipa_res->rx_rdy_ring_base_paddr;
+	QDF_IPA_PIPE_IN_UL_RDY_RING_SIZE(&pipe_in) = ipa_res->rx_rdy_ring_size;
+	QDF_IPA_PIPE_IN_UL_RDY_RING_RP_PA(&pipe_in) =
+		ipa_res->rx_proc_done_idx_paddr;
 	OL_TXRX_IPA_WDI2_SET(pipe_in, ipa_res);
 
 #ifdef FEATURE_METERING
-	pipe_in.wdi_notify = ipa_wdi_meter_notifier_cb;
+	QDF_IPA_PIPE_IN_WDI_NOTIFY(&pipe_in) = ipa_wdi_meter_notifier_cb;
 #endif
 
 	ret = ipa_connect_wdi_pipe(&pipe_in, &pipe_out);
@@ -401,17 +411,18 @@ QDF_STATUS ol_txrx_ipa_setup(struct cdp_pdev *ppdev, void *ipa_i2w_cb,
 		    "ipa_connect_wdi_pipe: Rx pipe setup failed: ret=%d", ret);
 		return QDF_STATUS_E_FAILURE;
 	}
-	ipa_res->rx_ready_doorbell_paddr = pipe_out.uc_door_bell_pa;
-	ipa_res->rx_pipe_handle = pipe_out.clnt_hdl;
-	*p_rx_pipe_handle = pipe_out.clnt_hdl;
+	ipa_res->rx_ready_doorbell_paddr =
+		QDF_IPA_PIPE_OUT_UC_DOOR_BELL_PA(&pipe_out);
+	ipa_res->rx_pipe_handle = QDF_IPA_PIPE_OUT_CLNT_HDL(&pipe_out);
+	*p_rx_pipe_handle = QDF_IPA_PIPE_OUT_CLNT_HDL(&pipe_out);
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 		  "RX: %s 0x%x, %s %d, %s 0x%x, %s 0x%x",
 		  "rdy_ring_base_pa",
-		  (unsigned int)pipe_in.u.ul.rdy_ring_base_pa,
+		  (unsigned int)QDF_IPA_PIPE_IN_UL_RDY_RING_BASE_PA(&pipe_in),
 		  "rdy_ring_size",
-		  pipe_in.u.ul.rdy_ring_size,
+		  QDF_IPA_PIPE_IN_UL_RDY_RING_SIZE(&pipe_in),
 		  "rdy_ring_rp_pa",
-		  (unsigned int)pipe_in.u.ul.rdy_ring_rp_pa,
+		  (unsigned int)QDF_IPA_PIPE_IN_UL_RDY_RING_RP_PA(&pipe_in),
 		  "rx_ready_doorbell_paddr",
 		  (unsigned int)ipa_res->rx_ready_doorbell_paddr);
 
@@ -462,13 +473,13 @@ QDF_STATUS ol_txrx_ipa_cleanup(uint32_t tx_pipe_handle, uint32_t rx_pipe_handle)
  */
 static QDF_STATUS ol_txrx_ipa_remove_header(char *name)
 {
-	struct ipa_ioc_get_hdr hdrlookup;
+	qdf_ipa_ioc_get_hdr_t hdrlookup;
 	int ret = 0, len;
-	struct ipa_ioc_del_hdr *ipa_hdr;
+	qdf_ipa_ioc_del_hdr_t *ipa_hdr;
 
 	qdf_mem_zero(&hdrlookup, sizeof(hdrlookup));
 	strlcpy(hdrlookup.name, name, sizeof(hdrlookup.name));
-	ret = ipa_get_hdr(&hdrlookup);
+	ret = qdf_ipa_get_hdr(&hdrlookup);
 	if (ret) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 			  "Hdr deleted already %s, %d", name, ret);
@@ -477,18 +488,18 @@ static QDF_STATUS ol_txrx_ipa_remove_header(char *name)
 
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, "hdl: 0x%x",
 		  hdrlookup.hdl);
-	len = sizeof(struct ipa_ioc_del_hdr) + sizeof(struct ipa_hdr_del) * 1;
-	ipa_hdr = (struct ipa_ioc_del_hdr *)qdf_mem_malloc(len);
+	len = sizeof(qdf_ipa_ioc_del_hdr_t) + sizeof(qdf_ipa_hdr_del_t) * 1;
+	ipa_hdr = (qdf_ipa_ioc_del_hdr_t *)qdf_mem_malloc(len);
 	if (ipa_hdr == NULL) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			  "ipa_hdr allocation failed");
 		return QDF_STATUS_E_FAILURE;
 	}
-	ipa_hdr->num_hdls = 1;
-	ipa_hdr->commit = 0;
-	ipa_hdr->hdl[0].hdl = hdrlookup.hdl;
-	ipa_hdr->hdl[0].status = -1;
-	ret = ipa_del_hdr(ipa_hdr);
+	QDF_IPA_IOC_DEL_HDR_NUM_HDRS(ipa_hdr) = 1;
+	QDF_IPA_IOC_DEL_HDR_COMMIT(ipa_hdr) = 0;
+	QDF_IPA_IOC_DEL_HDR_HDL(ipa_hdr) = QDF_IPA_IOC_GET_HDR_HDL(&hdrlookup);
+	QDF_IPA_IOC_DEL_HDR_STATUS(ipa_hdr) = -1;
+	ret = qdf_ipa_del_hdr(ipa_hdr);
 	if (ret != 0) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			  "Delete header failed: %d", ret);
@@ -511,7 +522,7 @@ static QDF_STATUS ol_txrx_ipa_remove_header(char *name)
 static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
 				       uint8_t session_id, bool is_ipv6_enabled)
 {
-	struct ipa_ioc_add_hdr *ipa_hdr = NULL;
+	qdf_ipa_ioc_add_hdr_t *ipa_hdr = NULL;
 	int ret = -EINVAL;
 	struct ol_txrx_ipa_uc_tx_hdr *uc_tx_hdr = NULL;
 
@@ -519,8 +530,8 @@ static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
 		  "Add Partial hdr: %s, %pM", ifname, mac_addr);
 
 	/* dynamically allocate the memory to add the hdrs */
-	ipa_hdr = qdf_mem_malloc(sizeof(struct ipa_ioc_add_hdr)
-				 + sizeof(struct ipa_hdr_add));
+	ipa_hdr = qdf_mem_malloc(sizeof(qdf_ipa_ioc_add_hdr_t)
+				 + sizeof(qdf_ipa_hdr_add_t));
 	if (!ipa_hdr) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			    "%s: ipa_hdr allocation failed", ifname);
@@ -528,26 +539,28 @@ static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
 		goto end;
 	}
 
-	ipa_hdr->commit = 0;
-	ipa_hdr->num_hdrs = 1;
+	QDF_IPA_IOC_ADD_HDR_COMMIT(ipa_hdr) = 0;
+	QDF_IPA_IOC_ADD_HDR_NUM_HDRS(ipa_hdr) = 1;
 
-	uc_tx_hdr = (struct ol_txrx_ipa_uc_tx_hdr *)ipa_hdr->hdr[0].hdr;
+	uc_tx_hdr = (struct ol_txrx_ipa_uc_tx_hdr *)
+		QDF_IPA_IOC_ADD_HDR_HDR(ipa_hdr);
 	memcpy(uc_tx_hdr, &ipa_uc_tx_hdr, OL_TXRX_IPA_UC_WLAN_TX_HDR_LEN);
 	memcpy(uc_tx_hdr->eth.h_source, mac_addr, ETH_ALEN);
 	uc_tx_hdr->ipa_hd.vdev_id = session_id;
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 		  "ifname=%s, vdev_id=%d",
 		  ifname, uc_tx_hdr->ipa_hd.vdev_id);
-	snprintf(ipa_hdr->hdr[0].name, IPA_RESOURCE_NAME_MAX, "%s%s",
-		 ifname, OL_TXRX_IPA_IPV4_NAME_EXT);
-	ipa_hdr->hdr[0].hdr_len = OL_TXRX_IPA_UC_WLAN_TX_HDR_LEN;
-	ipa_hdr->hdr[0].type = IPA_HDR_L2_ETHERNET_II;
-	ipa_hdr->hdr[0].is_partial = 1;
-	ipa_hdr->hdr[0].hdr_hdl = 0;
-	ipa_hdr->hdr[0].is_eth2_ofst_valid = 1;
-	ipa_hdr->hdr[0].eth2_ofst = OL_TXRX_IPA_UC_WLAN_HDR_DES_MAC_OFFSET;
-
-	ret = ipa_add_hdr(ipa_hdr);
+	snprintf(QDF_IPA_IOC_ADD_HDR_NAME(ipa_hdr), IPA_RESOURCE_NAME_MAX,
+		 "%s%s", ifname, OL_TXRX_IPA_IPV4_NAME_EXT);
+	QDF_IPA_IOC_ADD_HDR_HDR_LEN(ipa_hdr) = OL_TXRX_IPA_UC_WLAN_TX_HDR_LEN;
+	QDF_IPA_IOC_ADD_HDR_TYPE(ipa_hdr) = IPA_HDR_L2_ETHERNET_II;
+	QDF_IPA_IOC_ADD_HDR_IS_PARTIAL(ipa_hdr) = 1;
+	QDF_IPA_IOC_ADD_HDR_HDR_HDL(ipa_hdr) = 0;
+	QDF_IPA_IOC_ADD_HDR_IS_ETH2_OFST_VALID(ipa_hdr) = 1;
+	QDF_IPA_IOC_ADD_HDR_ETH2_OFST(ipa_hdr) =
+		OL_TXRX_IPA_UC_WLAN_HDR_DES_MAC_OFFSET;
+
+	ret = qdf_ipa_add_hdr(ipa_hdr);
 	if (ret) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			  "%s IPv4 add hdr failed: %d", ifname, ret);
@@ -555,17 +568,20 @@ static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
 	}
 
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
-		  "%s: IPv4 hdr_hdl: 0x%x",
-		  ipa_hdr->hdr[0].name, ipa_hdr->hdr[0].hdr_hdl);
+		"%s: IPv4 hdr_hdl: 0x%x",
+		QDF_IPA_IOC_ADD_HDR_NAME(ipa_hdr),
+		QDF_IPA_IOC_ADD_HDR_HDR_HDL(ipa_hdr));
 
 	if (is_ipv6_enabled) {
-		snprintf(ipa_hdr->hdr[0].name, IPA_RESOURCE_NAME_MAX, "%s%s",
+		snprintf(QDF_IPA_IOC_ADD_HDR_NAME(ipa_hdr),
+			 IPA_RESOURCE_NAME_MAX, "%s%s",
 			 ifname, OL_TXRX_IPA_IPV6_NAME_EXT);
 
-		uc_tx_hdr = (struct ol_txrx_ipa_uc_tx_hdr *)ipa_hdr->hdr[0].hdr;
+		uc_tx_hdr = (struct ol_txrx_ipa_uc_tx_hdr *)
+			QDF_IPA_IOC_ADD_HDR_HDR(ipa_hdr);
 		uc_tx_hdr->eth.h_proto = cpu_to_be16(ETH_P_IPV6);
 
-		ret = ipa_add_hdr(ipa_hdr);
+		ret = qdf_ipa_add_hdr(ipa_hdr);
 		if (ret) {
 			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 				    "%s: IPv6 add hdr failed: %d", ifname, ret);
@@ -573,8 +589,9 @@ static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
 		}
 
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
-			  "%s: IPv6 hdr_hdl: 0x%x",
-			  ipa_hdr->hdr[0].name, ipa_hdr->hdr[0].hdr_hdl);
+			"%s: IPv6 hdr_hdl: 0x%x",
+			QDF_IPA_IOC_ADD_HDR_NAME(ipa_hdr),
+			QDF_IPA_IOC_ADD_HDR_HDR_HDL(ipa_hdr));
 	}
 
 	qdf_mem_free(ipa_hdr);
@@ -603,15 +620,15 @@ end:
  * Return: 0 on success, negative errno on error
  */
 static int ol_txrx_ipa_register_interface(char *ifname,
-					  enum ipa_client_type prod_client,
-					  enum ipa_client_type cons_client,
+					  qdf_ipa_client_type_t prod_client,
+					  qdf_ipa_client_type_t cons_client,
 					  uint8_t session_id,
 					  bool is_ipv6_enabled)
 {
-	struct ipa_tx_intf tx_intf;
-	struct ipa_rx_intf rx_intf;
-	struct ipa_ioc_tx_intf_prop *tx_prop = NULL;
-	struct ipa_ioc_rx_intf_prop *rx_prop = NULL;
+	qdf_ipa_tx_intf_t tx_intf;
+	qdf_ipa_rx_intf_t rx_intf;
+	qdf_ipa_ioc_tx_intf_prop_t *tx_prop = NULL;
+	qdf_ipa_ioc_rx_intf_prop_t *rx_prop = NULL;
 
 	char ipv4_hdr_name[IPA_RESOURCE_NAME_MAX];
 	char ipv6_hdr_name[IPA_RESOURCE_NAME_MAX];
@@ -624,7 +641,7 @@ static int ol_txrx_ipa_register_interface(char *ifname,
 
 	/* Allocate TX properties for TOS categories, 1 each for IPv4 & IPv6 */
 	tx_prop =
-		qdf_mem_malloc(sizeof(struct ipa_ioc_tx_intf_prop) * num_prop);
+		qdf_mem_malloc(sizeof(qdf_ipa_ioc_tx_intf_prop_t) * num_prop);
 	if (!tx_prop) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			  "tx_prop allocation failed");
@@ -633,7 +650,7 @@ static int ol_txrx_ipa_register_interface(char *ifname,
 
 	/* Allocate RX properties, 1 each for IPv4 & IPv6 */
 	rx_prop =
-		qdf_mem_malloc(sizeof(struct ipa_ioc_rx_intf_prop) * num_prop);
+		qdf_mem_malloc(sizeof(qdf_ipa_ioc_rx_intf_prop_t) * num_prop);
 	if (!rx_prop) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 			  "rx_prop allocation failed");
@@ -648,52 +665,65 @@ static int ol_txrx_ipa_register_interface(char *ifname,
 	snprintf(ipv6_hdr_name, IPA_RESOURCE_NAME_MAX, "%s%s",
 		 ifname, OL_TXRX_IPA_IPV6_NAME_EXT);
 
-	rx_prop[IPA_IP_v4].ip = IPA_IP_v4;
-	rx_prop[IPA_IP_v4].src_pipe = prod_client;
-	rx_prop[IPA_IP_v4].hdr_l2_type = IPA_HDR_L2_ETHERNET_II;
-	rx_prop[IPA_IP_v4].attrib.attrib_mask = IPA_FLT_META_DATA;
+	QDF_IPA_IOC_RX_INTF_PROP_IP(&rx_prop[IPA_IP_v4]) = IPA_IP_v4;
+	QDF_IPA_IOC_RX_INTF_PROP_SRC_PIPE(&rx_prop[IPA_IP_v4]) = prod_client;
+	QDF_IPA_IOC_RX_INTF_PROP_HDR_L2_TYPE(&rx_prop[IPA_IP_v4]) =
+		IPA_HDR_L2_ETHERNET_II;
+	QDF_IPA_IOC_RX_INTF_PROP_ATTRIB_MASK(&rx_prop[IPA_IP_v4]) =
+		IPA_FLT_META_DATA;
 
 	/*
 	 * Interface ID is 3rd byte in the CLD header. Add the meta data and
 	 * mask to identify the interface in IPA hardware
 	 */
-	rx_prop[IPA_IP_v4].attrib.meta_data =
+	QDF_IPA_IOC_RX_INTF_PROP_META_DATA(&rx_prop[IPA_IP_v4]) =
 		htonl(session_id << 16);
-	rx_prop[IPA_IP_v4].attrib.meta_data_mask = htonl(0x00FF0000);
+	QDF_IPA_IOC_RX_INTF_PROP_META_DATA_MASK(&rx_prop[IPA_IP_v4]) =
+		htonl(0x00FF0000);
 
 	rx_intf.num_props++;
 	if (is_ipv6_enabled) {
-		rx_prop[IPA_IP_v6].ip = IPA_IP_v6;
-		rx_prop[IPA_IP_v6].src_pipe = prod_client;
-		rx_prop[IPA_IP_v6].hdr_l2_type = IPA_HDR_L2_ETHERNET_II;
-		rx_prop[IPA_IP_v6].attrib.attrib_mask = IPA_FLT_META_DATA;
-		rx_prop[IPA_IP_v6].attrib.meta_data =
+		QDF_IPA_IOC_RX_INTF_PROP_IP(&rx_prop[IPA_IP_v6]) = IPA_IP_v6;
+		QDF_IPA_IOC_RX_INTF_PROP_SRC_PIPE(&rx_prop[IPA_IP_v6]) =
+			prod_client;
+		QDF_IPA_IOC_RX_INTF_PROP_HDR_L2_TYPE(&rx_prop[IPA_IP_v6]) =
+			IPA_HDR_L2_ETHERNET_II;
+		QDF_IPA_IOC_RX_INTF_PROP_ATTRIB_MASK(&rx_prop[IPA_IP_v6]) =
+			IPA_FLT_META_DATA;
+		QDF_IPA_IOC_RX_INTF_PROP_META_DATA(&rx_prop[IPA_IP_v6]) =
 			htonl(session_id << 16);
-		rx_prop[IPA_IP_v4].attrib.meta_data_mask = htonl(0x00FF0000);
+		QDF_IPA_IOC_RX_INTF_PROP_META_DATA_MASK(&rx_prop[IPA_IP_v6]) =
+			htonl(0x00FF0000);
 
 		rx_intf.num_props++;
 	}
 
-	tx_prop[IPA_IP_v4].ip = IPA_IP_v4;
-	tx_prop[IPA_IP_v4].hdr_l2_type = IPA_HDR_L2_ETHERNET_II;
-	tx_prop[IPA_IP_v4].dst_pipe = IPA_CLIENT_WLAN1_CONS;
-	tx_prop[IPA_IP_v4].alt_dst_pipe = cons_client;
-	strlcpy(tx_prop[IPA_IP_v4].hdr_name, ipv4_hdr_name,
-			IPA_RESOURCE_NAME_MAX);
+	QDF_IPA_IOC_TX_INTF_PROP_IP(&tx_prop[IPA_IP_v4]) = IPA_IP_v4;
+	QDF_IPA_IOC_TX_INTF_PROP_HDR_L2_TYPE(&tx_prop[IPA_IP_v4]) =
+			IPA_HDR_L2_ETHERNET_II;
+	QDF_IPA_IOC_TX_INTF_PROP_DST_PIPE(&tx_prop[IPA_IP_v4]) =
+			IPA_CLIENT_WLAN1_CONS;
+	QDF_IPA_IOC_TX_INTF_PROP_ALT_DST_PIPE(&tx_prop[IPA_IP_v4]) =
+			cons_client;
+	strlcpy(QDF_IPA_IOC_TX_INTF_PROP_HDR_NAME(&tx_prop[IPA_IP_v4]),
+		ipv4_hdr_name, IPA_RESOURCE_NAME_MAX);
 	tx_intf.num_props++;
 
 	if (is_ipv6_enabled) {
-		tx_prop[IPA_IP_v6].ip = IPA_IP_v6;
-		tx_prop[IPA_IP_v6].hdr_l2_type = IPA_HDR_L2_ETHERNET_II;
-		tx_prop[IPA_IP_v6].dst_pipe = IPA_CLIENT_WLAN1_CONS;
-		tx_prop[IPA_IP_v6].alt_dst_pipe = cons_client;
-		strlcpy(tx_prop[IPA_IP_v6].hdr_name, ipv6_hdr_name,
-				IPA_RESOURCE_NAME_MAX);
+		QDF_IPA_IOC_TX_INTF_PROP_IP(&tx_prop[IPA_IP_v6]) = IPA_IP_v6;
+		QDF_IPA_IOC_TX_INTF_PROP_HDR_L2_TYPE(&tx_prop[IPA_IP_v6]) =
+			IPA_HDR_L2_ETHERNET_II;
+		QDF_IPA_IOC_TX_INTF_PROP_DST_PIPE(&tx_prop[IPA_IP_v6]) =
+			IPA_CLIENT_WLAN1_CONS;
+		QDF_IPA_IOC_TX_INTF_PROP_ALT_DST_PIPE(&tx_prop[IPA_IP_v6]) =
+			cons_client;
+		strlcpy(QDF_IPA_IOC_TX_INTF_PROP_HDR_NAME(&tx_prop[IPA_IP_v6]),
+			ipv6_hdr_name, IPA_RESOURCE_NAME_MAX);
 		tx_intf.num_props++;
 	}
 
-	tx_intf.prop = tx_prop;
-	rx_intf.prop = rx_prop;
+	QDF_IPA_TX_INTF_PROP(&tx_intf) = tx_prop;
+	QDF_IPA_RX_INTF_PROP(&rx_intf) = rx_prop;
 
 	/* Call the ipa api to register interface */
 	ret = ipa_register_intf(ifname, &tx_intf, &rx_intf);
@@ -716,8 +746,8 @@ register_interface_fail:
  * Return: QDF_STATUS
  */
 QDF_STATUS ol_txrx_ipa_setup_iface(char *ifname, uint8_t *mac_addr,
-				   enum ipa_client_type prod_client,
-				   enum ipa_client_type cons_client,
+				   qdf_ipa_client_type_t prod_client,
+				   qdf_ipa_client_type_t cons_client,
 				   uint8_t session_id, bool is_ipv6_enabled)
 {
 	int ret;
@@ -728,7 +758,9 @@ QDF_STATUS ol_txrx_ipa_setup_iface(char *ifname, uint8_t *mac_addr,
 		return QDF_STATUS_E_FAILURE;
 
 	/* Configure the TX and RX pipes filter rules */
-	ret = ol_txrx_ipa_register_interface(ifname, prod_client, cons_client,
+	ret = ol_txrx_ipa_register_interface(ifname,
+					     prod_client,
+					     cons_client,
 					     session_id, is_ipv6_enabled);
 	if (ret)
 		return QDF_STATUS_E_FAILURE;
@@ -759,7 +791,7 @@ QDF_STATUS ol_txrx_ipa_cleanup_iface(char *ifname, bool is_ipv6_enabled)
 		ol_txrx_ipa_remove_header(name_ipa);
 	}
 	/* unregister the interface with IPA */
-	ret = ipa_deregister_intf(ifname);
+	ret = qdf_ipa_deregister_intf(ifname);
 	if (ret) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
 				"%s: ipa_deregister_intf fail: %d",
@@ -885,11 +917,12 @@ QDF_STATUS ol_txrx_ipa_disable_pipes(struct cdp_pdev *ppdev)
 QDF_STATUS ol_txrx_ipa_set_perf_level(int client,
 				      uint32_t max_supported_bw_mbps)
 {
-	struct ipa_rm_perf_profile profile;
+	qdf_ipa_rm_perf_profile_t profile;
 	int result;
 
-	profile.max_supported_bandwidth_mbps = max_supported_bw_mbps;
-	result = ipa_rm_set_perf_profile(client, &profile);
+	QDF_IPA_RM_PERF_PROFILE_MAX_SUPPORTED_BANDWIDTH_MBPS(&profile) =
+		max_supported_bw_mbps;
+	result = qdf_ipa_rm_set_perf_profile(client, &profile);
 
 	if (result) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,

core/dp/txrx/ol_txrx_ipa.h

@@ -117,8 +117,8 @@ QDF_STATUS ol_txrx_ipa_setup(struct cdp_pdev *pdev, void *ipa_i2w_cb,
 QDF_STATUS ol_txrx_ipa_cleanup(uint32_t tx_pipe_handle,
 		uint32_t rx_pipe_handle);
 QDF_STATUS ol_txrx_ipa_setup_iface(char *ifname, uint8_t *mac_addr,
-		enum ipa_client_type prod_client,
-		enum ipa_client_type cons_client,
+		qdf_ipa_client_type_t prod_client,
+		qdf_ipa_client_type_t cons_client,
 		uint8_t session_id, bool is_ipv6_enabled);
 QDF_STATUS ol_txrx_ipa_cleanup_iface(char *ifname, bool is_ipv6_enabled);
 QDF_STATUS ol_txrx_ipa_enable_pipes(struct cdp_pdev *pdev);

core/hdd/src/wlan_hdd_ipa.c

@@ -35,18 +35,11 @@
 #ifdef IPA_OFFLOAD
 
 /* Include Files */
-#include <linux/ipa.h>
+#include <qdf_ipa.h>
 #include <wlan_hdd_includes.h>
 #include <wlan_hdd_ipa.h>
 
-#include <linux/etherdevice.h>
-#include <linux/atomic.h>
-#include <linux/netdevice.h>
-#include <linux/skbuff.h>
-#include <linux/list.h>
-#include <linux/debugfs.h>
 #include <linux/inetdevice.h>
-#include <linux/ip.h>
 #include <wlan_hdd_softap_tx_rx.h>
 #include <ol_txrx.h>
 #include <cdp_txrx_peer_ops.h>
@@ -213,13 +206,13 @@ struct hdd_ipa_pm_tx_cb {
 	bool exception;
 	struct hdd_adapter *adapter;
 	struct hdd_ipa_iface_context *iface_context;
-	struct ipa_rx_data *ipa_tx_desc;
+	qdf_ipa_rx_data_t *ipa_tx_desc;
 };
 
 struct hdd_ipa_sys_pipe {
 	uint32_t conn_hdl;
 	uint8_t conn_hdl_valid;
-	struct ipa_sys_connect_params ipa_sys_params;
+	qdf_ipa_sys_connect_params_t ipa_sys_params;
 };
 
 struct hdd_ipa_iface_stats {
@@ -237,8 +230,8 @@ struct hdd_ipa_iface_context {
 	struct hdd_adapter *adapter;
 	void *tl_context;
 
-	enum ipa_client_type cons_client;
-	enum ipa_client_type prod_client;
+	qdf_ipa_client_type_t cons_client;
+	qdf_ipa_client_type_t prod_client;
 
 	uint8_t iface_id;       /* This iface ID */
 	uint8_t sta_id;         /* This iface station ID */
@@ -313,7 +306,7 @@ struct ipa_uc_fw_stats {
 struct ipa_uc_pending_event {
 	qdf_list_node_t node;
 	struct hdd_adapter *adapter;
-	enum ipa_wlan_event type;
+	qdf_ipa_wlan_event_t type;
 	uint8_t sta_id;
 	uint8_t mac_addr[QDF_MAC_ADDR_SIZE];
 };
@@ -325,7 +318,7 @@ struct ipa_uc_pending_event {
  */
 struct uc_rm_work_struct {
 	struct work_struct work;
-	enum ipa_rm_event event;
+	qdf_ipa_rm_event_t event;
 };
 
 /**
@@ -395,7 +388,7 @@ struct hdd_ipa_tx_desc {
 	struct list_head link;
 	void *priv;
 	uint32_t id;
-	struct ipa_rx_data *ipa_tx_desc_ptr;
+	qdf_ipa_rx_data_t *ipa_tx_desc_ptr;
 };
 
 struct hdd_ipa_priv {
@@ -459,8 +452,8 @@ struct hdd_ipa_priv {
 	qdf_mc_timer_t rt_debug_timer;
 	struct uc_rt_debug_info rt_bug_buffer[HDD_IPA_UC_RT_DEBUG_BUF_COUNT];
 	unsigned int rt_buf_fill_index;
-	struct ipa_wdi_in_params cons_pipe_in;
-	struct ipa_wdi_in_params prod_pipe_in;
+	qdf_ipa_wdi_in_params_t cons_pipe_in;
+	qdf_ipa_wdi_in_params_t prod_pipe_in;
 	bool uc_loaded;
 	bool wdi_enabled;
 	qdf_mc_timer_t rt_debug_fill_timer;
@@ -522,8 +515,8 @@ struct hdd_ipa_priv {
 #define HDD_IPA_DBG_DUMP_TX_LEN 48
 
 static struct hdd_ipa_adapter_2_client {
-	enum ipa_client_type cons_client;
-	enum ipa_client_type prod_client;
+	qdf_ipa_client_type_t cons_client;
+	qdf_ipa_client_type_t prod_client;
 } hdd_ipa_adapter_2_client[HDD_IPA_MAX_IFACE] = {
 	{
 		IPA_CLIENT_WLAN2_CONS, IPA_CLIENT_WLAN1_PROD
@@ -544,12 +537,12 @@ static struct hdd_ipa_adapter_2_client {
 static struct hdd_ipa_priv *ghdd_ipa;
 
 /* Local Function Prototypes */
-static void hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
+static void hdd_ipa_i2w_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
 			   unsigned long data);
-static void hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
+static void hdd_ipa_w2i_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
 			   unsigned long data);
 #ifdef FEATURE_METERING
-static void hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
+static void hdd_ipa_wdi_meter_notifier_cb(qdf_ipa_wdi_meter_evt_type_t evt,
 					  void *data);
 #else
 static void hdd_ipa_wdi_meter_notifier_cb(void);
@@ -616,13 +609,13 @@ done:
  */
 static int hdd_ipa_uc_send_wdi_control_msg(bool ctrl)
 {
-	struct ipa_msg_meta meta;
-	struct ipa_wlan_msg *ipa_msg;
+	qdf_ipa_msg_meta_t meta;
+	qdf_ipa_wlan_msg_t *ipa_msg;
 	int ret = 0;
 
 	/* WDI enable message to IPA */
-	meta.msg_len = sizeof(*ipa_msg);
-	ipa_msg = qdf_mem_malloc(meta.msg_len);
+	QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(*ipa_msg);
+	ipa_msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
 	if (ipa_msg == NULL) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"msg allocation failed");
@@ -630,17 +623,17 @@ static int hdd_ipa_uc_send_wdi_control_msg(bool ctrl)
 	}
 
 	if (ctrl == true)
-		meta.msg_type = WLAN_WDI_ENABLE;
+		QDF_IPA_MSG_META_MSG_TYPE(&meta) = WLAN_WDI_ENABLE;
 	else
-		meta.msg_type = WLAN_WDI_DISABLE;
+		QDF_IPA_MSG_META_MSG_TYPE(&meta) = WLAN_WDI_DISABLE;
 
 	HDD_IPA_LOG(QDF_TRACE_LEVEL_DEBUG,
-		    "ipa_send_msg(Evt:%d)", meta.msg_type);
-	ret = ipa_send_msg(&meta, ipa_msg, hdd_ipa_msg_free_fn);
+		    "ipa_send_msg(Evt:%d)", QDF_IPA_MSG_META_MSG_TYPE(&meta));
+	ret = qdf_ipa_send_msg(&meta, ipa_msg, hdd_ipa_msg_free_fn);
 	if (ret) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"ipa_send_msg(Evt:%d)-fail=%d",
-			meta.msg_type,  ret);
+			QDF_IPA_MSG_META_MSG_TYPE(&meta),  ret);
 		qdf_mem_free(ipa_msg);
 	}
 	return ret;
@@ -659,18 +652,19 @@ static int hdd_ipa_uc_send_wdi_control_msg(bool ctrl)
  */
 static int hdd_ipa_uc_register_uc_ready(struct hdd_ipa_priv *hdd_ipa)
 {
-	struct ipa_wdi_uc_ready_params uc_ready_param;
+	qdf_ipa_wdi_uc_ready_params_t uc_ready_param;
 	int ret = 0;
 
 	hdd_ipa->uc_loaded = false;
-	uc_ready_param.priv = (void *)hdd_ipa;
-	uc_ready_param.notify = hdd_ipa_uc_loaded_uc_cb;
+	QDF_IPA_UC_READY_PARAMS_PRIV(&uc_ready_param) = (void *)hdd_ipa;
+	QDF_IPA_UC_READY_PARAMS_NOTIFY(&uc_ready_param) =
+		hdd_ipa_uc_loaded_uc_cb;
 	if (ipa_uc_reg_rdyCB(&uc_ready_param)) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"UC Ready CB register fail");
 		return -EPERM;
 	}
-	if (true == uc_ready_param.is_uC_ready) {
+	if (false != QDF_IPA_UC_READY_PARAMS_IS_UC_READY(&uc_ready_param)) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_INFO, "UC Ready");
 		hdd_ipa->uc_loaded = true;
 	} else {
@@ -1241,7 +1235,7 @@ static void hdd_ipa_dump_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 
 	for (i = 0; i < HDD_IPA_MAX_SYSBAM_PIPE; i++) {
 		struct hdd_ipa_sys_pipe *sys_pipe;
-		struct ipa_sys_connect_params *ipa_sys_params;
+		qdf_ipa_sys_connect_params_t *ipa_sys_params;
 
 		sys_pipe = &hdd_ipa->sys_pipe[i];
 		ipa_sys_params = &sys_pipe->ipa_sys_params;
@@ -1266,19 +1260,21 @@ static void hdd_ipa_dump_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 			i,
 			sys_pipe->conn_hdl,
 			sys_pipe->conn_hdl_valid,
-			ipa_sys_params->ipa_ep_cfg.nat.nat_en,
-			ipa_sys_params->ipa_ep_cfg.hdr.hdr_len,
-			ipa_sys_params->ipa_ep_cfg.hdr.hdr_additional_const_len,
-			ipa_sys_params->ipa_ep_cfg.hdr.hdr_ofst_pkt_size_valid,
-			ipa_sys_params->ipa_ep_cfg.hdr.hdr_ofst_pkt_size,
-			ipa_sys_params->ipa_ep_cfg.hdr_ext.hdr_little_endian,
-			ipa_sys_params->ipa_ep_cfg.mode.mode,
-			ipa_sys_params->client,
-			ipa_sys_params->desc_fifo_sz,
-			ipa_sys_params->priv,
-			ipa_sys_params->notify,
-			ipa_sys_params->skip_ep_cfg,
-			ipa_sys_params->keep_ipa_awake);
+			QDF_IPA_SYS_PARAMS_NAT_EN(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_HDR_LEN(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_HDR_ADDITIONAL_CONST_LEN(
+				ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_HDR_OFST_PKT_SIZE_VALID(
+				ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_HDR_OFST_PKT_SIZE(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_HDR_LITTLE_ENDIAN(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_MODE(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_CLIENT(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_DESC_FIFO_SZ(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_PRIV(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_NOTIFY(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_SKIP_EP_CFG(ipa_sys_params),
+			QDF_IPA_SYS_PARAMS_KEEP_IPA_AWAKE(ipa_sys_params));
 	}
 }
 
@@ -2055,7 +2051,7 @@ static void hdd_ipa_uc_handle_last_discon(struct hdd_ipa_priv *hdd_ipa)
  * Return: None
  */
 static void
-hdd_ipa_uc_rm_notify_handler(void *context, enum ipa_rm_event event)
+hdd_ipa_uc_rm_notify_handler(void *context, qdf_ipa_rm_event_t event)
 {
 	struct hdd_ipa_priv *hdd_ipa = context;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
@@ -2110,7 +2106,7 @@ hdd_ipa_uc_rm_notify_handler(void *context, enum ipa_rm_event event)
  */
 static void hdd_ipa_uc_rm_notify_defer(struct work_struct *work)
 {
-	enum ipa_rm_event event;
+	qdf_ipa_rm_event_t event;
 	struct uc_rm_work_struct *uc_rm_work = container_of(work,
 			struct uc_rm_work_struct, work);
 	struct hdd_ipa_priv *hdd_ipa = container_of(uc_rm_work,
@@ -2276,7 +2272,7 @@ static QDF_STATUS hdd_ipa_uc_op_metering(struct hdd_context *hdd_ctx,
  *
  * Return: ASCII string representing the IPA WLAN event
  */
-static inline char *hdd_ipa_wlan_event_to_str(enum ipa_wlan_event event)
+static inline char *hdd_ipa_wlan_event_to_str(qdf_ipa_wlan_event_t event)
 {
 	switch (event) {
 	CASE_RETURN_STRING(WLAN_CLIENT_CONNECT);
@@ -2940,13 +2936,13 @@ static void hdd_ipa_init_uc_op_work(struct work_struct *work,
  *
  * Return: None
  */
-static void __hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
+static void __hdd_ipa_wdi_meter_notifier_cb(qdf_ipa_wdi_meter_evt_type_t evt,
 					  void *data)
 {
 	struct hdd_ipa_priv *hdd_ipa = ghdd_ipa;
 	struct hdd_adapter *adapter = NULL;
-	struct ipa_get_wdi_sap_stats *wdi_sap_stats;
-	struct ipa_set_wifi_quota *ipa_set_quota;
+	qdf_ipa_get_wdi_sap_stats_t *wdi_sap_stats;
+	qdf_ipa_set_wifi_quota_t *ipa_set_quota;
 	int ret = 0;
 
 	if (wlan_hdd_validate_context(hdd_ipa->hdd_ctx))
@@ -2966,51 +2962,63 @@ static void __hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
 		if (!adapter) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 				"IPA uC share stats failed - no adapter");
-			wdi_sap_stats->stats_valid = 0;
+			QDF_IPA_GET_WDI_SAP_STATS_STATS_VALID(wdi_sap_stats) =
+				0;
 			return;
 		}
 
 		INIT_COMPLETION(hdd_ipa->ipa_uc_sharing_stats_comp);
 		hdd_ipa_uc_sharing_stats_request(adapter,
-					     wdi_sap_stats->reset_stats);
+			QDF_IPA_GET_WDI_SAP_STATS_RESET_STATS(wdi_sap_stats));
 		ret = wait_for_completion_timeout(
 			&hdd_ipa->ipa_uc_sharing_stats_comp,
 			msecs_to_jiffies(IPA_UC_SHARING_STATES_WAIT_TIME));
 		if (!ret) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 					"IPA uC share stats request timed out");
-			wdi_sap_stats->stats_valid = 0;
+			QDF_IPA_GET_WDI_SAP_STATS_STATS_VALID(wdi_sap_stats)
+				= 0;
 		} else {
-			wdi_sap_stats->stats_valid = 1;
-
-			wdi_sap_stats->ipv4_rx_packets =
-				hdd_ipa->ipa_sharing_stats.ipv4_rx_packets;
-			wdi_sap_stats->ipv4_rx_bytes =
-				hdd_ipa->ipa_sharing_stats.ipv4_rx_bytes;
-			wdi_sap_stats->ipv6_rx_packets =
-				hdd_ipa->ipa_sharing_stats.ipv6_rx_packets;
-			wdi_sap_stats->ipv6_rx_bytes =
-				hdd_ipa->ipa_sharing_stats.ipv6_rx_bytes;
-			wdi_sap_stats->ipv4_tx_packets =
-				hdd_ipa->ipa_sharing_stats.ipv4_tx_packets;
-			wdi_sap_stats->ipv4_tx_bytes =
-				hdd_ipa->ipa_sharing_stats.ipv4_tx_bytes;
-			wdi_sap_stats->ipv6_tx_packets =
-				hdd_ipa->ipa_sharing_stats.ipv6_tx_packets;
-			wdi_sap_stats->ipv6_tx_bytes =
-				hdd_ipa->ipa_sharing_stats.ipv6_tx_bytes;
+			QDF_IPA_GET_WDI_SAP_STATS_STATS_VALID(wdi_sap_stats)
+				= 1;
+
+			QDF_IPA_GET_WDI_SAP_STATS_IPV4_RX_PACKETS(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv4_rx_packets;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV4_RX_BYTES(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv4_rx_bytes;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV6_RX_PACKETS(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv6_rx_packets;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV6_RX_BYTES(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv6_rx_bytes;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV4_TX_PACKETS(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv4_tx_packets;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV4_TX_BYTES(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv4_tx_bytes;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV6_TX_PACKETS(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv6_tx_packets;
+			QDF_IPA_GET_WDI_SAP_STATS_IPV6_TX_BYTES(wdi_sap_stats)
+				= hdd_ipa->ipa_sharing_stats.ipv6_tx_bytes;
 			HDD_IPA_DP_LOG(QDF_TRACE_LEVEL_DEBUG,
 				"%s:%d,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu",
 				"IPA_GET_WDI_SAP_STATS",
-				wdi_sap_stats->stats_valid,
-				wdi_sap_stats->ipv4_rx_packets,
-				wdi_sap_stats->ipv4_rx_bytes,
-				wdi_sap_stats->ipv6_rx_packets,
-				wdi_sap_stats->ipv6_rx_bytes,
-				wdi_sap_stats->ipv4_tx_packets,
-				wdi_sap_stats->ipv4_tx_bytes,
-				wdi_sap_stats->ipv6_tx_packets,
-				wdi_sap_stats->ipv6_tx_bytes);
+				QDF_IPA_GET_WDI_SAP_STATS_STATS_VALID(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV4_RX_PACKETS(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV4_RX_BYTES(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV6_RX_PACKETS(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV6_RX_BYTES(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV4_TX_PACKETS(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV4_TX_BYTES(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV6_TX_PACKETS(
+					wdi_sap_stats),
+				QDF_IPA_GET_WDI_SAP_STATS_IPV6_TX_BYTES(
+					wdi_sap_stats));
 		}
 		break;
 	case IPA_SET_WIFI_QUOTA:
@@ -3036,12 +3044,12 @@ static void __hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
 		if (!ret) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 					"IPA uC set quota request timed out");
-			ipa_set_quota->set_valid = 0;
+			QDF_IPA_SET_WIFI_QUOTA_SET_VALID(ipa_set_quota)	= 0;
 		} else {
-			ipa_set_quota->quota_bytes =
+			QDF_IPA_SET_WIFI_QUOTA_BYTES(ipa_set_quota) =
 				((uint64_t)(hdd_ipa->ipa_quota_rsp.quota_hi)
 				  <<32)|hdd_ipa->ipa_quota_rsp.quota_lo;
-			ipa_set_quota->set_valid =
+			QDF_IPA_SET_WIFI_QUOTA_SET_VALID(ipa_set_quota)	=
 				hdd_ipa->ipa_quota_rsp.success;
 		}
 
@@ -3062,7 +3070,7 @@ static void __hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
  *
  * Return: None
  */
-static void hdd_ipa_wdi_meter_notifier_cb(enum ipa_wdi_meter_evt_type evt,
+static void hdd_ipa_wdi_meter_notifier_cb(qdf_ipa_wdi_meter_evt_type_t evt,
 					  void *data)
 {
 	cds_ssr_protect(__func__);
@@ -3289,32 +3297,33 @@ static void hdd_ipa_msg_free_fn(void *buff, uint32_t len, uint32_t type)
  * Return: 0 - Success
  */
 static int hdd_ipa_uc_send_evt(struct hdd_adapter *adapter,
-	enum ipa_wlan_event type, uint8_t *mac_addr)
+	qdf_ipa_wlan_event_t type, uint8_t *mac_addr)
 {
 	struct hdd_ipa_priv *hdd_ipa = ghdd_ipa;
-	struct ipa_msg_meta meta;
-	struct ipa_wlan_msg *msg;
+	qdf_ipa_msg_meta_t meta;
+	qdf_ipa_wlan_msg_t *msg;
 	int ret = 0;
 
-	meta.msg_len = sizeof(struct ipa_wlan_msg);
-	msg = qdf_mem_malloc(meta.msg_len);
+	QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(qdf_ipa_wlan_msg_t);
+	msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
 	if (msg == NULL) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"msg allocation failed");
 		return -ENOMEM;
 	}
 
-	meta.msg_type = type;
-	strlcpy(msg->name, adapter->dev->name,
+	QDF_IPA_MSG_META_MSG_TYPE(&meta) = type;
+	strlcpy(QDF_IPA_WLAN_MSG_NAME(msg), adapter->dev->name,
 		IPA_RESOURCE_NAME_MAX);
-	memcpy(msg->mac_addr, mac_addr, ETH_ALEN);
+	memcpy(QDF_IPA_WLAN_MSG_MAC_ADDR(msg), mac_addr, ETH_ALEN);
 	HDD_IPA_LOG(QDF_TRACE_LEVEL_INFO, "%s: Evt: %d",
-		msg->name, meta.msg_type);
-	ret = ipa_send_msg(&meta, msg, hdd_ipa_msg_free_fn);
+		QDF_IPA_WLAN_MSG_NAME(msg), QDF_IPA_MSG_META_MSG_TYPE(&meta));
+	ret = qdf_ipa_send_msg(&meta, msg, hdd_ipa_msg_free_fn);
 	if (ret) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			"%s: Evt: %d fail:%d",
-			msg->name, meta.msg_type,  ret);
+			QDF_IPA_WLAN_MSG_NAME(msg),
+			QDF_IPA_MSG_META_MSG_TYPE(&meta),  ret);
 		qdf_mem_free(msg);
 		return ret;
 	}
@@ -3646,7 +3655,7 @@ static int hdd_ipa_rm_request(struct hdd_ipa_priv *hdd_ipa)
 
 	qdf_spin_unlock_bh(&hdd_ipa->rm_lock);
 
-	ret = ipa_rm_inactivity_timer_request_resource(
+	ret = qdf_ipa_rm_inactivity_timer_request_resource(
 			IPA_RM_RESOURCE_WLAN_PROD);
 
 	qdf_spin_lock_bh(&hdd_ipa->rm_lock);
@@ -3709,7 +3718,7 @@ static int hdd_ipa_rm_try_release(struct hdd_ipa_priv *hdd_ipa)
 	hdd_ipa->stats.num_rm_release++;
 	qdf_spin_unlock_bh(&hdd_ipa->rm_lock);
 
-	ret = ipa_rm_inactivity_timer_release_resource(
+	ret = qdf_ipa_rm_inactivity_timer_release_resource(
 				IPA_RM_RESOURCE_WLAN_PROD);
 
 	qdf_spin_lock_bh(&hdd_ipa->rm_lock);
@@ -3743,7 +3752,7 @@ static int hdd_ipa_rm_try_release(struct hdd_ipa_priv *hdd_ipa)
  *
  * Return: None
  */
-static void hdd_ipa_rm_notify(void *user_data, enum ipa_rm_event event,
+static void hdd_ipa_rm_notify(void *user_data, qdf_ipa_rm_event_t event,
 			      unsigned long data)
 {
 	struct hdd_ipa_priv *hdd_ipa = user_data;
@@ -3838,7 +3847,7 @@ static int __hdd_ipa_set_perf_level(struct hdd_context *hdd_ctx,
 {
 	uint32_t next_cons_bw, next_prod_bw;
 	struct hdd_ipa_priv *hdd_ipa;
-	struct ipa_rm_perf_profile profile;
+	qdf_ipa_rm_perf_profile_t profile;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	int ret;
 
@@ -3947,7 +3956,7 @@ static void hdd_ipa_init_uc_rm_work(struct work_struct *work,
  */
 static int hdd_ipa_setup_rm(struct hdd_ipa_priv *hdd_ipa)
 {
-	struct ipa_rm_create_params create_params = { 0 };
+	qdf_ipa_rm_create_params_t create_params = { 0 };
 	int ret;
 
 	if (!hdd_ipa_is_rm_enabled(hdd_ipa->hdd_ctx))
@@ -3956,12 +3965,16 @@ static int hdd_ipa_setup_rm(struct hdd_ipa_priv *hdd_ipa)
 	hdd_ipa_init_uc_rm_work(&hdd_ipa->uc_rm_work.work,
 		hdd_ipa_uc_rm_notify_defer);
 	memset(&create_params, 0, sizeof(create_params));
-	create_params.name = IPA_RM_RESOURCE_WLAN_PROD;
-	create_params.reg_params.user_data = hdd_ipa;
-	create_params.reg_params.notify_cb = hdd_ipa_rm_notify;
-	create_params.floor_voltage = IPA_VOLTAGE_SVS;
-
-	ret = ipa_rm_create_resource(&create_params);
+	QDF_IPA_RM_CREATE_PARAMS_NAME(&create_params) =
+		 IPA_RM_RESOURCE_WLAN_PROD;
+	QDF_IPA_RM_CREATE_PARAMS_USER_DATA(&create_params) =
+		hdd_ipa;
+	QDF_IPA_RM_CREATE_PARAMS_NOTIFY_CB(&create_params) =
+		hdd_ipa_rm_notify;
+	QDF_IPA_RM_CREATE_PARAMS_FLOOR_VOLTAGE(&create_params) =
+		IPA_VOLTAGE_SVS;
+
+	ret = qdf_ipa_rm_create_resource(&create_params);
 	if (ret) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			    "Create RM resource failed: %d", ret);
@@ -3969,12 +3982,16 @@ static int hdd_ipa_setup_rm(struct hdd_ipa_priv *hdd_ipa)
 	}
 
 	memset(&create_params, 0, sizeof(create_params));
-	create_params.name = IPA_RM_RESOURCE_WLAN_CONS;
-	create_params.request_resource = hdd_ipa_rm_cons_request;
-	create_params.release_resource = hdd_ipa_rm_cons_release;
-	create_params.floor_voltage = IPA_VOLTAGE_SVS;
-
-	ret = ipa_rm_create_resource(&create_params);
+	QDF_IPA_RM_CREATE_PARAMS_NAME(&create_params) =
+		IPA_RM_RESOURCE_WLAN_CONS;
+	QDF_IPA_RM_CREATE_PARAMS_REQUEST_RESOURCE(&create_params) =
+		hdd_ipa_rm_cons_request;
+	QDF_IPA_RM_CREATE_PARAMS_RELEASE_RESOURCE(&create_params) =
+		hdd_ipa_rm_cons_release;
+	QDF_IPA_RM_CREATE_PARAMS_FLOOR_VOLTAGE(&create_params) =
+		IPA_VOLTAGE_SVS;
+
+	ret = qdf_ipa_rm_create_resource(&create_params);
 	if (ret) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			    "Create RM CONS resource failed: %d", ret);
@@ -3984,8 +4001,8 @@ static int hdd_ipa_setup_rm(struct hdd_ipa_priv *hdd_ipa)
 	ipa_rm_add_dependency(IPA_RM_RESOURCE_WLAN_PROD,
 			      IPA_RM_RESOURCE_APPS_CONS);
 
-	ret = ipa_rm_inactivity_timer_init(IPA_RM_RESOURCE_WLAN_PROD,
-					   HDD_IPA_RX_INACTIVITY_MSEC_DELAY);
+	ret = qdf_ipa_rm_inactivity_timer_init(IPA_RM_RESOURCE_WLAN_PROD,
+			HDD_IPA_RX_INACTIVITY_MSEC_DELAY);
 	if (ret) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR, "Timer init failed: %d",
 			    ret);
@@ -4047,12 +4064,12 @@ static void hdd_ipa_destroy_rm_resource(struct hdd_ipa_priv *hdd_ipa)
 
 	ipa_rm_inactivity_timer_destroy(IPA_RM_RESOURCE_WLAN_PROD);
 
-	ret = ipa_rm_delete_resource(IPA_RM_RESOURCE_WLAN_PROD);
+	ret = qdf_ipa_rm_delete_resource(IPA_RM_RESOURCE_WLAN_PROD);
 	if (ret)
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			    "RM PROD resource delete failed %d", ret);
 
-	ret = ipa_rm_delete_resource(IPA_RM_RESOURCE_WLAN_CONS);
+	ret = qdf_ipa_rm_delete_resource(IPA_RM_RESOURCE_WLAN_CONS);
 	if (ret)
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 			    "RM CONS resource delete failed %d", ret);
@@ -4256,8 +4273,8 @@ static enum hdd_ipa_forward_type hdd_ipa_intrabss_forward(
  *
  * Return: None
  */
-static void __hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
-			   unsigned long data)
+static void __hdd_ipa_w2i_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
+			     unsigned long data)
 {
 	struct hdd_ipa_priv *hdd_ipa = NULL;
 	struct hdd_adapter *adapter = NULL;
@@ -4377,7 +4394,7 @@ static void __hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
  *
  * Return: None
  */
-static void hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
+static void hdd_ipa_w2i_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
 			   unsigned long data)
 {
 	cds_ssr_protect(__func__);
@@ -4394,7 +4411,7 @@ static void hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
 void hdd_ipa_nbuf_cb(qdf_nbuf_t skb)
 {
 	struct hdd_ipa_priv *hdd_ipa = ghdd_ipa;
-	struct ipa_rx_data *ipa_tx_desc;
+	qdf_ipa_rx_data_t *ipa_tx_desc;
 	struct hdd_ipa_tx_desc *tx_desc;
 	uint16_t id;
 
@@ -4434,7 +4451,7 @@ void hdd_ipa_nbuf_cb(qdf_nbuf_t skb)
  */
 static void hdd_ipa_send_pkt_to_tl(
 		struct hdd_ipa_iface_context *iface_context,
-		struct ipa_rx_data *ipa_tx_desc)
+		qdf_ipa_rx_data_t *ipa_tx_desc)
 {
 	struct hdd_ipa_priv *hdd_ipa = iface_context->hdd_ipa;
 	struct hdd_adapter *adapter = NULL;
@@ -4471,7 +4488,7 @@ static void hdd_ipa_send_pkt_to_tl(
 
 	qdf_spin_unlock_bh(&iface_context->interface_lock);
 
-	skb = ipa_tx_desc->skb;
+	skb = QDF_IPA_RX_DATA_SKB(ipa_tx_desc);
 
 	qdf_mem_set(skb->cb, sizeof(skb->cb), 0);
 
@@ -4479,10 +4496,10 @@ static void hdd_ipa_send_pkt_to_tl(
 	qdf_nbuf_ipa_owned_set(skb);
 	if (hdd_ipa_uc_sta_is_enabled(hdd_ipa->hdd_ctx)) {
 		qdf_nbuf_mapped_paddr_set(skb,
-					  ipa_tx_desc->dma_addr
+					  QDF_IPA_RX_DATA_DMA_ADDR(ipa_tx_desc)
 					  + HDD_IPA_WLAN_FRAG_HEADER
 					  + HDD_IPA_WLAN_IPA_HEADER);
-		ipa_tx_desc->skb->len -=
+		QDF_IPA_RX_DATA_SKB_LEN(ipa_tx_desc) -=
 			HDD_IPA_WLAN_FRAG_HEADER + HDD_IPA_WLAN_IPA_HEADER;
 	} else
 		qdf_nbuf_mapped_paddr_set(skb, ipa_tx_desc->dma_addr);
@@ -4506,11 +4523,11 @@ static void hdd_ipa_send_pkt_to_tl(
 		return;
 	}
 
-	adapter->stats.tx_bytes += ipa_tx_desc->skb->len;
+	adapter->stats.tx_bytes += QDF_IPA_RX_DATA_SKB_LEN(ipa_tx_desc);
 
 	skb = cdp_ipa_tx_send_data_frame(cds_get_context(QDF_MODULE_ID_SOC),
-		(struct cdp_vdev *)iface_context->tl_context,
-		ipa_tx_desc->skb);
+			(struct cdp_vdev *)iface_context->tl_context,
+			QDF_IPA_RX_DATA_SKB(ipa_tx_desc));
 	if (skb) {
 		qdf_nbuf_free(skb);
 		iface_context->stats.num_tx_err++;
@@ -4601,18 +4618,18 @@ static void hdd_ipa_pm_flush(struct work_struct *work)
  *
  * Return: None
  */
-static void __hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
-			   unsigned long data)
+static void __hdd_ipa_i2w_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
+			     unsigned long data)
 {
 	struct hdd_ipa_priv *hdd_ipa = NULL;
-	struct ipa_rx_data *ipa_tx_desc;
+	qdf_ipa_rx_data_t *ipa_tx_desc;
 	struct hdd_ipa_iface_context *iface_context;
 	qdf_nbuf_t skb;
 	struct hdd_ipa_pm_tx_cb *pm_tx_cb = NULL;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	iface_context = (struct hdd_ipa_iface_context *)priv;
-	ipa_tx_desc = (struct ipa_rx_data *)data;
+	ipa_tx_desc = (qdf_ipa_rx_data_t *)data;
 	hdd_ipa = iface_context->hdd_ipa;
 
 	if (evt != IPA_RECEIVE) {
@@ -4634,7 +4651,7 @@ static void __hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
 		return;
 	}
 
-	skb = ipa_tx_desc->skb;
+	skb = QDF_IPA_RX_DATA_SKB(ipa_tx_desc);
 
 	HDD_IPA_DBG_DUMP(QDF_TRACE_LEVEL_DEBUG,
 			 "i2w", skb->data, HDD_IPA_DBG_DUMP_TX_LEN);
@@ -4687,7 +4704,7 @@ static void __hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
  *
  * Return: None
  */
-static void hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
+static void hdd_ipa_i2w_cb(void *priv, qdf_ipa_dp_evt_type_t evt,
 			   unsigned long data)
 {
 	cds_ssr_protect(__func__);
@@ -4851,7 +4868,7 @@ static int hdd_ipa_alloc_tx_desc_list(struct hdd_ipa_priv *hdd_ipa)
 static int hdd_ipa_setup_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 {
 	int i, ret = 0;
-	struct ipa_sys_connect_params *ipa;
+	qdf_ipa_sys_connect_params_t *ipa;
 	uint32_t desc_fifo_sz;
 
 	/* The maximum number of descriptors that can be provided to a BAM at
@@ -4892,7 +4909,8 @@ static int hdd_ipa_setup_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 		if (!hdd_ipa_is_rm_enabled(hdd_ipa->hdd_ctx))
 			ipa->keep_ipa_awake = 1;
 
-		ret = ipa_setup_sys_pipe(ipa, &(hdd_ipa->sys_pipe[i].conn_hdl));
+		ret = qdf_ipa_setup_sys_pipe(ipa,
+			&hdd_ipa->sys_pipe[i].conn_hdl);
 		if (ret) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 				    "Failed for pipe %d ret: %d", i, ret);
@@ -4923,7 +4941,8 @@ static int hdd_ipa_setup_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 		if (!hdd_ipa_is_rm_enabled(hdd_ipa->hdd_ctx))
 			ipa->keep_ipa_awake = 1;
 
-		ret = ipa_setup_sys_pipe(ipa, &(hdd_ipa->sys_pipe[i].conn_hdl));
+		ret = qdf_ipa_setup_sys_pipe(ipa,
+			&hdd_ipa->sys_pipe[i].conn_hdl);
 		if (ret) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
 					"Failed for RX pipe: %d", ret);
@@ -4961,7 +4980,7 @@ static void hdd_ipa_teardown_sys_pipe(struct hdd_ipa_priv *hdd_ipa)
 	int ret = 0, i;
 	uint32_t max_desc_cnt;
 	struct hdd_ipa_tx_desc *tmp_desc;
-	struct ipa_rx_data *ipa_tx_desc;
+	qdf_ipa_rx_data_t *ipa_tx_desc;
 
 	for (i = 0; i < HDD_IPA_MAX_SYSBAM_PIPE; i++) {
 		if (hdd_ipa->sys_pipe[i].conn_hdl_valid) {
@@ -5124,8 +5143,9 @@ static int __hdd_ipa_send_mcc_scc_msg(struct hdd_context *hdd_ctx,
 	hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL;
 	QDF_STATUS status;
 	struct hdd_adapter *adapter;
-	struct ipa_msg_meta meta;
-	struct ipa_wlan_msg *msg;
+	qdf_ipa_msg_meta_t meta;
+	qdf_ipa_wlan_msg_t *msg;
+
 	int ret;
 
 	if (wlan_hdd_validate_context(hdd_ctx))
@@ -5152,22 +5172,22 @@ static int __hdd_ipa_send_mcc_scc_msg(struct hdd_context *hdd_ctx,
 	}
 
 	/* Send SCC/MCC Switching event to IPA */
-	meta.msg_len = sizeof(*msg);
-	msg = qdf_mem_malloc(meta.msg_len);
+	QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(*msg);
+	msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
 	if (msg == NULL) {
 		hdd_err("msg allocation failed");
 		return -ENOMEM;
 	}
 
-	meta.msg_type = mcc_mode ?
+	QDF_IPA_MSG_META_MSG_TYPE(&meta) = mcc_mode ?
 			WLAN_SWITCH_TO_MCC : WLAN_SWITCH_TO_SCC;
-	hdd_debug("ipa_send_msg(Evt:%d)", meta.msg_type);
+	hdd_debug("ipa_send_msg(Evt:%d)", QDF_IPA_MSG_META_MSG_TYPE(&meta));
 
-	ret = ipa_send_msg(&meta, msg, hdd_ipa_msg_free_fn);
+	ret = qdf_ipa_send_msg(&meta, msg, hdd_ipa_msg_free_fn);
 
 	if (ret) {
 		hdd_err("ipa_send_msg(Evt:%d) - fail=%d",
-			meta.msg_type,  ret);
+			QDF_IPA_MSG_META_MSG_TYPE(&meta),  ret);
 		qdf_mem_free(msg);
 	}
 
@@ -5196,12 +5216,12 @@ int hdd_ipa_send_mcc_scc_msg(struct hdd_context *hdd_ctx, bool mcc_mode)
  * hdd_to_ipa_wlan_event() - convert hdd_ipa_wlan_event to ipa_wlan_event
  * @hdd_ipa_event_type: HDD IPA WLAN event to be converted to an ipa_wlan_event
  *
- * Return: ipa_wlan_event representing the hdd_ipa_wlan_event
+ * Return: qdf_ipa_wlan_event representing the hdd_ipa_wlan_event
  */
-static enum ipa_wlan_event
+static qdf_ipa_wlan_event_t
 hdd_to_ipa_wlan_event(enum hdd_ipa_wlan_event hdd_ipa_event_type)
 {
-	enum ipa_wlan_event ipa_event;
+	qdf_ipa_wlan_event_t ipa_event;
 
 	switch (hdd_ipa_event_type) {
 	case HDD_IPA_CLIENT_CONNECT:
@@ -5246,12 +5266,12 @@ hdd_to_ipa_wlan_event(enum hdd_ipa_wlan_event hdd_ipa_event_type)
  * Return: 0 on success, negative errno value on error
  */
 static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
-		     enum ipa_wlan_event type, uint8_t *mac_addr)
+		     qdf_ipa_wlan_event_t type, uint8_t *mac_addr)
 {
 	struct hdd_ipa_priv *hdd_ipa = ghdd_ipa;
-	struct ipa_msg_meta meta;
-	struct ipa_wlan_msg *msg;
-	struct ipa_wlan_msg_ex *msg_ex = NULL;
+	qdf_ipa_msg_meta_t meta;
+	qdf_ipa_wlan_msg_t *msg;
+	qdf_ipa_wlan_msg_ex_t *msg_ex = NULL;
 	int ret;
 
 	HDD_IPA_LOG(QDF_TRACE_LEVEL_INFO, "%s: EVT: %s, MAC: %pM, sta_id: %d",
@@ -5348,7 +5368,7 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 
 	hdd_ipa->stats.event[type]++;
 
-	meta.msg_type = type;
+	QDF_IPA_MSG_META_MSG_TYPE(&meta) = type;
 	switch (type) {
 	case WLAN_STA_CONNECT:
 		qdf_mutex_acquire(&hdd_ipa->event_lock);
@@ -5404,7 +5424,7 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 		if (ret) {
 			qdf_mutex_release(&hdd_ipa->event_lock);
 			hdd_err("%s: Evt: %d, Interface setup failed",
-				msg_ex->name, meta.msg_type);
+				msg_ex->name, QDF_IPA_MSG_META_MSG_TYPE(&meta));
 			goto end;
 		}
 
@@ -5428,7 +5448,7 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 		if (!hdd_ipa->sta_connected) {
 			qdf_mutex_release(&hdd_ipa->event_lock);
 			hdd_err("%s: Evt: %d, STA already disconnected",
-				msg_ex->name, meta.msg_type);
+				msg_ex->name, QDF_IPA_MSG_META_MSG_TYPE(&meta));
 			return -EINVAL;
 		}
 
@@ -5470,7 +5490,7 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 		if (!adapter->ipa_context) {
 			qdf_mutex_release(&hdd_ipa->event_lock);
 			hdd_err("%s: Evt: %d, SAP already disconnected",
-				msg_ex->name, meta.msg_type);
+				msg_ex->name, QDF_IPA_MSG_META_MSG_TYPE(&meta));
 			return -EINVAL;
 		}
 
@@ -5570,10 +5590,11 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 
 		qdf_mutex_release(&hdd_ipa->event_lock);
 
-		meta.msg_type = type;
-		meta.msg_len = (sizeof(struct ipa_wlan_msg_ex) +
-				sizeof(struct ipa_wlan_hdr_attrib_val));
-		msg_ex = qdf_mem_malloc(meta.msg_len);
+		QDF_IPA_MSG_META_MSG_TYPE(&meta) = type;
+		QDF_IPA_MSG_META_MSG_LEN(&meta) =
+			(sizeof(qdf_ipa_wlan_msg_ex_t) +
+				sizeof(qdf_ipa_wlan_hdr_attrib_val_t));
+		msg_ex = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
 
 		if (msg_ex == NULL) {
 			HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR,
@@ -5620,7 +5641,7 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 		if (!hdd_ipa->sap_num_connected_sta) {
 			qdf_mutex_release(&hdd_ipa->event_lock);
 			hdd_err("%s: Evt: %d, Client already disconnected",
-				msg_ex->name, meta.msg_type);
+				msg_ex->name, QDF_IPA_MSG_META_MSG_TYPE(&meta));
 			return 0;
 		}
 		if (!hdd_ipa_uc_find_add_assoc_sta(hdd_ipa, false, sta_id)) {
@@ -5664,25 +5685,28 @@ static int __hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 		return 0;
 	}
 
-	meta.msg_len = sizeof(struct ipa_wlan_msg);
-	msg = qdf_mem_malloc(meta.msg_len);
+	QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(qdf_ipa_wlan_msg_t);
+	msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
 	if (msg == NULL) {
 		HDD_IPA_LOG(QDF_TRACE_LEVEL_ERROR, "msg allocation failed");
 		return -ENOMEM;
 	}
 
-	meta.msg_type = type;
-	strlcpy(msg->name, adapter->dev->name, IPA_RESOURCE_NAME_MAX);
-	memcpy(msg->mac_addr, mac_addr, ETH_ALEN);
+	QDF_IPA_MSG_META_MSG_TYPE(&meta) = type;
+	strlcpy(QDF_IPA_WLAN_MSG_NAME(msg), adapter->dev->name,
+		IPA_RESOURCE_NAME_MAX);
+	memcpy(QDF_IPA_WLAN_MSG_MAC_ADDR(msg), mac_addr, ETH_ALEN);
 
 	HDD_IPA_LOG(QDF_TRACE_LEVEL_DEBUG, "%s: Evt: %d",
-		    msg->name, meta.msg_type);
+		    QDF_IPA_WLAN_MSG_NAME(msg),
+		    QDF_IPA_MSG_META_MSG_TYPE(&meta));
 
 	ret = ipa_send_msg(&meta, msg, hdd_ipa_msg_free_fn);
 
 	if (ret) {
 		hdd_err("%s: Evt: %d fail:%d",
-			msg->name, meta.msg_type, ret);
+			QDF_IPA_WLAN_MSG_NAME(msg),
+			QDF_IPA_MSG_META_MSG_TYPE(&meta), ret);
 		qdf_mem_free(msg);
 		return ret;
 	}
@@ -5707,7 +5731,7 @@ end:
 int hdd_ipa_wlan_evt(struct hdd_adapter *adapter, uint8_t sta_id,
 	enum hdd_ipa_wlan_event hdd_event_type, uint8_t *mac_addr)
 {
-	enum ipa_wlan_event type = hdd_to_ipa_wlan_event(hdd_event_type);
+	qdf_ipa_wlan_event_t type = hdd_to_ipa_wlan_event(hdd_event_type);
 	int ret = 0;
 
 	cds_ssr_protect(__func__);
@@ -5792,7 +5816,7 @@ static QDF_STATUS __hdd_ipa_init(struct hdd_context *hdd_ctx)
 	int ret, i;
 	struct hdd_ipa_iface_context *iface_context = NULL;
 	struct ol_txrx_pdev_t *pdev = NULL;
-	struct ipa_rm_perf_profile profile;
+	qdf_ipa_rm_perf_profile_t profile;
 
 	if (!hdd_ipa_is_enabled(hdd_ctx))
 		return QDF_STATUS_SUCCESS;