qcacmn: Rename pAdapter in epping

The Linux Coding Style frowns upon mixed-case names and
so-called Hungarian notation, so rename pAdapter to align
with the Coding Style.

Change-Id: Iddd543a9e0fb61a92e0769abb234b93e44f603c2
CRs-Fixed: 2119798

utils/epping/inc/epping_internal.h

@@ -159,22 +159,22 @@ struct epping_cookie *epping_alloc_cookie(epping_context_t *pEpping_ctx);
 void epping_get_dummy_mac_addr(tSirMacAddr macAddr);
 void epping_hex_dump(void *data, int buf_len, const char *str);
 void *epping_get_qdf_ctx(void);
-void epping_log_packet(epping_adapter_t *pAdapter,
+void epping_log_packet(epping_adapter_t *adapter,
 		       EPPING_HEADER *eppingHdr, int ret, const char *str);
-void epping_log_stats(epping_adapter_t *pAdapter, const char *str);
-void epping_set_kperf_flag(epping_adapter_t *pAdapter,
+void epping_log_stats(epping_adapter_t *adapter, const char *str);
+void epping_set_kperf_flag(epping_adapter_t *adapter,
 			   HTC_ENDPOINT_ID eid, A_UINT8 kperf_flag);
 
 /* epping_tx signatures */
-void epping_tx_timer_expire(epping_adapter_t *pAdapter);
+void epping_tx_timer_expire(epping_adapter_t *adapter);
 void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue);
-int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter);
+int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *adapter);
 
 #ifdef HIF_SDIO
 enum htc_send_full_action epping_tx_queue_full(void *Context,
 						struct _HTC_PACKET *pPacket);
 #endif
-void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
+void epping_tx_dup_pkt(epping_adapter_t *adapter,
 		       HTC_ENDPOINT_ID eid, qdf_nbuf_t skb);
 /* epping_rx signatures */
 void epping_rx(void *Context, HTC_PACKET *pPacket);
@@ -187,7 +187,7 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint);
 epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
 				     tSirMacAddr macAddr,
 				     enum tQDF_ADAPTER_MODE device_mode);
-void epping_destroy_adapter(epping_adapter_t *pAdapter);
+void epping_destroy_adapter(epping_adapter_t *adapter);
 int epping_connect_service(epping_context_t *pEpping_ctx);
 #ifdef HIF_PCI
 void epping_register_tx_copier(HTC_ENDPOINT_ID eid,

utils/epping/src/epping_helper.c

@@ -168,7 +168,7 @@ void *epping_get_qdf_ctx(void)
 	return qdf_ctx;
 }
 
-void epping_log_packet(epping_adapter_t *pAdapter,
+void epping_log_packet(epping_adapter_t *adapter,
 		       EPPING_HEADER *eppingHdr, int ret, const char *str)
 {
 	if (eppingHdr->Cmd_h & EPPING_LOG_MASK) {
@@ -178,33 +178,33 @@ void epping_log_packet(epping_adapter_t *pAdapter,
 			   "rxCount = %lu, rxDrop = %lu, rxBytes = %lu\n",
 			   str, eppingHdr->Cmd_h, eppingHdr->SeqNo,
 			   eppingHdr->CmdFlags_h, ret,
-			   pAdapter->stats.tx_packets,
-			   pAdapter->stats.tx_dropped,
-			   pAdapter->stats.tx_bytes,
-			   pAdapter->stats.rx_packets,
-			   pAdapter->stats.rx_dropped,
-			   pAdapter->stats.rx_bytes);
+			   adapter->stats.tx_packets,
+			   adapter->stats.tx_dropped,
+			   adapter->stats.tx_bytes,
+			   adapter->stats.rx_packets,
+			   adapter->stats.rx_dropped,
+			   adapter->stats.rx_bytes);
 	}
 }
 
