musb_hdrc: Search and replace wCount with len

Search and replace wCount with len

Signed-off-by: Tony Lindgren <tony@atomide.com>

diff --git a/drivers/usb/musb/g_ep0.c b/drivers/usb/musb/g_ep0.c
index b424dc0413083ee0c9fe0d47ee06258fcd745a84..b8cdc1837501cdd09c822cf1a82643a5bd3cfdec 100644 (file)
--- 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);

diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index dc22de2d121b837679b7da031da2c427c2ce23c6..85808ec7eff595012f5142939b1f801654698e71 100644 (file)
--- 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);
 }
 

diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index e74b8a211ad8c972204599b0acf05628ce136a0e..ffd8ed181ad586f73a021bc45ea8df8e44162323 100644 (file)
--- 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;

diff --git a/drivers/usb/musb/musbdefs.h b/drivers/usb/musb/musbdefs.h
index b612f1f4afe00767ec7a610871c6d672aebf9cb8..3505be25de221848cbb7712027ea15b32b7cc89f 100644 (file)
--- 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 *);
 

diff --git a/drivers/usb/musb/plat_uds.c b/drivers/usb/musb/plat_uds.c
index 2218c62c4ff4485a2f431438d04da5e89458a95c..7582a89ff0a76d43dcb49460216e9052ebe253c2 100644 (file)
--- 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);
        }
 }