qcacld-3.0: Update driver to use QDF NBUF APIs(1/2)

Update driver to use QDF NBUF APIs

Change-Id: I4409b6c046de1221b57baed45088d5f3b898b565
CRs-Fixed: 981188

7 files changed, 58 insertions, 58 deletions

diff --git a/core/utils/epping/inc/epping_internal.h b/core/utils/epping/inc/epping_internal.h
index 0c980de6b759..2439c575113a 100644
--- a/core/utils/epping/inc/epping_internal.h
+++ b/core/utils/epping/inc/epping_internal.h
@@ -96,7 +96,7 @@ typedef struct {
 	struct task_struct *pid;
 	void *arg;
 	bool done;
-	cdf_nbuf_t skb;
+	qdf_nbuf_t skb;
 	HTC_ENDPOINT_ID eid;
 	struct semaphore sem;
 	bool inited;
@@ -142,7 +142,7 @@ typedef struct epping_adapter_s {
 	uint8_t sessionId;
 	/* for mboxping */
 	qdf_spinlock_t data_lock;
-	cdf_nbuf_queue_t nodrop_queue;
+	qdf_nbuf_queue_t nodrop_queue;
 	qdf_timer_t epping_timer;
 	epping_tx_timer_state_t epping_timer_state;
 	bool registered;
@@ -168,7 +168,7 @@ void epping_set_kperf_flag(epping_adapter_t *pAdapter,
 /* epping_tx signatures */
 void epping_tx_timer_expire(epping_adapter_t *pAdapter);
 void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue);
-int epping_tx_send(cdf_nbuf_t skb, epping_adapter_t *pAdapter);
+int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter);
 
 #ifdef HIF_SDIO
 HTC_SEND_FULL_ACTION epping_tx_queue_full(void *Context, HTC_PACKET *pPacket);
@@ -192,6 +192,6 @@ void epping_register_tx_copier(HTC_ENDPOINT_ID eid,
 void epping_unregister_tx_copier(HTC_ENDPOINT_ID eid,
 				 epping_context_t *pEpping_ctx);
 void epping_tx_copier_schedule(epping_context_t *pEpping_ctx,
-			       HTC_ENDPOINT_ID eid, cdf_nbuf_t skb);
+			       HTC_ENDPOINT_ID eid, qdf_nbuf_t skb);
 #endif /* HIF_PCI */
 #endif /* end #ifndef EPPING_INTERNAL_H */
diff --git a/core/utils/epping/src/epping_rx.c b/core/utils/epping/src/epping_rx.c
index ea2d32311c37..2718e64e5a32 100644
--- a/core/utils/epping/src/epping_rx.c
+++ b/core/utils/epping/src/epping_rx.c
@@ -83,7 +83,7 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint)
 		   __func__, buffersToRefill, Endpoint);
 
 	for (RxBuffers = 0; RxBuffers < buffersToRefill; RxBuffers++) {
-		osBuf = cdf_nbuf_alloc(NULL, AR6000_BUFFER_SIZE,
+		osBuf = qdf_nbuf_alloc(NULL, AR6000_BUFFER_SIZE,
 				       AR6000_MIN_HEAD_ROOM, 4, false);
 		if (NULL == osBuf) {
 			break;
@@ -93,7 +93,7 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint)
 		pPacket = (HTC_PACKET *) (A_NETBUF_HEAD(osBuf));
 		/* set re-fill info */
 		SET_HTC_PACKET_INFO_RX_REFILL(pPacket, osBuf,
-					      cdf_nbuf_data(osBuf),
+					      qdf_nbuf_data(osBuf),
 					      AR6000_BUFFER_SIZE, Endpoint);
 		SET_HTC_PACKET_NET_BUF_CONTEXT(pPacket, osBuf);
 		/* add to queue */
@@ -123,9 +123,9 @@ void epping_rx(void *ctx, HTC_PACKET *pPacket)
 
 	if (status != A_OK) {
 		if (status != A_ECANCELED) {
-			printk("%s: RX ERR (%d) \n", __func__, status);
+			printk("%s: RX ERR (%d)\n", __func__, status);
 		}
-		cdf_nbuf_free(pktSkb);
+		qdf_nbuf_free(pktSkb);
 		return;
 	}
 
@@ -135,7 +135,7 @@ void epping_rx(void *ctx, HTC_PACKET *pPacket)
 			A_NETBUF_PULL(pktSkb, EPPING_ALIGNMENT_PAD);
 		}
 		if (enb_rx_dump)
-			epping_hex_dump((void *)cdf_nbuf_data(pktSkb),
+			epping_hex_dump((void *)qdf_nbuf_data(pktSkb),
 					pktSkb->len, __func__);
 		pktSkb->dev = dev;
 		if ((pktSkb->dev->flags & IFF_UP) == IFF_UP) {
@@ -155,7 +155,7 @@ void epping_rx(void *ctx, HTC_PACKET *pPacket)
 			}
 		} else {
 			++pAdapter->stats.rx_dropped;
-			cdf_nbuf_free(pktSkb);
+			qdf_nbuf_free(pktSkb);
 		}
 	}
 }