-void epping_log_stats(epping_adapter_t *pAdapter, const char *str)
+void epping_log_stats(epping_adapter_t *adapter, const char *str)
 {
 	EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 		   "%s: txCount = %lu, txDrop = %lu, tx_bytes = %lu, "
 		   "rxCount = %lu, rxDrop = %lu, rx_bytes = %lu, tx_acks = %u\n",
 		   str,
-		   pAdapter->stats.tx_packets,
-		   pAdapter->stats.tx_dropped,
-		   pAdapter->stats.tx_bytes,
-		   pAdapter->stats.rx_packets,
-		   pAdapter->stats.rx_dropped,
-		   pAdapter->stats.rx_bytes,
-		   pAdapter->pEpping_ctx->total_tx_acks);
+		   adapter->stats.tx_packets,
+		   adapter->stats.tx_dropped,
+		   adapter->stats.tx_bytes,
+		   adapter->stats.rx_packets,
+		   adapter->stats.rx_dropped,
+		   adapter->stats.rx_bytes,
+		   adapter->pEpping_ctx->total_tx_acks);
 }
 
-void epping_set_kperf_flag(epping_adapter_t *pAdapter,
+void epping_set_kperf_flag(epping_adapter_t *adapter,
 			   HTC_ENDPOINT_ID eid, A_UINT8 kperf_flag)
 {
-	pAdapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
-	pAdapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
+	adapter->pEpping_ctx->kperf_num_rx_recv[eid] = 0;
+	adapter->pEpping_ctx->kperf_num_tx_acks[eid] = 0;
 }

utils/epping/src/epping_rx.c

@@ -110,15 +110,15 @@ void epping_refill(void *ctx, HTC_ENDPOINT_ID Endpoint)
 void epping_rx(void *ctx, HTC_PACKET *pPacket)
 {
 	epping_context_t *pEpping_ctx = (epping_context_t *) ctx;
-	epping_adapter_t *pAdapter = pEpping_ctx->epping_adapter;
-	struct net_device *dev = pAdapter->dev;
+	epping_adapter_t *adapter = pEpping_ctx->epping_adapter;
+	struct net_device *dev = adapter->dev;
 	QDF_STATUS status = pPacket->Status;
 	HTC_ENDPOINT_ID eid = pPacket->Endpoint;
 	struct sk_buff *pktSkb = (struct sk_buff *)pPacket->pPktContext;
 
 	EPPING_LOG(QDF_TRACE_LEVEL_INFO,
-		   "%s: pAdapter = 0x%p eid=%d, skb=0x%p, data=0x%p, len=0x%x status:%d",
-		   __func__, pAdapter, eid, pktSkb, pPacket->pBuffer,
+		   "%s: adapter = 0x%p eid=%d, skb=0x%p, data=0x%p, len=0x%x status:%d",
+		   __func__, adapter, eid, pktSkb, pPacket->pBuffer,
 		   pPacket->ActualLength, status);
 
 	if (status != QDF_STATUS_SUCCESS) {
@@ -140,22 +140,22 @@ void epping_rx(void *ctx, HTC_PACKET *pPacket)
 		pktSkb->dev = dev;
 		if ((pktSkb->dev->flags & IFF_UP) == IFF_UP) {
 			pktSkb->protocol = eth_type_trans(pktSkb, pktSkb->dev);
-			++pAdapter->stats.rx_packets;
-			pAdapter->stats.rx_bytes += pktSkb->len;
+			++adapter->stats.rx_packets;
+			adapter->stats.rx_bytes += pktSkb->len;
 			qdf_net_buf_debug_release_skb(pktSkb);
 			if (hdd_napi_enabled(HDD_NAPI_ANY))
 				netif_receive_skb(pktSkb);
 			else
 				netif_rx_ni(pktSkb);
-			if ((pAdapter->stats.rx_packets %
+			if ((adapter->stats.rx_packets %
 				 EPPING_STATS_LOG_COUNT) == 0) {
 				EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 					   "%s: total_rx_pkts = %lu",
 					   __func__,
-					   pAdapter->stats.rx_packets);
+					   adapter->stats.rx_packets);
 			}
 		} else {
-			++pAdapter->stats.rx_dropped;
+			++adapter->stats.rx_dropped;
 			qdf_nbuf_free(pktSkb);
 		}
 	}

utils/epping/src/epping_tx.c

@@ -55,14 +55,14 @@
 
 static bool enb_tx_dump;
 
-void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
+void epping_tx_dup_pkt(epping_adapter_t *adapter,
 		       HTC_ENDPOINT_ID eid, qdf_nbuf_t skb)
 {
 	struct epping_cookie *cookie = NULL;
 	int skb_len, ret;
 	qdf_nbuf_t new_skb;
 
-	cookie = epping_alloc_cookie(pAdapter->pEpping_ctx);
+	cookie = epping_alloc_cookie(adapter->pEpping_ctx);
 	if (cookie == NULL) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: epping_alloc_cookie returns no resource\n",
@@ -73,7 +73,7 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
 	if (!new_skb) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: qdf_nbuf_copy returns no resource\n", __func__);
-		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
+		epping_free_cookie(adapter->pEpping_ctx, cookie);
 		return;
 	}
 	SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
@@ -82,24 +82,24 @@ void epping_tx_dup_pkt(epping_adapter_t *pAdapter,
 	SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, new_skb);
 	skb_len = (int)qdf_nbuf_len(new_skb);
 	/* send the packet */
-	ret = htc_send_pkt(pAdapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
+	ret = htc_send_pkt(adapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
 	if (ret != QDF_STATUS_SUCCESS) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: htc_send_pkt failed, ret = %d\n", __func__, ret);
-		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
+		epping_free_cookie(adapter->pEpping_ctx, cookie);
 		qdf_nbuf_free(new_skb);
 		return;
 	}
-	pAdapter->stats.tx_bytes += skb_len;
-	++pAdapter->stats.tx_packets;
-	if (((pAdapter->stats.tx_packets +
-	      pAdapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
-	    (pAdapter->stats.tx_packets || pAdapter->stats.tx_dropped)) {
-		epping_log_stats(pAdapter, __func__);
+	adapter->stats.tx_bytes += skb_len;
+	++adapter->stats.tx_packets;
+	if (((adapter->stats.tx_packets +
+	      adapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
+	    (adapter->stats.tx_packets || adapter->stats.tx_dropped)) {
+		epping_log_stats(adapter, __func__);
 	}
 }
 
-static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
+static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *adapter)
 {
 	EPPING_HEADER *eppingHdr = (EPPING_HEADER *) qdf_nbuf_data(skb);
 	HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED;
@@ -110,7 +110,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	EPPING_HEADER tmpHdr = *eppingHdr;
 
 	/* allocate resource for this packet */
-	cookie = epping_alloc_cookie(pAdapter->pEpping_ctx);
+	cookie = epping_alloc_cookie(adapter->pEpping_ctx);
 	/* no resource */
 	if (cookie == NULL) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
@@ -131,7 +131,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	}
 	/* prepare ep/HTC information */
 	ac = eppingHdr->StreamNo_h;
-	eid = pAdapter->pEpping_ctx->EppingEndpoint[ac];
+	eid = adapter->pEpping_ctx->EppingEndpoint[ac];
 	if (eid < 0 || eid >= EPPING_MAX_NUM_EPIDS) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: invalid eid = %d, ac = %d\n", __func__, eid,
@@ -140,7 +140,7 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	}
 	if (tmpHdr.Cmd_h == EPPING_CMD_RESET_RECV_CNT ||
 	    tmpHdr.Cmd_h == EPPING_CMD_CONT_RX_START) {
-		epping_set_kperf_flag(pAdapter, eid, tmpHdr.CmdBuffer_t[0]);
+		epping_set_kperf_flag(adapter, eid, tmpHdr.CmdBuffer_t[0]);
 	}
 	SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
 			       cookie, qdf_nbuf_data(skb), qdf_nbuf_len(skb),
@@ -148,52 +148,52 @@ static int epping_tx_send_int(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	SET_HTC_PACKET_NET_BUF_CONTEXT(&cookie->HtcPkt, skb);
 	skb_len = skb->len;
 	/* send the packet */
-	ret = htc_send_pkt(pAdapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
-	epping_log_packet(pAdapter, &tmpHdr, ret, __func__);
+	ret = htc_send_pkt(adapter->pEpping_ctx->HTCHandle, &cookie->HtcPkt);
+	epping_log_packet(adapter, &tmpHdr, ret, __func__);
 	if (ret != QDF_STATUS_SUCCESS) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: htc_send_pkt failed, status = %d\n", __func__,
 			   ret);
-		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
+		epping_free_cookie(adapter->pEpping_ctx, cookie);
 		return A_ERROR;
 	}
-	pAdapter->stats.tx_bytes += skb_len;
-	++pAdapter->stats.tx_packets;
-	if (((pAdapter->stats.tx_packets +
-	      pAdapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
-	    (pAdapter->stats.tx_packets || pAdapter->stats.tx_dropped)) {
-		epping_log_stats(pAdapter, __func__);
+	adapter->stats.tx_bytes += skb_len;
+	++adapter->stats.tx_packets;
+	if (((adapter->stats.tx_packets +
+	      adapter->stats.tx_dropped) % EPPING_STATS_LOG_COUNT) == 0 &&
+	    (adapter->stats.tx_packets || adapter->stats.tx_dropped)) {
+		epping_log_stats(adapter, __func__);
 	}
 
 	return 0;
 }
 
-void epping_tx_timer_expire(epping_adapter_t *pAdapter)
+void epping_tx_timer_expire(epping_adapter_t *adapter)
 {
 	qdf_nbuf_t nodrop_skb;
 
 	EPPING_LOG(QDF_TRACE_LEVEL_INFO, "%s: queue len: %d\n", __func__,
-		   qdf_nbuf_queue_len(&pAdapter->nodrop_queue));
+		   qdf_nbuf_queue_len(&adapter->nodrop_queue));
 
-	if (!qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
+	if (!qdf_nbuf_queue_len(&adapter->nodrop_queue)) {
 		/* nodrop queue is empty so no need to arm timer */
-		pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
+		adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 		return;
 	}
 
 	/* try to flush nodrop queue */
-	while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
-		htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, true);
-		if (epping_tx_send_int(nodrop_skb, pAdapter)) {
+	while ((nodrop_skb = qdf_nbuf_queue_remove(&adapter->nodrop_queue))) {
+		htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, true);
+		if (epping_tx_send_int(nodrop_skb, adapter)) {
 			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 */
-			qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
+			qdf_nbuf_queue_insert_head(&adapter->nodrop_queue,
 						   nodrop_skb);
 			break;
 		} else {
-			htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, false);
+			htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, false);
 			EPPING_LOG(QDF_TRACE_LEVEL_INFO,
 				   "%s: nodrop: %p xmit ok in timer\n",
 				   __func__, nodrop_skb);
@@ -202,20 +202,20 @@ void epping_tx_timer_expire(epping_adapter_t *pAdapter)
 
 	/* if nodrop queue is not empty, continue to arm timer */
 	if (nodrop_skb) {
-		qdf_spin_lock_bh(&pAdapter->data_lock);
+		qdf_spin_lock_bh(&adapter->data_lock);
 		/* if nodrop queue is not empty, continue to arm timer */
-		if (pAdapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
-			pAdapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
-			qdf_timer_mod(&pAdapter->epping_timer,
+		if (adapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
+			adapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
+			qdf_timer_mod(&adapter->epping_timer,
 					      TX_RETRY_TIMEOUT_IN_MS);
 		}
-		qdf_spin_unlock_bh(&pAdapter->data_lock);
+		qdf_spin_unlock_bh(&adapter->data_lock);
 	} else {
-		pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
+		adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 	}
 }
 
-int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
+int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *adapter)
 {
 	qdf_nbuf_t nodrop_skb;
 	EPPING_HEADER *eppingHdr;
@@ -254,19 +254,19 @@ int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	 */
 
 	/* check the nodrop queue first */
-	while ((nodrop_skb = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue))) {
-		htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, true);
-		if (epping_tx_send_int(nodrop_skb, pAdapter)) {
+	while ((nodrop_skb = qdf_nbuf_queue_remove(&adapter->nodrop_queue))) {
+		htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, true);
+		if (epping_tx_send_int(nodrop_skb, adapter)) {
 			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 */
-			qdf_nbuf_queue_insert_head(&pAdapter->nodrop_queue,
+			qdf_nbuf_queue_insert_head(&adapter->nodrop_queue,
 						   nodrop_skb);
 			/* no cookie so free the current skb */
 			goto tx_fail;
 		} else {
-			htc_set_nodrop_pkt(pAdapter->pEpping_ctx->HTCHandle, false);
+			htc_set_nodrop_pkt(adapter->pEpping_ctx->HTCHandle, false);
 			EPPING_LOG(QDF_TRACE_LEVEL_INFO,
 				   "%s: nodrop: %p xmit ok\n", __func__,
 				   nodrop_skb);
@@ -274,7 +274,7 @@ int epping_tx_send(qdf_nbuf_t skb, epping_adapter_t *pAdapter)
 	}
 
 	/* send the original packet */
-	if (epping_tx_send_int(skb, pAdapter))
+	if (epping_tx_send_int(skb, adapter))
 		goto tx_fail;
 
 	return 0;
@@ -283,22 +283,22 @@ tx_fail:
 	if (!IS_EPING_PACKET_NO_DROP(eppingHdr)) {
 		/* allow to drop the skb so drop it */
 		qdf_nbuf_free(skb);
-		++pAdapter->stats.tx_dropped;
+		++adapter->stats.tx_dropped;
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: Tx skb %p dropped, stats.tx_dropped = %ld\n",
-			   __func__, skb, pAdapter->stats.tx_dropped);
+			   __func__, skb, adapter->stats.tx_dropped);
 		return -ENOMEM;
 	} else {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: nodrop: %p queued\n", __func__, 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;
-			qdf_timer_mod(&pAdapter->epping_timer,
+		qdf_nbuf_queue_add(&adapter->nodrop_queue, skb);
+		qdf_spin_lock_bh(&adapter->data_lock);
+		if (adapter->epping_timer_state != EPPING_TX_TIMER_RUNNING) {
+			adapter->epping_timer_state = EPPING_TX_TIMER_RUNNING;
+			qdf_timer_mod(&adapter->epping_timer,
 					      TX_RETRY_TIMEOUT_IN_MS);
 		}
-		qdf_spin_unlock_bh(&pAdapter->data_lock);
+		qdf_spin_unlock_bh(&adapter->data_lock);
 	}
 
 	return 0;
@@ -318,8 +318,8 @@ enum htc_send_full_action epping_tx_queue_full(void *Context,
 void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 {
 	epping_context_t *pEpping_ctx = (epping_context_t *) ctx;
-	epping_adapter_t *pAdapter = pEpping_ctx->epping_adapter;
-	struct net_device *dev = pAdapter->dev;
+	epping_adapter_t *adapter = pEpping_ctx->epping_adapter;
+	struct net_device *dev = adapter->dev;
 	QDF_STATUS status;
 	HTC_ENDPOINT_ID eid;
 	qdf_nbuf_t pktSkb;
@@ -330,7 +330,7 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 
 	qdf_nbuf_queue_init(&skb_queue);
 
-	qdf_spin_lock_bh(&pAdapter->data_lock);
+	qdf_spin_lock_bh(&adapter->data_lock);
 
 	while (!HTC_QUEUE_EMPTY(pPacketQueue)) {
 		htc_pkt = htc_packet_dequeue(pPacketQueue);
@@ -385,10 +385,10 @@ void epping_tx_complete_multiple(void *ctx, HTC_PACKET_QUEUE *pPacketQueue)
 			flushing = false;
 		}
 
-		epping_free_cookie(pAdapter->pEpping_ctx, cookie);
+		epping_free_cookie(adapter->pEpping_ctx, cookie);
 	}
 
-	qdf_spin_unlock_bh(&pAdapter->data_lock);
+	qdf_spin_unlock_bh(&adapter->data_lock);
 
 	/* free all skbs in our local list */
 	while (qdf_nbuf_queue_len(&skb_queue)) {

utils/epping/src/epping_txrx.c

@@ -51,13 +51,13 @@
 #include "epping_main.h"
 #include "epping_internal.h"
 
-static int epping_start_adapter(epping_adapter_t *pAdapter);
-static void epping_stop_adapter(epping_adapter_t *pAdapter);
+static int epping_start_adapter(epping_adapter_t *adapter);
+static void epping_stop_adapter(epping_adapter_t *adapter);
 
 static void epping_timer_expire(void *data)
 {
 	struct net_device *dev = (struct net_device *)data;
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 
 	if (dev == NULL) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
@@ -65,79 +65,79 @@ static void epping_timer_expire(void *data)
 		return;
 	}
 
-	pAdapter = netdev_priv(dev);
-	if (pAdapter == NULL) {
+	adapter = netdev_priv(dev);
+	if (adapter == NULL) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: adapter = NULL", __func__);
 		return;
 	}
-	pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
-	epping_tx_timer_expire(pAdapter);
+	adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
+	epping_tx_timer_expire(adapter);
 }
 
 static int epping_ndev_open(struct net_device *dev)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 	int ret = 0;
 
-	pAdapter = netdev_priv(dev);
-	epping_start_adapter(pAdapter);
+	adapter = netdev_priv(dev);
+	epping_start_adapter(adapter);
 	return ret;
 }
 
 static int epping_ndev_stop(struct net_device *dev)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 	int ret = 0;
 
-	pAdapter = netdev_priv(dev);
-	if (NULL == pAdapter) {
+	adapter = netdev_priv(dev);
+	if (NULL == adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: EPPING adapter context is Null", __func__);
 		ret = -ENODEV;
 		goto end;
 	}
-	epping_stop_adapter(pAdapter);
+	epping_stop_adapter(adapter);
 end:
 	return ret;
 }
 
 static void epping_ndev_uninit(struct net_device *dev)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 
-	pAdapter = netdev_priv(dev);
-	if (NULL == pAdapter) {
+	adapter = netdev_priv(dev);
+	if (NULL == adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: EPPING adapter context is Null", __func__);
 		goto end;
 	}
-	epping_stop_adapter(pAdapter);
+	epping_stop_adapter(adapter);
 end:
 	return;
 }
 
 static void epping_tx_queue_timeout(struct net_device *dev)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 
-	pAdapter = netdev_priv(dev);
-	if (NULL == pAdapter) {
+	adapter = netdev_priv(dev);
+	if (NULL == adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: EPPING adapter context is Null", __func__);
 		goto end;
 	}
 
 	EPPING_LOG(QDF_TRACE_LEVEL_ERROR,
-		   "%s: Transmission timeout occurred, pAdapter->started= %d",
-		   __func__, pAdapter->started);
+		   "%s: Transmission timeout occurred, adapter->started= %d",
+		   __func__, adapter->started);
 
 	/* Getting here implies we disabled the TX queues
 	 * for too long. Since this is epping
 	 * (not because of disassociation or low resource scenarios),
 	 * try to restart the queue
 	 */
-	if (pAdapter->started)
+	if (adapter->started)
 		netif_wake_queue(dev);
 end:
 	return;
@@ -146,47 +146,47 @@ end:
 
 static int epping_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 	int ret = 0;
 
-	pAdapter = netdev_priv(dev);
-	if (NULL == pAdapter) {
+	adapter = netdev_priv(dev);
+	if (NULL == adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: EPPING adapter context is Null", __func__);
 		ret = -ENODEV;
 		goto end;
 	}
-	ret = epping_tx_send(skb, pAdapter);
+	ret = epping_tx_send(skb, adapter);
 end:
 	return ret;
 }
 
 static struct net_device_stats *epping_get_stats(struct net_device *dev)
 {
-	epping_adapter_t *pAdapter = netdev_priv(dev);
+	epping_adapter_t *adapter = netdev_priv(dev);
 
-	if (NULL == pAdapter) {
-		EPPING_LOG(QDF_TRACE_LEVEL_ERROR, "%s: pAdapter = NULL",
+	if (NULL == adapter) {
+		EPPING_LOG(QDF_TRACE_LEVEL_ERROR, "%s: adapter = NULL",
 			   __func__);
 		return NULL;
 	}
 
-	return &pAdapter->stats;
+	return &adapter->stats;
 }
 
 static int epping_ndev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 	int ret = 0;
 
-	pAdapter = netdev_priv(dev);
-	if (NULL == pAdapter) {
+	adapter = netdev_priv(dev);
+	if (NULL == adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: EPPING adapter context is Null", __func__);
 		ret = -ENODEV;
 		goto end;
 	}
-	if (dev != pAdapter->dev) {
+	if (dev != adapter->dev) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: HDD adapter/dev inconsistency", __func__);
 		ret = -ENODEV;
@@ -217,15 +217,15 @@ end:
 
 static int epping_set_mac_address(struct net_device *dev, void *addr)
 {
-	epping_adapter_t *pAdapter = netdev_priv(dev);
+	epping_adapter_t *adapter = netdev_priv(dev);
 	struct sockaddr *psta_mac_addr = addr;
-	qdf_mem_copy(&pAdapter->macAddressCurrent,
+	qdf_mem_copy(&adapter->macAddressCurrent,
 		     psta_mac_addr->sa_data, ETH_ALEN);
 	qdf_mem_copy(dev->dev_addr, psta_mac_addr->sa_data, ETH_ALEN);
 	return 0;
 }
 
-static void epping_stop_adapter(epping_adapter_t *pAdapter)
+static void epping_stop_adapter(epping_adapter_t *adapter)
 {
 	qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
@@ -235,17 +235,17 @@ static void epping_stop_adapter(epping_adapter_t *pAdapter)
 		return;
 	}
 
-	if (pAdapter && pAdapter->started) {
+	if (adapter && adapter->started) {
 		EPPING_LOG(LOG1, FL("Disabling queues"));
-		netif_tx_disable(pAdapter->dev);
-		netif_carrier_off(pAdapter->dev);
-		pAdapter->started = false;
+		netif_tx_disable(adapter->dev);
+		netif_carrier_off(adapter->dev);
+		adapter->started = false;
 		pld_request_bus_bandwidth(qdf_ctx->dev,
 					  PLD_BUS_WIDTH_LOW);
 	}
 }
 
-static int epping_start_adapter(epping_adapter_t *pAdapter)
+static int epping_start_adapter(epping_adapter_t *adapter)
 {
 	qdf_device_t qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
@@ -255,78 +255,78 @@ static int epping_start_adapter(epping_adapter_t *pAdapter)
 		return -EINVAL;
 	}
 
-	if (!pAdapter) {
+	if (!adapter) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
-			   "%s: pAdapter= NULL\n", __func__);
+			   "%s: adapter= NULL\n", __func__);
 		return -EINVAL;
 	}
-	if (!pAdapter->started) {
+	if (!adapter->started) {
 		pld_request_bus_bandwidth(qdf_ctx->dev,
 					  PLD_BUS_WIDTH_HIGH);
-		netif_carrier_on(pAdapter->dev);
+		netif_carrier_on(adapter->dev);
 		EPPING_LOG(LOG1, FL("Enabling queues"));
-		netif_tx_start_all_queues(pAdapter->dev);
-		pAdapter->started = true;
+		netif_tx_start_all_queues(adapter->dev);
+		adapter->started = true;
 	} else {
 		EPPING_LOG(QDF_TRACE_LEVEL_WARN,
-			   "%s: pAdapter %p already started\n", __func__,
-			   pAdapter);
+			   "%s: adapter %p already started\n", __func__,
+			   adapter);
 	}
 	return 0;
 }
 
-static int epping_register_adapter(epping_adapter_t *pAdapter)
+static int epping_register_adapter(epping_adapter_t *adapter)
 {
 	int ret = 0;
 
-	ret = register_netdev(pAdapter->dev);
+	ret = register_netdev(adapter->dev);
 	if (ret != 0) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
 			   "%s: unable to register device\n",
-			   pAdapter->dev->name);
+			   adapter->dev->name);
 	} else {
-		pAdapter->registered = true;
+		adapter->registered = true;
 	}
 	return ret;
 }
 
-static void epping_unregister_adapter(epping_adapter_t *pAdapter)
+static void epping_unregister_adapter(epping_adapter_t *adapter)
 {
-	if (pAdapter) {
-		epping_stop_adapter(pAdapter);
-		if (pAdapter->registered) {
-			unregister_netdev(pAdapter->dev);
-			pAdapter->registered = false;
+	if (adapter) {
+		epping_stop_adapter(adapter);
+		if (adapter->registered) {
+			unregister_netdev(adapter->dev);
+			adapter->registered = false;
 		}
 	} else {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
-			   "%s: pAdapter = NULL, unable to unregister device\n",
+			   "%s: adapter = NULL, unable to unregister device\n",
 			   __func__);
 	}
 }
 
-void epping_destroy_adapter(epping_adapter_t *pAdapter)
+void epping_destroy_adapter(epping_adapter_t *adapter)
 {
 	struct net_device *dev = NULL;
 	epping_context_t *pEpping_ctx;
 
-	if (!pAdapter || !pAdapter->pEpping_ctx) {
+	if (!adapter || !adapter->pEpping_ctx) {
 		EPPING_LOG(QDF_TRACE_LEVEL_FATAL,
-			   "%s: pAdapter = NULL\n", __func__);
+			   "%s: adapter = NULL\n", __func__);
 		return;
 	}
 
-	dev = pAdapter->dev;
-	pEpping_ctx = pAdapter->pEpping_ctx;
-	epping_unregister_adapter(pAdapter);
+	dev = adapter->dev;
+	pEpping_ctx = adapter->pEpping_ctx;
+	epping_unregister_adapter(adapter);
 
-	qdf_spinlock_destroy(&pAdapter->data_lock);
-	qdf_timer_free(&pAdapter->epping_timer);
-	pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
+	qdf_spinlock_destroy(&adapter->data_lock);
+	qdf_timer_free(&adapter->epping_timer);
+	adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
 
-	while (qdf_nbuf_queue_len(&pAdapter->nodrop_queue)) {
+	while (qdf_nbuf_queue_len(&adapter->nodrop_queue)) {
 		qdf_nbuf_t tmp_nbuf = NULL;
-		tmp_nbuf = qdf_nbuf_queue_remove(&pAdapter->nodrop_queue);
+		tmp_nbuf = qdf_nbuf_queue_remove(&adapter->nodrop_queue);
 		if (tmp_nbuf)
 			qdf_nbuf_free(tmp_nbuf);
 	}
@@ -358,7 +358,7 @@ epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
 				     enum tQDF_ADAPTER_MODE device_mode)
 {
 	struct net_device *dev;
-	epping_adapter_t *pAdapter;
+	epping_adapter_t *adapter;
 
 	dev = alloc_netdev(sizeof(epping_adapter_t), "wifi%d",
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0))
@@ -371,30 +371,30 @@ epping_adapter_t *epping_add_adapter(epping_context_t *pEpping_ctx,
 		return NULL;
 	}
 
-	pAdapter = netdev_priv(dev);
-	qdf_mem_zero(pAdapter, sizeof(*pAdapter));
-	pAdapter->dev = dev;
-	pAdapter->pEpping_ctx = pEpping_ctx;
-	pAdapter->device_mode = device_mode;    /* station, SAP, etc */
+	adapter = netdev_priv(dev);
+	qdf_mem_zero(adapter, sizeof(*adapter));
+	adapter->dev = dev;
+	adapter->pEpping_ctx = pEpping_ctx;
+	adapter->device_mode = device_mode;    /* station, SAP, etc */
 	qdf_mem_copy(dev->dev_addr, (void *)macAddr, sizeof(tSirMacAddr));
-	qdf_mem_copy(pAdapter->macAddressCurrent.bytes,
+	qdf_mem_copy(adapter->macAddressCurrent.bytes,
 		     macAddr, sizeof(tSirMacAddr));
-	qdf_spinlock_create(&pAdapter->data_lock);
-	qdf_nbuf_queue_init(&pAdapter->nodrop_queue);
-	pAdapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
-	qdf_timer_init(epping_get_qdf_ctx(), &pAdapter->epping_timer,
+	qdf_spinlock_create(&adapter->data_lock);
+	qdf_nbuf_queue_init(&adapter->nodrop_queue);
+	adapter->epping_timer_state = EPPING_TX_TIMER_STOPPED;
+	qdf_timer_init(epping_get_qdf_ctx(), &adapter->epping_timer,
 		epping_timer_expire, dev, QDF_TIMER_TYPE_SW);
 	dev->type = ARPHRD_IEEE80211;
 	dev->netdev_ops = &epping_drv_ops;
 	dev->watchdog_timeo = 5 * HZ;   /* XXX */
 	dev->tx_queue_len = EPPING_TXBUF - 1;      /* 1 for mgmt frame */
-	if (epping_register_adapter(pAdapter) == 0) {
+	if (epping_register_adapter(adapter) == 0) {
 		EPPING_LOG(LOG1, FL("Disabling queues"));
 		netif_tx_disable(dev);
 		netif_carrier_off(dev);
-		return pAdapter;
+		return adapter;
 	} else {
-		epping_destroy_adapter(pAdapter);
+		epping_destroy_adapter(adapter);
 		return NULL;
 	}
 }