[PATCH 11/52] musb_hdrc: Search and replace wCount with len

[Tony Lindgren <tony@atomide.com>]

Search and replace wCount with len

Signed-off-by: Tony Lindgren <tony@atomide.com>
---
 drivers/usb/musb/g_ep0.c       |   10 ++++----
 drivers/usb/musb/musb_gadget.c |   12 +++++-----
 drivers/usb/musb/musb_host.c   |   16 +++++++-------
 drivers/usb/musb/musbdefs.h    |    4 +-
 drivers/usb/musb/plat_uds.c    |   44 ++++++++++++++++++++--------------------
 5 files changed, 43 insertions(+), 43 deletions(-)

--- a/drivers/usb/musb/g_ep0.c
+++ b/drivers/usb/musb/g_ep0.c
@@ -599,17 +599,17 @@ __acquires(musb->Lock)
 irqreturn_t musb_g_ep0_irq(struct musb *musb)
 {
 	u16		wCsrVal;
-	u16		wCount;
+	u16		len;
 	void __iomem	*mbase = musb->mregs;
 	void __iomem	*regs = musb->aLocalEnd[0].regs;
 	irqreturn_t	retval = IRQ_NONE;
 
 	MGC_SelectEnd(mbase, 0);	/* select ep0 */
 	wCsrVal = musb_readw(regs, MGC_O_HDRC_CSR0);
-	wCount = musb_readb(regs, MGC_O_HDRC_COUNT0);
+	len = musb_readb(regs, MGC_O_HDRC_COUNT0);
 
 	DBG(4, "csr %04x, count %d, myaddr %d, ep0stage %s\n",
-			wCsrVal, wCount,
+			wCsrVal, len,
 			musb_readb(mbase, MGC_O_HDRC_FADDR),
 			decode_ep0stage(musb->ep0_state));
 
@@ -696,8 +696,8 @@ irqreturn_t musb_g_ep0_irq(struct musb *musb)
 			struct usb_ctrlrequest	setup;
 			int			handled = 0;
 
-			if (wCount != 8) {
-				ERR("SETUP packet len %d != 8 ?\n", wCount);
+			if (len != 8) {
+				ERR("SETUP packet len %d != 8 ?\n", len);
 				break;
 			}
 			musb_read_setup(musb, &setup);
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -578,7 +578,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 	struct musb_ep		*musb_ep = &musb->aLocalEnd[bEnd].ep_out;
 	void __iomem		*epio = musb->aLocalEnd[bEnd].regs;
 	u16			fifo_count = 0;
-	u16			wCount = musb_ep->wPacketSize;
+	u16			len = musb_ep->wPacketSize;
 
 	wCsrVal = musb_readw(epio, MGC_O_HDRC_RXCSR);
 
@@ -610,7 +610,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 	}
 
 	if (wCsrVal & MGC_M_RXCSR_RXPKTRDY) {
-		wCount = musb_readw(epio, MGC_O_HDRC_RXCOUNT);
+		len = musb_readw(epio, MGC_O_HDRC_RXCOUNT);
 		if (pRequest->actual < pRequest->length) {
 #ifdef CONFIG_USB_INVENTRA_DMA
 			if (is_dma_capable() && musb_ep->dma) {
@@ -663,7 +663,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 					transfer_size = min(pRequest->length,
 							channel->dwMaxLength);
 #else
-					transfer_size = wCount;
+					transfer_size = len;
 #endif
 					if (transfer_size <= musb_ep->wPacketSize)
 						musb_ep->dma->bDesiredMode = 0;
@@ -687,10 +687,10 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 			fifo_count = pRequest->length - pRequest->actual;
 			DBG(3, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
 					musb_ep->end_point.name,
-					wCount, fifo_count,
+					len, fifo_count,
 					musb_ep->wPacketSize);
 
-			fifo_count = min(wCount, fifo_count);
+			fifo_count = min(len, fifo_count);
 
 #ifdef	CONFIG_USB_TUSB_OMAP_DMA
 			if (tusb_dma_omap() && musb_ep->dma) {
@@ -725,7 +725,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
 	}
 
 	/* reach the end or short packet detected */
-	if (pRequest->actual == pRequest->length || wCount < musb_ep->wPacketSize)
+	if (pRequest->actual == pRequest->length || len < musb_ep->wPacketSize)
 		musb_g_giveback(musb_ep, pRequest, 0);
 }
 
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -943,7 +943,7 @@ static void musb_ep_program(struct musb *musb, u8 bEnd,
  * Return TRUE until it's time to start the status stage.
  */
 static int musb_h_ep0_continue(struct musb *musb,
-				u16 wCount, struct urb *pUrb)
+				u16 len, struct urb *pUrb)
 {
 	int			 bMore = FALSE;
 	u8 *pFifoDest = NULL;
@@ -955,15 +955,15 @@ static int musb_h_ep0_continue(struct musb *musb,
 	switch (musb->bEnd0Stage) {
 	case MGC_END0_IN:
 		pFifoDest = pUrb->transfer_buffer + pUrb->actual_length;
-		fifo_count = min(wCount, ((u16) (pUrb->transfer_buffer_length
+		fifo_count = min(len, ((u16) (pUrb->transfer_buffer_length
 					- pUrb->actual_length)));
-		if (fifo_count < wCount)
+		if (fifo_count < len)
 			pUrb->status = -EOVERFLOW;
 
 		musb_read_fifo(hw_ep, fifo_count, pFifoDest);
 
 		pUrb->actual_length += fifo_count;
-		if (wCount < qh->maxpacket) {
+		if (len < qh->maxpacket) {
 			/* always terminate on short read; it's
 			 * rarely reported as an error.
 			 */
@@ -1021,7 +1021,7 @@ static int musb_h_ep0_continue(struct musb *musb,
 irqreturn_t musb_h_ep0_irq(struct musb *musb)
 {
 	struct urb		*pUrb;
-	u16			wCsrVal, wCount;
+	u16			wCsrVal, len;
 	int			status = 0;
 	void __iomem		*mbase = musb->mregs;
 	struct musb_hw_ep	*hw_ep = musb->control_ep;
@@ -1035,12 +1035,12 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
 
 	MGC_SelectEnd(mbase, 0);
 	wCsrVal = musb_readw(epio, MGC_O_HDRC_CSR0);
-	wCount = (wCsrVal & MGC_M_CSR0_RXPKTRDY)
+	len = (wCsrVal & MGC_M_CSR0_RXPKTRDY)
 			? musb_readb(epio, MGC_O_HDRC_COUNT0)
 			: 0;
 
 	DBG(4, "<== csr0 %04x, qh %p, count %d, urb %p, stage %d\n",
-		wCsrVal, qh, wCount, pUrb, musb->bEnd0Stage);
+		wCsrVal, qh, len, pUrb, musb->bEnd0Stage);
 
 	/* if we just did status stage, we are done */
 	if (MGC_END0_STATUS == musb->bEnd0Stage) {
@@ -1112,7 +1112,7 @@ irqreturn_t musb_h_ep0_irq(struct musb *musb)
 
 	if (!bComplete) {
 		/* call common logic and prepare response */
-		if (musb_h_ep0_continue(musb, wCount, pUrb)) {
+		if (musb_h_ep0_continue(musb, len, pUrb)) {
 			/* more packets required */
 			wCsrVal = (MGC_END0_IN == musb->bEnd0Stage)
 				?  MGC_M_CSR0_H_REQPKT : MGC_M_CSR0_TXPKTRDY;
--- a/drivers/usb/musb/musbdefs.h
+++ b/drivers/usb/musb/musbdefs.h
@@ -500,9 +500,9 @@ extern void musb_start(struct musb *musb);
 extern void musb_stop(struct musb *musb);
 
 extern void musb_write_fifo(struct musb_hw_ep *ep,
-			     u16 wCount, const u8 * src);
+			     u16 len, const u8 * src);
 extern void musb_read_fifo(struct musb_hw_ep *ep,
-			       u16 wCount, u8 * dst);
+			       u16 len, u8 * dst);
 
 extern void musb_load_testpacket(struct musb *);
 
--- a/drivers/usb/musb/plat_uds.c
+++ b/drivers/usb/musb/plat_uds.c
@@ -169,14 +169,14 @@ static inline struct musb *dev_to_musb(struct device *dev)
 /*
  * Load an endpoint's FIFO
  */
-void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 wCount, const u8 *src)
+void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 {
 	void __iomem *fifo = hw_ep->fifo;
 
 	prefetch((u8 *)src);
 
 	DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
-			'T', hw_ep->bLocalEnd, fifo, wCount, src);
+			'T', hw_ep->bLocalEnd, fifo, len, src);
 
 	/* we can't assume unaligned reads work */
 	if (likely((0x01 & (unsigned long) src) == 0)) {
@@ -184,37 +184,37 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 wCount, const u8 *src)
 
 		/* best case is 32bit-aligned source address */
 		if ((0x02 & (unsigned long) src) == 0) {
-			if (wCount >= 4) {
-				writesl(fifo, src + index, wCount >> 2);
-				index += wCount & ~0x03;
+			if (len >= 4) {
+				writesl(fifo, src + index, len >> 2);
+				index += len & ~0x03;
 			}
-			if (wCount & 0x02) {
+			if (len & 0x02) {
 				musb_writew(fifo, 0, *(u16*)&src[index]);
 				index += 2;
 			}
 		} else {
-			if (wCount >= 2) {
-				writesw(fifo, src + index, wCount >> 1);
-				index += wCount & ~0x01;
+			if (len >= 2) {
+				writesw(fifo, src + index, len >> 1);
+				index += len & ~0x01;
 			}
 		}
-		if (wCount & 0x01)
+		if (len & 0x01)
 			musb_writeb(fifo, 0, src[index]);
 	} else  {
 		/* byte aligned */
-		writesb(fifo, src, wCount);
+		writesb(fifo, src, len);
 	}
 }
 
 /*
  * Unload an endpoint's FIFO
  */
-void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 wCount, u8 *dst)
+void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
 	void __iomem *fifo = hw_ep->fifo;
 
 	DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
-			'R', hw_ep->bLocalEnd, fifo, wCount, dst);
+			'R', hw_ep->bLocalEnd, fifo, len, dst);
 
 	/* we can't assume unaligned writes work */
 	if (likely((0x01 & (unsigned long) dst) == 0)) {
@@ -222,25 +222,25 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 wCount, u8 *dst)
 
 		/* best case is 32bit-aligned destination address */
 		if ((0x02 & (unsigned long) dst) == 0) {
-			if (wCount >= 4) {
-				readsl(fifo, dst, wCount >> 2);
-				index = wCount & ~0x03;
+			if (len >= 4) {
+				readsl(fifo, dst, len >> 2);
+				index = len & ~0x03;
 			}
-			if (wCount & 0x02) {
+			if (len & 0x02) {
 				*(u16*)&dst[index] = musb_readw(fifo, 0);
 				index += 2;
 			}
 		} else {
-			if (wCount >= 2) {
-				readsw(fifo, dst, wCount >> 1);
-				index = wCount & ~0x01;
+			if (len >= 2) {
+				readsw(fifo, dst, len >> 1);
+				index = len & ~0x01;
 			}
 		}
-		if (wCount & 0x01)
+		if (len & 0x01)
 			dst[index] = musb_readb(fifo, 0);
 	} else  {
 		/* byte aligned */
-		readsb(fifo, dst, wCount);
+		readsb(fifo, dst, len);
 	}
 }
 
-- 
1.5.2.3