diff --git a/core/utils/epping/src/epping_tx.c b/core/utils/epping/src/epping_tx.c
index 814f4438dfa3..ffcf8df36b2e 100644
--- a/core/utils/epping/src/epping_tx.c
+++ b/core/utils/epping/src/epping_tx.c
@@ -56,11 +56,11 @@
 static bool enb_tx_dump;
 
 void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
-		       HTC_ENDPOINT_ID eid, cdf_nbuf_t skb)
+		       HTC_ENDPOINT_ID eid, qdf_nbuf_t skb)
 {
 	struct epping_cookie *cookie = NULL;
 	int skb_len, ret;
-	cdf_nbuf_t new_skb;
+	qdf_nbuf_t new_skb;
 
 	cookie = epping_alloc_cookie(pAdapter->pEpping_ctx);
 	if (cookie == NULL) {
@@ -69,25 +69,25 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
 			   __func__);
 		return;
 	}
-	new_skb = cdf_nbuf_copy(skb);
+	new_skb = qdf_nbuf_copy(skb);
 	if (!new_skb) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
-			   "%s: cdf_nbuf_copy returns no resource\n", __func__);
+			   "%s: qdf_nbuf_copy returns no resource\n", __func__);
 		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
 		return;
 	}
 	SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
-			       cookie, cdf_nbuf_data(skb),
-			       cdf_nbuf_len(new_skb), eid, 0);
+			       cookie, qdf_nbuf_data(skb),
+			       qdf_nbuf_len(new_skb), eid, 0);
 	SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, new_skb);
-	skb_len = (int)cdf_nbuf_len(new_skb);
+	skb_len = (int)qdf_nbuf_len(new_skb);
 	/* send the packet */
 	ret = htc_send_pkt(pAdapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
 	if (ret != A_OK) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: htc_send_pkt failed, ret = %d\n", __func__, ret);
 		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
-		cdf_nbuf_free(new_skb);
+		qdf_nbuf_free(new_skb);
 		return;
 	}
 	pAdapter->stats.tx_bytes += skb_len;
@@ -99,9 +99,9 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
 	}
 }
 
-static int epping_tx_send_int(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
+static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 {
-	EPPING_HEADER *eppingHdr = (EPPING_HEADER *) cdf_nbuf_data(skb);
+	EPPING_HEADER *eppingHdr = (EPPING_HEADER *) qdf_nbuf_data(skb);
 	HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED;
 	struct epping_cookie *cookie = NULL;
 	A_UINT8 ac = 0;
@@ -143,7 +143,7 @@ static int epping_tx_send_int(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
 		epping_set_kperf_flag(pAdapter, eid, tmpHdr.CmdBuffer_t[0]);
 	}
 	SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
-			       cookie, cdf_nbuf_data(skb), cdf_nbuf_len(skb),
+			       cookie, qdf_nbuf_data(skb), qdf_nbuf_len(skb),
 			       eid, 0);
 	SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, skb);
 	skb_len = skb->len;
