qcacmn: Update driver to use QDF NBUF APIs(2/2)

Update driver to use QDF NBUF APIs Change-Id: I555c739660e62e6d0237c65c57bcb169fec11cf4 CRs-Fixed: 981187
2016-03-01 16:28:23 +05:30
--- a/htc/htc.c
+++ b/htc/htc.c
@@ -28,7 +28,7 @@
 #include "ol_if_athvar.h"
 #include "htc_debug.h"
 #include "htc_internal.h"
-#include <cdf_nbuf.h>           /* cdf_nbuf_t */
+#include <qdf_nbuf.h>           /* qdf_nbuf_t */
 #include <qdf_types.h>          /* qdf_print */
 #include <hif.h>
 #include "epping_main.h"
@@ -62,11 +62,11 @@ static void reset_endpoint_states(HTC_TARGET *target);

 static void destroy_htc_tx_ctrl_packet(HTC_PACKET *pPacket)
 {
-	cdf_nbuf_t netbuf;
-	netbuf = (cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
-	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("free ctrl netbuf :0x%p \n", netbuf));
+	qdf_nbuf_t netbuf;
+	netbuf = (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
+	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("free ctrl netbuf :0x%p\n", netbuf));
 	if (netbuf != NULL) {
-		cdf_nbuf_free(netbuf);
+		qdf_nbuf_free(netbuf);
 	}

 	qdf_mem_free(pPacket);
@@ -75,7 +75,7 @@ static void destroy_htc_tx_ctrl_packet(HTC_PACKET *pPacket)
 static HTC_PACKET *build_htc_tx_ctrl_packet(qdf_device_t osdev)
 {
 	HTC_PACKET *pPacket = NULL;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;

 	do {
 		pPacket = (HTC_PACKET *) qdf_mem_malloc(sizeof(HTC_PACKET));
@@ -83,8 +83,8 @@ static HTC_PACKET *build_htc_tx_ctrl_packet(qdf_device_t osdev)
 			break;
 		}
 		A_MEMZERO(pPacket, sizeof(HTC_PACKET));
-		netbuf =
-			cdf_nbuf_alloc(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, true);
+		netbuf = qdf_nbuf_alloc(osdev,
+				HTC_CONTROL_BUFFER_SIZE, 20, 4, true);
 		if (NULL == netbuf) {
 			qdf_mem_free(pPacket);
 			pPacket = NULL;
@@ -146,7 +146,7 @@ void htc_dump(HTC_HANDLE HTCHandle, uint8_t CmdId, bool start)
 static void htc_cleanup(HTC_TARGET *target)
 {
 	HTC_PACKET *pPacket;
-	/* cdf_nbuf_t netbuf; */
+	/* qdf_nbuf_t netbuf; */

 	if (target->hif_dev != NULL) {
 		hif_detach_htc(target->hif_dev);
@@ -173,9 +173,9 @@ static void htc_cleanup(HTC_TARGET *target)
 		if (NULL == pPacket) {
 			break;
 		}
-		netbuf = (cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
+		netbuf = (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
 		if (netbuf != NULL) {
-			cdf_nbuf_free(netbuf);
+			qdf_nbuf_free(netbuf);
 		}

 		qdf_mem_free(pPacket);
@@ -535,7 +535,7 @@ static void reset_endpoint_states(HTC_TARGET *target)

 A_STATUS htc_start(HTC_HANDLE HTCHandle)
 {
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	A_STATUS status = A_OK;
 	HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
 	HTC_SETUP_COMPLETE_EX_MSG *pSetupComp;
@@ -558,11 +558,11 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle)
 		}

 		netbuf =
-			(cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
+		   (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
 		/* assemble setup complete message */
-		cdf_nbuf_put_tail(netbuf, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
+		qdf_nbuf_put_tail(netbuf, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
 		pSetupComp =
-			(HTC_SETUP_COMPLETE_EX_MSG *) cdf_nbuf_data(netbuf);
+			(HTC_SETUP_COMPLETE_EX_MSG *) qdf_nbuf_data(netbuf);
 		A_MEMZERO(pSetupComp, sizeof(HTC_SETUP_COMPLETE_EX_MSG));

 		HTC_SET_FIELD(pSetupComp, HTC_SETUP_COMPLETE_EX_MSG,
@@ -610,11 +610,11 @@ void htc_flush_surprise_remove(HTC_HANDLE HTCHandle)
 	int i;
 	HTC_ENDPOINT *pEndpoint;
 #ifdef RX_SG_SUPPORT
-	cdf_nbuf_t netbuf;
-	cdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;
+	qdf_nbuf_t netbuf;
+	qdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;
 #endif

-	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_flush_surprise_remove \n"));
+	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_flush_surprise_remove\n"));

 	/* cleanup endpoints */
 	for (i = 0; i < ENDPOINT_MAX; i++) {
@@ -627,9 +627,8 @@ void htc_flush_surprise_remove(HTC_HANDLE HTCHandle)

 #ifdef RX_SG_SUPPORT
 	LOCK_HTC_RX(target);
-	while ((netbuf = cdf_nbuf_queue_remove(rx_sg_queue)) != NULL) {
-		cdf_nbuf_free(netbuf);
-	}
+	while ((netbuf = qdf_nbuf_queue_remove(rx_sg_queue)) != NULL)
+		qdf_nbuf_free(netbuf);
 	RESET_RX_SG_CONFIG(target);
 	UNLOCK_HTC_RX(target);
 #endif
@@ -646,11 +645,11 @@ void htc_stop(HTC_HANDLE HTCHandle)
 	int i;
 	HTC_ENDPOINT *pEndpoint;
 #ifdef RX_SG_SUPPORT
-	cdf_nbuf_t netbuf;
-	cdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;
+	qdf_nbuf_t netbuf;
+	qdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;
 #endif

-	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_stop \n"));
+	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_stop\n"));

 	/* cleanup endpoints */
 	for (i = 0; i < ENDPOINT_MAX; i++) {
@@ -674,9 +673,8 @@ void htc_stop(HTC_HANDLE HTCHandle)

 #ifdef RX_SG_SUPPORT
 	LOCK_HTC_RX(target);
-	while ((netbuf = cdf_nbuf_queue_remove(rx_sg_queue)) != NULL) {
-		cdf_nbuf_free(netbuf);
-	}
+	while ((netbuf = qdf_nbuf_queue_remove(rx_sg_queue)) != NULL)
+		qdf_nbuf_free(netbuf);
 	RESET_RX_SG_CONFIG(target);
 	UNLOCK_HTC_RX(target);
 #endif
--- a/htc/htc_api.h
+++ b/htc/htc_api.h
@@ -443,7 +443,7 @@ A_STATUS htc_send_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket);
   @see also: htc_send_pkt
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 #ifdef ATH_11AC_TXCOMPACT
-A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, cdf_nbuf_t netbuf,
+A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf,
 			   int Epid, int ActualLength);
 #else                           /*ATH_11AC_TXCOMPACT */
 A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket,
--- a/htc/htc_internal.h
+++ b/htc/htc_internal.h
@@ -35,7 +35,7 @@ extern "C" {
 #include <athdefs.h>
 #include "a_types.h"
 #include "osapi_linux.h"
-#include <cdf_nbuf.h>
+#include <qdf_nbuf.h>
 #include <qdf_types.h>
 #include <qdf_lock.h>
 #include <qdf_timer.h>
@@ -173,7 +173,7 @@ typedef struct _HTC_TARGET {
 		ServiceTxAllocTable[HTC_MAX_SERVICE_ALLOC_ENTRIES];
 	int TargetCreditSize;
 #ifdef RX_SG_SUPPORT
-	cdf_nbuf_queue_t RxSgQueue;
+	qdf_nbuf_queue_t RxSgQueue;
 	A_BOOL IsRxSgInprogress;
 	A_UINT32 CurRxSgTotalLen;               /* current total length */
 	A_UINT32 ExpRxSgTotalLen;               /* expected total length */
@@ -227,9 +227,9 @@ typedef struct _HTC_TARGET {
 	} while (0);
 /* internal HTC functions */

-QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
+QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf,
 				   uint8_t pipeID);
-QDF_STATUS htc_tx_completion_handler(void *Context, cdf_nbuf_t netbuf,
+QDF_STATUS htc_tx_completion_handler(void *Context, qdf_nbuf_t netbuf,
 				   unsigned int transferID, uint32_t toeplitz_hash_result);

 HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target);
--- a/htc/htc_recv.c
+++ b/htc/htc_recv.c
@@ -28,7 +28,7 @@
 #include "htc_debug.h"
 #include "htc_internal.h"
 #include "cds_api.h"
-#include <cdf_nbuf.h>           /* cdf_nbuf_t */
+#include <qdf_nbuf.h>           /* qdf_nbuf_t */
 #include "epping_main.h"

 /* HTC Control message receive timeout msec */
@@ -209,17 +209,17 @@ void free_htc_packet_container(HTC_TARGET *target, HTC_PACKET *pPacket)
 }

 #ifdef RX_SG_SUPPORT
-cdf_nbuf_t rx_sg_to_single_netbuf(HTC_TARGET *target)
+qdf_nbuf_t rx_sg_to_single_netbuf(HTC_TARGET *target)
 {
-	cdf_nbuf_t skb;
+	qdf_nbuf_t skb;
 	uint8_t *anbdata;
 	uint8_t *anbdata_new;
 	uint32_t anblen;
-	cdf_nbuf_t new_skb = NULL;
+	qdf_nbuf_t new_skb = NULL;
 	uint32_t sg_queue_len;
-	cdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;
+	qdf_nbuf_queue_t *rx_sg_queue = &target->RxSgQueue;

-	sg_queue_len = cdf_nbuf_queue_len(rx_sg_queue);
+	sg_queue_len = qdf_nbuf_queue_len(rx_sg_queue);

 	if (sg_queue_len <= 1) {
 		AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
@@ -227,7 +227,7 @@ cdf_nbuf_t rx_sg_to_single_netbuf(HTC_TARGET *target)
 		goto _failed;
 	}

-	new_skb = cdf_nbuf_alloc(target->ExpRxSgTotalLen, 0, 4, false);
+	new_skb = qdf_nbuf_alloc(target->ExpRxSgTotalLen, 0, 4, false);
 	if (new_skb == NULL) {
 		AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
 				("rx_sg_to_single_netbuf: can't allocate %u size netbuf\n",
@@ -235,16 +235,16 @@ cdf_nbuf_t rx_sg_to_single_netbuf(HTC_TARGET *target)
 		goto _failed;
 	}

-	cdf_nbuf_peek_header(new_skb, &anbdata_new, &anblen);
+	qdf_nbuf_peek_header(new_skb, &anbdata_new, &anblen);

-	skb = cdf_nbuf_queue_remove(rx_sg_queue);
+	skb = qdf_nbuf_queue_remove(rx_sg_queue);
 	do {
-		cdf_nbuf_peek_header(skb, &anbdata, &anblen);
-		qdf_mem_copy(anbdata_new, anbdata, cdf_nbuf_len(skb));
-		cdf_nbuf_put_tail(new_skb, cdf_nbuf_len(skb));
-		anbdata_new += cdf_nbuf_len(skb);
-		cdf_nbuf_free(skb);
-		skb = cdf_nbuf_queue_remove(rx_sg_queue);
+		qdf_nbuf_peek_header(skb, &anbdata, &anblen);
+		qdf_mem_copy(anbdata_new, anbdata, qdf_nbuf_len(skb));
+		qdf_nbuf_put_tail(new_skb, qdf_nbuf_len(skb));
+		anbdata_new += qdf_nbuf_len(skb);
+		qdf_nbuf_free(skb);
+		skb = qdf_nbuf_queue_remove(rx_sg_queue);
 	} while (skb != NULL);

 	RESET_RX_SG_CONFIG(target);
@@ -252,16 +252,15 @@ cdf_nbuf_t rx_sg_to_single_netbuf(HTC_TARGET *target)

 _failed:

-	while ((skb = cdf_nbuf_queue_remove(rx_sg_queue)) != NULL) {
-		cdf_nbuf_free(skb);
-	}
+	while ((skb = qdf_nbuf_queue_remove(rx_sg_queue)) != NULL)
+		qdf_nbuf_free(skb);

 	RESET_RX_SG_CONFIG(target);
 	return NULL;
 }
 #endif

-QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
+QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf,
 				   uint8_t pipeID)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
@@ -278,8 +277,8 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 #ifdef RX_SG_SUPPORT
 	LOCK_HTC_RX(target);
 	if (target->IsRxSgInprogress) {
-		target->CurRxSgTotalLen += cdf_nbuf_len(netbuf);
-		cdf_nbuf_queue_add(&target->RxSgQueue, netbuf);
+		target->CurRxSgTotalLen += qdf_nbuf_len(netbuf);
+		qdf_nbuf_queue_add(&target->RxSgQueue, netbuf);
 		if (target->CurRxSgTotalLen == target->ExpRxSgTotalLen) {
 			netbuf = rx_sg_to_single_netbuf(target);
 			if (netbuf == NULL) {
@@ -295,8 +294,8 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 	UNLOCK_HTC_RX(target);
 #endif

-	netdata = cdf_nbuf_data(netbuf);
-	netlen = cdf_nbuf_len(netbuf);
+	netdata = qdf_nbuf_data(netbuf);
+	netlen = qdf_nbuf_len(netbuf);

 	HtcHdr = (HTC_FRAME_HDR *) netdata;

@@ -333,8 +332,8 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 #ifdef RX_SG_SUPPORT
 			LOCK_HTC_RX(target);
 			target->IsRxSgInprogress = true;
-			cdf_nbuf_queue_init(&target->RxSgQueue);
-			cdf_nbuf_queue_add(&target->RxSgQueue, netbuf);
+			qdf_nbuf_queue_init(&target->RxSgQueue);
+			qdf_nbuf_queue_add(&target->RxSgQueue, netbuf);
 			target->ExpRxSgTotalLen = (payloadLen + HTC_HDR_LENGTH);
 			target->CurRxSgTotalLen += netlen;
 			UNLOCK_HTC_RX(target);
@@ -404,9 +403,9 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 			int wow_nack = 0;

 			/* remove HTC header */
-			cdf_nbuf_pull_head(netbuf, HTC_HDR_LENGTH);
-			netdata = cdf_nbuf_data(netbuf);
-			netlen = cdf_nbuf_len(netbuf);
+			qdf_nbuf_pull_head(netbuf, HTC_HDR_LENGTH);
+			netdata = qdf_nbuf_data(netbuf);
+			netlen = qdf_nbuf_len(netbuf);

 			htc_msg = (HTC_UNKNOWN_MSG *) netdata;
 			message_id =
@@ -465,7 +464,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 				break;
 			}

-			cdf_nbuf_free(netbuf);
+			qdf_nbuf_free(netbuf);
 			netbuf = NULL;
 			break;
 		}
@@ -482,11 +481,11 @@ QDF_STATUS htc_rx_completion_handler(void *Context, cdf_nbuf_t netbuf,
 		pPacket->Status = QDF_STATUS_SUCCESS;
 		pPacket->Endpoint = htc_ep_id;
 		pPacket->pPktContext = netbuf;
-		pPacket->pBuffer = cdf_nbuf_data(netbuf) + HTC_HDR_LENGTH;
+		pPacket->pBuffer = qdf_nbuf_data(netbuf) + HTC_HDR_LENGTH;
 		pPacket->ActualLength = netlen - HTC_HEADER_LEN - trailerlen;

-		cdf_nbuf_pull_head(netbuf, HTC_HEADER_LEN);
-		cdf_nbuf_set_pktlen(netbuf, pPacket->ActualLength);
+		qdf_nbuf_pull_head(netbuf, HTC_HEADER_LEN);
+		qdf_nbuf_set_pktlen(netbuf, pPacket->ActualLength);

 		recv_packet_completion(target, pEndpoint, pPacket);
 		/* recover the packet container */
@@ -500,7 +499,7 @@ _out:
 #endif

 	if (netbuf != NULL) {
-		cdf_nbuf_free(netbuf);
+		qdf_nbuf_free(netbuf);
 	}

 	return status;
--- a/htc/htc_send.c
+++ b/htc/htc_send.c
@@ -27,7 +27,7 @@

 #include "htc_debug.h"
 #include "htc_internal.h"
-#include <cdf_nbuf.h>           /* cdf_nbuf_t */
+#include <qdf_nbuf.h>           /* qdf_nbuf_t */
 #include <qdf_mem.h>         /* qdf_mem_malloc */
 #include "epping_main.h"

@@ -133,9 +133,9 @@ void htc_get_control_endpoint_tx_host_credits(HTC_HANDLE HTCHandle, int *credits
 static inline void restore_tx_packet(HTC_TARGET *target, HTC_PACKET *pPacket)
 {
 	if (pPacket->PktInfo.AsTx.Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) {
-		cdf_nbuf_t netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
-		cdf_nbuf_unmap(target->osdev, netbuf, QDF_DMA_TO_DEVICE);
-		cdf_nbuf_pull_head(netbuf, sizeof(HTC_FRAME_HDR));
+		qdf_nbuf_t netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
+		qdf_nbuf_unmap(target->osdev, netbuf, QDF_DMA_TO_DEVICE);
+		qdf_nbuf_pull_head(netbuf, sizeof(HTC_FRAME_HDR));
 		pPacket->PktInfo.AsTx.Flags &= ~HTC_TX_PACKET_FLAG_FIXUP_NETBUF;
 	}

@@ -205,11 +205,11 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target)
 {
 	HTC_PACKET *pPacket;
 	HTC_PACKET_QUEUE *pQueueSave;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	LOCK_HTC_TX(target);
 	if (NULL == target->pBundleFreeList) {
 		UNLOCK_HTC_TX(target);
-		netbuf = cdf_nbuf_alloc(NULL,
+		netbuf = qdf_nbuf_alloc(NULL,
 					target->MaxMsgsPerHTCBundle *
 					target->TargetCreditSize, 0, 4, false);
 		AR_DEBUG_ASSERT(netbuf);
@@ -219,25 +219,25 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target)
 		pPacket = qdf_mem_malloc(sizeof(HTC_PACKET));
 		AR_DEBUG_ASSERT(pPacket);
 		if (!pPacket) {
-			cdf_nbuf_free(netbuf);
+			qdf_nbuf_free(netbuf);
 			return NULL;
 		}
 		pQueueSave = qdf_mem_malloc(sizeof(HTC_PACKET_QUEUE));
 		AR_DEBUG_ASSERT(pQueueSave);
 		if (!pQueueSave) {
-			cdf_nbuf_free(netbuf);
+			qdf_nbuf_free(netbuf);
 			qdf_mem_free(pPacket);
 			return NULL;
 		}
 		INIT_HTC_PACKET_QUEUE(pQueueSave);
 		pPacket->pContext = pQueueSave;
 		SET_HTC_PACKET_NET_BUF_CONTEXT(pPacket, netbuf);
-		pPacket->pBuffer = cdf_nbuf_data(netbuf);
-		pPacket->BufferLength = cdf_nbuf_len(netbuf);
+		pPacket->pBuffer = qdf_nbuf_data(netbuf);
+		pPacket->BufferLength = qdf_nbuf_len(netbuf);

 		/* store the original head room so that we can restore this when we "free" the packet */
 		/* free packet puts the packet back on the free list */
-		pPacket->netbufOrigHeadRoom = cdf_nbuf_headroom(netbuf);
+		pPacket->netbufOrigHeadRoom = qdf_nbuf_headroom(netbuf);
 		return pPacket;
 	}
 	/* already done malloc - restore from free list */
@@ -257,7 +257,7 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target)
 void free_htc_bundle_packet(HTC_TARGET *target, HTC_PACKET *pPacket)
 {
 	A_UINT32 curentHeadRoom;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	HTC_PACKET_QUEUE *pQueueSave;

 	netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
@@ -272,14 +272,14 @@ void free_htc_bundle_packet(HTC_TARGET *target, HTC_PACKET *pPacket)
 	/* and eventually HIF ends up doing another malloc big enough to store the */
 	/* data + its header */

-	curentHeadRoom = cdf_nbuf_headroom(netbuf);
-	cdf_nbuf_pull_head(netbuf,
+	curentHeadRoom = qdf_nbuf_headroom(netbuf);
+	qdf_nbuf_pull_head(netbuf,
 			   pPacket->netbufOrigHeadRoom - curentHeadRoom);
-	cdf_nbuf_trim_tail(netbuf, cdf_nbuf_len(netbuf));
+	qdf_nbuf_trim_tail(netbuf, qdf_nbuf_len(netbuf));

 	/* restore the pBuffer pointer. HIF changes this */
-	pPacket->pBuffer = cdf_nbuf_data(netbuf);
-	pPacket->BufferLength = cdf_nbuf_len(netbuf);
+	pPacket->pBuffer = qdf_nbuf_data(netbuf);
+	pPacket->BufferLength = qdf_nbuf_len(netbuf);

 	/* restore queue */
 	pQueueSave = (HTC_PACKET_QUEUE *) pPacket->pContext;
@@ -307,12 +307,12 @@ static A_STATUS htc_send_bundled_netbuf(HTC_TARGET *target,
 {
 	qdf_size_t data_len;
 	A_STATUS status;
-	cdf_nbuf_t bundleBuf;
+	qdf_nbuf_t bundleBuf;
 	uint32_t data_attr = 0;

 	bundleBuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacketTx);
-	data_len = pBundleBuffer - cdf_nbuf_data(bundleBuf);
-	cdf_nbuf_put_tail(bundleBuf, data_len);
+	data_len = pBundleBuffer - qdf_nbuf_data(bundleBuf);
+	qdf_nbuf_put_tail(bundleBuf, data_len);
 	SET_HTC_PACKET_INFO_TX(pPacketTx,
 			       target,
 			       pBundleBuffer,
@@ -342,7 +342,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target,
 				     HTC_PACKET_QUEUE *pPktQueue)
 {
 	int i, frag_count, nbytes;
-	cdf_nbuf_t netbuf, bundleBuf;
+	qdf_nbuf_t netbuf, bundleBuf;
 	unsigned char *pBundleBuffer = NULL;
 	HTC_PACKET *pPacket = NULL, *pPacketTx = NULL;
 	HTC_FRAME_HDR *pHtcHdr;
@@ -361,7 +361,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target,
 		return;
 	}
 	bundleBuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacketTx);
-	pBundleBuffer = cdf_nbuf_data(bundleBuf);
+	pBundleBuffer = qdf_nbuf_data(bundleBuf);
 	pQueueSave = (HTC_PACKET_QUEUE *) pPacketTx->pContext;
 	while (1) {
 		pPacket = htc_packet_dequeue(pPktQueue);
@@ -401,13 +401,13 @@ static void htc_issue_packets_bundle(HTC_TARGET *target,
 				return;
 			}
 			bundleBuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacketTx);
-			pBundleBuffer = cdf_nbuf_data(bundleBuf);
+			pBundleBuffer = qdf_nbuf_data(bundleBuf);
 			pQueueSave = (HTC_PACKET_QUEUE *) pPacketTx->pContext;
 		}

 		bundlesSpaceRemaining -= transferLength;
 		netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
-		pHtcHdr = (HTC_FRAME_HDR *) cdf_nbuf_get_frag_vaddr(netbuf, 0);
+		pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0);
 		HTC_WRITE32(pHtcHdr,
 			    SM(pPacket->ActualLength,
 			       HTC_FRAME_HDR_PAYLOADLEN) | SM(pPacket->PktInfo.
@@ -421,12 +421,12 @@ static void htc_issue_packets_bundle(HTC_TARGET *target,
 			       HTC_FRAME_HDR_CONTROLBYTES1) | SM(creditPad,
 								 HTC_FRAME_HDR_RESERVED));
 		pHtcHdr->reserved = creditPad;
-		frag_count = cdf_nbuf_get_num_frags(netbuf);
+		frag_count = qdf_nbuf_get_num_frags(netbuf);
 		nbytes = pPacket->ActualLength + HTC_HDR_LENGTH;
 		for (i = 0; i < frag_count && nbytes > 0; i++) {
-			int frag_len = cdf_nbuf_get_frag_len(netbuf, i);
+			int frag_len = qdf_nbuf_get_frag_len(netbuf, i);
 			unsigned char *frag_addr =
-				cdf_nbuf_get_frag_vaddr(netbuf, i);
+				qdf_nbuf_get_frag_vaddr(netbuf, i);
 			if (frag_len > nbytes) {
 				frag_len = nbytes;
 			}
@@ -437,7 +437,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target,
 		HTC_PACKET_ENQUEUE(pQueueSave, pPacket);
 		pBundleBuffer += creditPad;
 	}
-	if (pBundleBuffer != cdf_nbuf_data(bundleBuf)) {
+	if (pBundleBuffer != qdf_nbuf_data(bundleBuf)) {
 		/* send out remaining buffer */
 		htc_send_bundled_netbuf(target, pEndpoint, pBundleBuffer,
 					pPacketTx);
@@ -453,7 +453,7 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target,
 				  HTC_PACKET_QUEUE *pPktQueue)
 {
 	A_STATUS status = A_OK;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	HTC_PACKET *pPacket = NULL;
 	uint16_t payloadLen;
 	HTC_FRAME_HDR *pHtcHdr;
@@ -492,9 +492,8 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target,
 			payloadLen = pPacket->ActualLength;
 			/* setup HTC frame header */

-			pHtcHdr =
-				(HTC_FRAME_HDR *) cdf_nbuf_get_frag_vaddr(netbuf,
-									  0);
+			pHtcHdr = (HTC_FRAME_HDR *)
+				qdf_nbuf_get_frag_vaddr(netbuf, 0);
 			AR_DEBUG_ASSERT(pHtcHdr);

 			HTC_WRITE32(pHtcHdr,
@@ -520,7 +519,7 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target,
 			 */
 			if (pPacket->PktInfo.AsTx.
 			    Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) {
-				cdf_nbuf_map(target->osdev,
+				qdf_nbuf_map(target->osdev,
 					     GET_HTC_PACKET_NET_BUF_CONTEXT
 						     (pPacket), QDF_DMA_TO_DEVICE);
 			}
@@ -868,9 +867,9 @@ void get_htc_send_packets(HTC_TARGET *target,

 		/*
 		 * FIX THIS:
-		 * For now, avoid calling cdf_nbuf_get_num_frags before calling
-		 * cdf_nbuf_map, because the MacOS version of cdf_nbuf_t doesn't
-		 * support cdf_nbuf_get_num_frags until after cdf_nbuf_map has
+		 * For now, avoid calling qdf_nbuf_get_num_frags before calling
+		 * qdf_nbuf_map, because the MacOS version of qdf_nbuf_t doesn't
+		 * support qdf_nbuf_get_num_frags until after qdf_nbuf_map has
 		 * been done.
 		 * Assume that the non-data netbufs, i.e. the WMI message netbufs,
 		 * consist of a single fragment.
@@ -879,7 +878,7 @@ void get_htc_send_packets(HTC_TARGET *target,
 			(pPacket->PktInfo.AsTx.
 			 Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) ? 1
 			/* WMI messages are in a single-fragment network buffer */ :
-			cdf_nbuf_get_num_frags(GET_HTC_PACKET_NET_BUF_CONTEXT
+			qdf_nbuf_get_num_frags(GET_HTC_PACKET_NET_BUF_CONTEXT
 						       (pPacket));
 		Resources -= num_frags;
 	}
@@ -998,7 +997,7 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target,
 							  pPacket);
 					/* put it in the send queue */
 					/* add HTC_FRAME_HDR space reservation again */
-					cdf_nbuf_push_head
+					qdf_nbuf_push_head
 						(GET_HTC_PACKET_NET_BUF_CONTEXT
 							(pPacket), sizeof(HTC_FRAME_HDR));

@@ -1230,7 +1229,7 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu
 	HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
 	HTC_ENDPOINT *pEndpoint;
 	HTC_PACKET *pPacket;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	HTC_FRAME_HDR *pHtcHdr;

 	AR_DEBUG_PRINTF(ATH_DEBUG_SEND,
@@ -1265,9 +1264,9 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu
 		netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
 		AR_DEBUG_ASSERT(netbuf);

-		cdf_nbuf_push_head(netbuf, sizeof(HTC_FRAME_HDR));
+		qdf_nbuf_push_head(netbuf, sizeof(HTC_FRAME_HDR));
 		/* setup HTC frame header */
-		pHtcHdr = (HTC_FRAME_HDR *) cdf_nbuf_get_frag_vaddr(netbuf, 0);
+		pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0);
 		AR_DEBUG_ASSERT(pHtcHdr);
 		HTC_WRITE32(pHtcHdr,
 			    SM(pPacket->ActualLength,
@@ -1289,7 +1288,7 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu
 		 * mapped.  This only applies to non-data frames, since data frames
 		 * were already mapped as they entered into the driver.
 		 */
-		cdf_nbuf_map(target->osdev,
+		qdf_nbuf_map(target->osdev,
 			     GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket),
 			     QDF_DMA_TO_DEVICE);

@@ -1349,7 +1348,7 @@ A_STATUS htc_send_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket)

 #ifdef ATH_11AC_TXCOMPACT

-A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, cdf_nbuf_t netbuf, int Epid,
+A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid,
 			   int ActualLength)
 {
 	HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
@@ -1380,10 +1379,10 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, cdf_nbuf_t netbuf, int Epid,
 	if (hif_pm_runtime_get(target->hif_dev))
 		return A_ERROR;

-	pHtcHdr = (HTC_FRAME_HDR *) cdf_nbuf_get_frag_vaddr(netbuf, 0);
+	pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0);
 	AR_DEBUG_ASSERT(pHtcHdr);

-	data_attr = cdf_nbuf_data_attr_get(netbuf);
+	data_attr = qdf_nbuf_data_attr_get(netbuf);

 	HTC_WRITE32(pHtcHdr, SM(ActualLength, HTC_FRAME_HDR_PAYLOADLEN) |
 		    SM(Epid, HTC_FRAME_HDR_ENDPOINTID));
@@ -1409,10 +1408,10 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, cdf_nbuf_t netbuf, int Epid,

 	pEndpoint->SeqNo++;

-	NBUF_UPDATE_TX_PKT_COUNT(netbuf, NBUF_TX_PKT_HTC);
+	QDF_NBUF_UPDATE_TX_PKT_COUNT(netbuf, QDF_NBUF_TX_PKT_HTC);
 	DPTRACE(qdf_dp_trace(netbuf, QDF_DP_TRACE_HTC_PACKET_PTR_RECORD,
-				(uint8_t *)(cdf_nbuf_data(netbuf)),
-				sizeof(cdf_nbuf_data(netbuf))));
+				(uint8_t *)(qdf_nbuf_data(netbuf)),
+				sizeof(qdf_nbuf_data(netbuf))));
 	status = hif_send_head(target->hif_dev,
 			       pEndpoint->UL_PipeID,
 			       pEndpoint->Id, ActualLength, netbuf, data_attr);
@@ -1429,7 +1428,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket,
 	HTC_ENDPOINT *pEndpoint;
 	HTC_FRAME_HDR *pHtcHdr;
 	HTC_PACKET_QUEUE sendQueue;
-	cdf_nbuf_t netbuf = NULL;
+	qdf_nbuf_t netbuf = NULL;
 	int tx_resources;
 	A_STATUS status = A_OK;
 	uint32_t data_attr = 0;
@@ -1440,7 +1439,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket,

 		/* add HTC_FRAME_HDR in the initial fragment */
 		netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
-		pHtcHdr = (HTC_FRAME_HDR *) cdf_nbuf_get_frag_vaddr(netbuf, 0);
+		pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0);
 		AR_DEBUG_ASSERT(pHtcHdr);

 		HTC_WRITE32(pHtcHdr,
@@ -1544,10 +1543,10 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket,
 		get_htc_send_packets(target, pEndpoint, &sendQueue, tx_resources);
 		UNLOCK_HTC_TX(target);
 	}
-	NBUF_UPDATE_TX_PKT_COUNT(netbuf, NBUF_TX_PKT_HTC);
+	QDF_NBUF_UPDATE_TX_PKT_COUNT(netbuf, QDF_NBUF_TX_PKT_HTC);
 	DPTRACE(qdf_dp_trace(netbuf, QDF_DP_TRACE_HTC_PACKET_PTR_RECORD,
-				(uint8_t *)(cdf_nbuf_data(netbuf)),
-				sizeof(cdf_nbuf_data(netbuf))));
+				(uint8_t *)(qdf_nbuf_data(netbuf)),
+				sizeof(qdf_nbuf_data(netbuf))));

 	/* send what we can */
 	while (true) {
@@ -1629,15 +1628,16 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket,
 #endif /*ATH_11AC_TXCOMPACT */

 /*
- * In the adapted HIF layer, cdf_nbuf_t are passed between HIF and HTC, since upper layers expects
- * HTC_PACKET containers we use the completed netbuf and lookup its corresponding HTC packet buffer
- * from a lookup list.
- * This is extra overhead that can be fixed by re-aligning HIF interfaces with HTC.
+ * In the adapted HIF layer, qdf_nbuf_t are passed between HIF and HTC,
+ * since upper layers expects HTC_PACKET containers we use the completed netbuf
+ * and lookup its corresponding HTC packet buffer from a lookup list.
+ * This is extra overhead that can be fixed by re-aligning HIF interfaces
+ * with HTC.
 *
 */
 static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target,
 					HTC_ENDPOINT *pEndpoint,
-					cdf_nbuf_t netbuf)
+					qdf_nbuf_t netbuf)
 {
 	HTC_PACKET *pPacket = NULL;
 	HTC_PACKET *pFoundPacket = NULL;
@@ -1655,7 +1655,7 @@ static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target,
 		UNLOCK_HTC_TX(target);
 		return NULL;
 	}
-	if (netbuf == (cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket)) {
+	if (netbuf == (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket)) {
 		UNLOCK_HTC_TX(target);
 		return pPacket;
 	} else {
@@ -1679,7 +1679,7 @@ static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target,
 		}
 		/* check for removal */
 		if (netbuf ==
-		    (cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket)) {
+		    (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket)) {
 			/* found it */
 			HTC_PACKET_REMOVE(&lookupQueue, pPacket);
 			pFoundPacket = pPacket;
@@ -1698,7 +1698,7 @@ static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target,
 }

 QDF_STATUS htc_tx_completion_handler(void *Context,
-				   cdf_nbuf_t netbuf, unsigned int EpID,
+				   qdf_nbuf_t netbuf, unsigned int EpID,
 				   uint32_t toeplitz_hash_result)
 {
 	HTC_TARGET *target = (HTC_TARGET *) Context;
--- a/htc/htc_services.c
+++ b/htc/htc_services.c
@@ -27,7 +27,7 @@

 #include "htc_debug.h"
 #include "htc_internal.h"
-#include <cdf_nbuf.h>           /* cdf_nbuf_t */
+#include <qdf_nbuf.h>           /* qdf_nbuf_t */
 #include "hif.h"

 /* use credit flow control over HTC */
@@ -66,7 +66,7 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle,
 	HTC_ENDPOINT_ID assignedEndpoint = ENDPOINT_MAX;
 	HTC_ENDPOINT *pEndpoint;
 	unsigned int maxMsgSize = 0;
-	cdf_nbuf_t netbuf;
+	qdf_nbuf_t netbuf;
 	A_UINT8 txAlloc;
 	int length;
 	A_BOOL disableCreditFlowCtrl = false;
@@ -109,16 +109,16 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle,
 			}

 			netbuf =
-				(cdf_nbuf_t)
+				(qdf_nbuf_t)
 				GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
 			length =
 				sizeof(HTC_CONNECT_SERVICE_MSG) +
 				pConnectReq->MetaDataLength;

 			/* assemble connect service message */
-			cdf_nbuf_put_tail(netbuf, length);
+			qdf_nbuf_put_tail(netbuf, length);
 			pConnectMsg =
-				(HTC_CONNECT_SERVICE_MSG *) cdf_nbuf_data(netbuf);
+			    (HTC_CONNECT_SERVICE_MSG *) qdf_nbuf_data(netbuf);

 			if (NULL == pConnectMsg) {
 				AR_DEBUG_ASSERT(0);