@@ -170,25 +170,25 @@ static int epping_tx_send_int(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
 
 void epping_tx_timer_expire(epping_adapter_t *pAdapter)
 {
-	cdf_nbuf_t nodrop_skb;
+	qdf_nbuf_t nodrop_skb;
 
 	EPPING_LOG(QDF_TRACE_LEVEL_INFO, "%s: queue len: %d\n", __func__,
-		   cdf_nbuf_queue_len(&pAdapter->nodrop_queue));
+		   qdf_nbuf_queue_len(&pAdapter->nodrop_queue));
 
-	if (!cdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
+	if (!qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
 		/* nodrop queue is empty so no need to arm timer */
 		pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 		return;
 	}
 
 	/* try to flush nodrop queue */
-	while ((nodrop_skb = cdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
+	while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
 		if (epping_tx_send_int(nodrop_skb, pAdapter)) {
 			EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 				   "%s: nodrop: %p xmit fail in timer\n",
 				   __func__, nodrop_skb);
 			/* fail to xmit so put the nodrop packet to the nodrop queue */
-			cdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
+			qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
 						   nodrop_skb);
 			break;
 		} else {
@@ -213,19 +213,19 @@ void epping_tx_timer_expire(epping_adapter_t *pAdapter)
 	}
 }
 
-int epping_tx_send(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
+int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 {
-	cdf_nbuf_t nodrop_skb;
+	qdf_nbuf_t nodrop_skb;
 	EPPING_HEADER *eppingHdr;
 	A_UINT8 ac = 0;
 
-	eppingHdr = (EPPING_HEADER *) cdf_nbuf_data(skb);
+	eppingHdr = (EPPING_HEADER *) qdf_nbuf_data(skb);
 
 	if (!IS_EPPING_PACKET(eppingHdr)) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: Recived non endpoint ping packets\n", __func__);
 		/* no packet to send, cleanup */
-		cdf_nbuf_free(skb);
+		qdf_nbuf_free(skb);
 		return -ENOMEM;
 	}
 
@@ -236,7 +236,7 @@ int epping_tx_send(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: ac %d is not mapped to mboxping service\n",
 			   __func__, ac);
-		cdf_nbuf_free(skb);
+		qdf_nbuf_free(skb);
 		return -ENOMEM;
 	}
 
@@ -252,13 +252,13 @@ int epping_tx_send(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	 */
 
 	/* check the nodrop queue first */
-	while ((nodrop_skb = cdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
+	while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
 		if (epping_tx_send_int(nodrop_skb, pAdapter)) {
 			EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 				   "%s: nodrop: %p xmit fail\n", __func__,
 				   nodrop_skb);
 			/* fail to xmit so put the nodrop packet to the nodrop queue */
-			cdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
+			qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
 						   nodrop_skb);
 			/* no cookie so free the current skb */
 			goto tx_fail;
@@ -278,7 +278,7 @@ int epping_tx_send(cdf_nbuf_t skb, epping_adapter_t *pAdapter)
 tx_fail:
 	if (!IS_EPING_PACKET_NO_DROP(eppingHdr)) {
 		/* allow to drop the skb so drop it */
-		cdf_nbuf_free(skb);
+		qdf_nbuf_free(skb);
 		++pAdapter->stats.tx_dropped;
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: Tx skb %p dropped, stats.tx_dropped = %ld\n",
@@ -287,7 +287,7 @@ tx_fail:
 	} else {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: nodrop: %p queued\n", __func__, skb);
-		cdf_nbuf_queue_add(&pAdapter->nodrop_queue, skb);
+		qdf_nbuf_queue_add(&pAdapter->nodrop_queue, skb);
 		qdf_spin_lock_bh(&pAdapter->data_lock);
 		if (pAdapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
 			pAdapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
@@ -317,13 +317,13 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 	struct net_device *dev = pAdapter->dev;
 	A_STATUS status;
 	HTC_ENDPOINT_ID eid;
-	cdf_nbuf_t pktSkb;
+	qdf_nbuf_t pktSkb;
 	struct epping_cookie *cookie;
 	A_BOOL flushing = false;
-	cdf_nbuf_queue_t skb_queue;
+	qdf_nbuf_queue_t skb_queue;
 	HTC_PACKET *htc_pkt;
 
-	cdf_nbuf_queue_init(&skb_queue);
+	qdf_nbuf_queue_init(&skb_queue);
 
 	qdf_spin_lock_bh(&pAdapter->data_lock);
 
@@ -337,13 +337,13 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 		cookie = htc_pkt->pPktContext;
 
 		ASSERT(pktSkb);
-		ASSERT(htc_pkt->pBuffer == cdf_nbuf_data(pktSkb));
+		ASSERT(htc_pkt->pBuffer == qdf_nbuf_data(pktSkb));
 
 		/* add this to the list, use faster non-lock API */
-		cdf_nbuf_queue_add(&skb_queue, pktSkb);
+		qdf_nbuf_queue_add(&skb_queue, pktSkb);
 
 		if (A_SUCCESS(status)) {
-			ASSERT(htc_pkt->ActualLength == cdf_nbuf_len(pktSkb));
+			ASSERT(htc_pkt->ActualLength == qdf_nbuf_len(pktSkb));
 		}
 		EPPING_LOG(QDF_TRACE_LEVEL_INFO,
 			   "%s skb=%p data=%p len=0x%x eid=%d ",
@@ -370,12 +370,12 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 	qdf_spin_unlock_bh(&pAdapter->data_lock);
 
 	/* free all skbs in our local list */
-	while (cdf_nbuf_queue_len(&skb_queue)) {
+	while (qdf_nbuf_queue_len(&skb_queue)) {
 		/* use non-lock version */
-		pktSkb = cdf_nbuf_queue_remove(&skb_queue);
+		pktSkb = qdf_nbuf_queue_remove(&skb_queue);
 		if (pktSkb == NULL)
 			break;
-		cdf_nbuf_free(pktSkb);
+		qdf_nbuf_free(pktSkb);
 		pEpping_ctx->total_tx_acks++;
 	}
 
diff --git a/core/utils/epping/src/epping_txrx.c b/core/utils/epping/src/epping_txrx.c
index 3d41d0f707f7..dc7e2fe8ee30 100644
--- a/core/utils/epping/src/epping_txrx.c
+++ b/core/utils/epping/src/epping_txrx.c
@@ -312,11 +312,11 @@ void epping_destroy_adapter(epping_adapter_t *pAdapter)
 	qdf_timer_free(&pAdapter->epping_timer);
 	pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 
-	while (cdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
-		cdf_nbuf_t tmp_nbuf = NULL;
-		tmp_nbuf = cdf_nbuf_queue_remove(&pAdapter->nodrop_queue);
+	while (qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
+		qdf_nbuf_t tmp_nbuf = NULL;
+		tmp_nbuf = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue);
 		if (tmp_nbuf)
-			cdf_nbuf_free(tmp_nbuf);
+			qdf_nbuf_free(tmp_nbuf);
 	}
 
 	free_netdev(dev);
@@ -368,7 +368,7 @@ epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
 	qdf_mem_copy(pAdapter->macAddressCurrent.bytes,
 		     macAddr, sizeof(tSirMacAddr));
 	qdf_spinlock_create(&pAdapter->data_lock);
-	cdf_nbuf_queue_init(&pAdapter->nodrop_queue);
+	qdf_nbuf_queue_init(&pAdapter->nodrop_queue);
 	pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 	qdf_timer_init(epping_get_cdf_ctx(), &pAdapter->epping_timer,
 		epping_timer_expire, dev, QDF_TIMER_TYPE_SW);
diff --git a/core/utils/fwlog/dbglog_host.c b/core/utils/fwlog/dbglog_host.c
index b37e83974340..977d0517e3a2 100644
--- a/core/utils/fwlog/dbglog_host.c
+++ b/core/utils/fwlog/dbglog_host.c
@@ -1392,7 +1392,7 @@ wmi_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
 				      len, WMI_DBGLOG_CFG_CMDID);
 
 	if (status != A_OK)
-		cdf_nbuf_free(buf);
+		qdf_nbuf_free(buf);
 
 	return status;
 }
diff --git a/core/utils/pktlog/include/pktlog_ac_i.h b/core/utils/pktlog/include/pktlog_ac_i.h
index 07bbac07a168..7dbf443a6990 100644
--- a/core/utils/pktlog/include/pktlog_ac_i.h
+++ b/core/utils/pktlog/include/pktlog_ac_i.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -59,7 +59,7 @@ char *pktlog_getbuf(struct ol_pktlog_dev_t *pl_dev,
 
 A_STATUS process_tx_info(struct ol_txrx_pdev_t *pdev, void *data);
 A_STATUS process_rx_info(void *pdev, void *data);
-A_STATUS process_rx_info_remote(void *pdev, cdf_nbuf_t amsdu);
+A_STATUS process_rx_info_remote(void *pdev, qdf_nbuf_t amsdu);
 A_STATUS process_rate_find(void *pdev, void *data);
 A_STATUS process_rate_update(void *pdev, void *data);
 
diff --git a/core/utils/pktlog/pktlog_internal.c b/core/utils/pktlog/pktlog_internal.c
index 010585ce362f..0d219b628475 100644
--- a/core/utils/pktlog/pktlog_internal.c
+++ b/core/utils/pktlog/pktlog_internal.c
@@ -406,7 +406,7 @@ A_STATUS process_tx_info(struct ol_txrx_pdev_t *txrx_pdev, void *data)
 						  msdu_id_offset);
 		uint8_t *addr, *vap_addr;
 		uint8_t vdev_id;
-		cdf_nbuf_t netbuf;
+		qdf_nbuf_t netbuf;
 		uint32_t len;
 
 		qdf_mem_set(&pl_msdu_info, sizeof(pl_msdu_info), 0);
@@ -436,7 +436,7 @@ A_STATUS process_tx_info(struct ol_txrx_pdev_t *txrx_pdev, void *data)
 			htt_tx_desc = (uint32_t *) tx_desc->htt_tx_desc;
 			qdf_assert(htt_tx_desc);
 
-			cdf_nbuf_peek_header(netbuf, &addr, &len);
+			qdf_nbuf_peek_header(netbuf, &addr, &len);
 
 			if (len < (2 * IEEE80211_ADDR_LEN)) {
 				qdf_print("TX frame does not have a valid"
@@ -482,7 +482,7 @@ A_STATUS process_tx_info(struct ol_txrx_pdev_t *txrx_pdev, void *data)
 	return A_OK;
 }
 
-A_STATUS process_rx_info_remote(void *pdev, cdf_nbuf_t amsdu)
+A_STATUS process_rx_info_remote(void *pdev, qdf_nbuf_t amsdu)
 {
 	struct ol_pktlog_dev_t *pl_dev;
 	struct ath_pktlog_info *pl_info;
@@ -490,7 +490,7 @@ A_STATUS process_rx_info_remote(void *pdev, cdf_nbuf_t amsdu)
 	struct ath_pktlog_hdr pl_hdr;
 	struct ath_pktlog_rx_info rxstat_log;
 	size_t log_size;
-	cdf_nbuf_t msdu;
+	qdf_nbuf_t msdu;
 
 	if (!pdev) {
 		printk("Invalid pdev in %s\n", __func__);
@@ -506,7 +506,7 @@ A_STATUS process_rx_info_remote(void *pdev, cdf_nbuf_t amsdu)
 
 	while (msdu) {
 		rx_desc =
-			(struct htt_host_rx_desc_base *)(cdf_nbuf_data(msdu)) - 1;
+		   (struct htt_host_rx_desc_base *)(qdf_nbuf_data(msdu)) - 1;
 		log_size =
 			sizeof(*rx_desc) - sizeof(struct htt_host_fw_desc_base);
 
@@ -530,7 +530,7 @@ A_STATUS process_rx_info_remote(void *pdev, cdf_nbuf_t amsdu)
 							   log_size, &pl_hdr);
 		qdf_mem_copy(rxstat_log.rx_desc, (void *)rx_desc +
 			     sizeof(struct htt_host_fw_desc_base), pl_hdr.size);
-		msdu = cdf_nbuf_next(msdu);
+		msdu = qdf_nbuf_next(msdu);
 	}
 	return A_OK;
 }