checkpatch complains that the alignment should match with open
parenthesis.

Signed-off-by: Sudip Mukherjee <su...@vectorindia.org>
---
 drivers/usb/gadget/udc/amd5536udc.c | 156 ++++++++++++++++++------------------
 1 file changed, 78 insertions(+), 78 deletions(-)

diff --git a/drivers/usb/gadget/udc/amd5536udc.c 
b/drivers/usb/gadget/udc/amd5536udc.c
index 98b841d..9f73de8 100644
--- a/drivers/usb/gadget/udc/amd5536udc.c
+++ b/drivers/usb/gadget/udc/amd5536udc.c
@@ -226,7 +226,7 @@ module_param(use_dma_ppb, bool, S_IRUGO);
 MODULE_PARM_DESC(use_dma_ppb, "true for DMA in packet per buffer mode");
 module_param(use_dma_ppb_du, bool, S_IRUGO);
 MODULE_PARM_DESC(use_dma_ppb_du,
-       "true for DMA in packet per buffer mode with descriptor update");
+                "true for DMA in packet per buffer mode with descriptor 
update");
 module_param(use_fullspeed, bool, S_IRUGO);
 MODULE_PARM_DESC(use_fullspeed, "true for fullspeed only");
 
@@ -436,7 +436,7 @@ udc_ep_enable(struct usb_ep *usbep, const struct 
usb_endpoint_descriptor *desc)
                /* set max packet size UDC CSR  */
                tmp = readl(&dev->csr->ne[ep->num - UDC_CSR_EP_OUT_IX_OFS]);
                tmp = AMD_ADDBITS(tmp, maxpacket,
-                                       UDC_CSR_NE_MAX_PKT);
+                                 UDC_CSR_NE_MAX_PKT);
                writel(tmp, &dev->csr->ne[ep->num - UDC_CSR_EP_OUT_IX_OFS]);
 
                if (use_dma && !ep->in) {
@@ -581,7 +581,7 @@ udc_alloc_request(struct usb_ep *usbep, gfp_t gfp)
        if (ep->dma) {
                /* ep0 in requests are allocated from data pool here */
                dma_desc = pci_pool_alloc(ep->dev->data_requests, gfp,
-                                               &req->td_phys);
+                                         &req->td_phys);
                if (!dma_desc) {
                        kfree(req);
                        return NULL;
@@ -622,7 +622,7 @@ static int udc_free_dma_chain(struct udc *dev, struct 
udc_request *req)
        for (i = 1; i < req->chain_len; i++) {
 
                pci_pool_free(dev->data_requests, td,
-                               (dma_addr_t) td_last->next);
+                             (dma_addr_t) td_last->next);
                td_last = td;
                td = phys_to_virt(td_last->next);
        }
@@ -652,7 +652,7 @@ udc_free_request(struct usb_ep *usbep, struct usb_request 
*usbreq)
                        udc_free_dma_chain(ep->dev, req);
 
                pci_pool_free(ep->dev->data_requests, req->td_data,
-                                                       req->td_phys);
+                             req->td_phys);
        }
        kfree(req);
 }
@@ -672,7 +672,7 @@ static void udc_init_bna_dummy(struct udc_request *req)
                                        UDC_DMA_STP_STS_BS);
 #ifdef UDC_VERBOSE
                pr_debug("bna desc = %p, sts = %08x\n",
-                       req->td_data, req->td_data->status);
+                        req->td_data, req->td_data->status);
 #endif
        }
 }
@@ -723,7 +723,7 @@ udc_txfifo_write(struct udc_ep *ep, struct usb_request *req)
        /* remaining bytes must be written by byte access */
        for (j = 0; j < bytes % UDC_DWORD_BYTES; j++) {
                writeb((u8)(*(buf + i) >> (j << UDC_BITS_PER_BYTE_SHIFT)),
-                                                       ep->txfifo);
+                      ep->txfifo);
        }
 
        /* dummy write confirm */
@@ -784,7 +784,7 @@ udc_rxfifo_read(struct udc_ep *ep, struct udc_request *req)
        if (bytes > buf_space) {
                if ((buf_space % ep->ep.maxpacket) != 0) {
                        DBG(ep->dev,
-                               "%s: rx %d bytes, rx-buf space = %d bytesn\n",
+                           "%s: rx %d bytes, rx-buf space = %d bytesn\n",
                                ep->ep.name, bytes, buf_space);
                        req->req.status = -EOVERFLOW;
                }
@@ -821,7 +821,7 @@ static int udc_create_dma_chain(
        unsigned len;
 
        VDBG(ep->dev, "udc_create_dma_chain: bytes=%ld buf_len=%ld\n",
-                       bytes, buf_len);
+            bytes, buf_len);
        dma_addr = DMA_DONT_USE;
 
        /* unset L bit in first desc for OUT */
@@ -848,7 +848,7 @@ static int udc_create_dma_chain(
                if (create_new_chain) {
 
                        td = pci_pool_alloc(ep->dev->data_requests,
-                                       gfp_flags, &dma_addr);
+                                           gfp_flags, &dma_addr);
                        if (!td)
                                return -ENOMEM;
 
@@ -889,7 +889,7 @@ static int udc_create_dma_chain(
                                /* first desc */
                                req->td_data->status =
                                        AMD_ADDBITS(req->td_data->status,
-                                                       ep->ep.maxpacket,
+                                                   ep->ep.maxpacket,
                                                        UDC_DMA_IN_STS_TXBYTES);
                                /* second desc */
                                td->status = AMD_ADDBITS(td->status,
@@ -930,7 +930,7 @@ static int prep_dma(struct udc_ep *ep, struct udc_request 
*req, gfp_t gfp)
 
        VDBG(ep->dev, "prep_dma\n");
        VDBG(ep->dev, "prep_dma ep%d req->td_data=%p\n",
-                       ep->num, req->td_data);
+            ep->num, req->td_data);
 
        /* set buffer pointer */
        req->td_data->bufptr = req->req.dma;
@@ -952,7 +952,7 @@ static int prep_dma(struct udc_ep *ep, struct udc_request 
*req, gfp_t gfp)
                                /* write tx bytes */
                                req->td_data->status =
                                        AMD_ADDBITS(req->td_data->status,
-                                               ep->ep.maxpacket,
+                                                   ep->ep.maxpacket,
                                                UDC_DMA_IN_STS_TXBYTES);
 
                        }
@@ -975,25 +975,25 @@ static int prep_dma(struct udc_ep *ep, struct udc_request 
*req, gfp_t gfp)
                        /* write tx bytes */
                        req->td_data->status =
                                AMD_ADDBITS(req->td_data->status,
-                                               req->req.length,
+                                           req->req.length,
                                                UDC_DMA_IN_STS_TXBYTES);
                        /* reset frame num */
                        req->td_data->status =
                                AMD_ADDBITS(req->td_data->status,
-                                               0,
+                                           0,
                                                UDC_DMA_IN_STS_FRAMENUM);
                }
                /* set HOST BUSY */
                req->td_data->status =
                        AMD_ADDBITS(req->td_data->status,
-                               UDC_DMA_STP_STS_BS_HOST_BUSY,
+                                   UDC_DMA_STP_STS_BS_HOST_BUSY,
                                UDC_DMA_STP_STS_BS);
        } else {
                VDBG(ep->dev, "OUT set host ready\n");
                /* set HOST READY */
                req->td_data->status =
                        AMD_ADDBITS(req->td_data->status,
-                               UDC_DMA_STP_STS_BS_HOST_READY,
+                                   UDC_DMA_STP_STS_BS_HOST_READY,
                                UDC_DMA_STP_STS_BS);
 
                        /* clear NAK by writing CNAK */
@@ -1037,7 +1037,7 @@ __acquires(ep->dev->lock)
        list_del_init(&req->queue);
 
        VDBG(ep->dev, "req %p => complete %d bytes at %s with sts %d\n",
-               &req->req, req->req.length, ep->ep.name, sts);
+            &req->req, req->req.length, ep->ep.name, sts);
 
        spin_unlock(&dev->lock);
        usb_gadget_giveback_request(&ep->ep, &req->req);
@@ -1136,7 +1136,7 @@ udc_queue(struct usb_ep *usbep, struct usb_request 
*usbreq, gfp_t gfp)
        }
 
        VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
-                       usbep->name, usbreq, usbreq->length,
+            usbep->name, usbreq, usbreq->length,
                        req->td_data, usbreq->buf);
 
        spin_lock_irqsave(&dev->lock, iflags);
@@ -1169,7 +1169,7 @@ udc_queue(struct usb_ep *usbep, struct usb_request 
*usbreq, gfp_t gfp)
                                writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
                                dev->ep[UDC_EP0IN_IX].naking = 0;
                                UDC_QUEUE_CNAK(&dev->ep[UDC_EP0IN_IX],
-                                                       UDC_EP0IN_IX);
+                                              UDC_EP0IN_IX);
                                dev->waiting_zlp_ack_ep0in = 0;
                        }
                        goto finished;
@@ -1183,7 +1183,7 @@ udc_queue(struct usb_ep *usbep, struct usb_request 
*usbreq, gfp_t gfp)
                                /* set HOST READY */
                                req->td_data->status =
                                        AMD_ADDBITS(req->td_data->status,
-                                               UDC_DMA_IN_STS_BS_HOST_READY,
+                                                   
UDC_DMA_IN_STS_BS_HOST_READY,
                                                UDC_DMA_IN_STS_BS);
                        }
 
@@ -1207,7 +1207,7 @@ udc_queue(struct usb_ep *usbep, struct usb_request 
*usbreq, gfp_t gfp)
                                if (ep->bna_occurred) {
                                        VDBG(dev, "copy to BNA dummy desc.\n");
                                        memcpy(ep->bna_dummy_req->td_data,
-                                               req->td_data,
+                                              req->td_data,
                                                sizeof(struct udc_data_dma));
                                }
                        }
@@ -1294,7 +1294,7 @@ static void empty_req_queue(struct udc_ep *ep)
        ep->halted = 1;
        while (!list_empty(&ep->queue)) {
                req = list_entry(ep->queue.next,
-                       struct udc_request,
+                                struct udc_request,
                        queue);
                complete_req(ep, req, -ESHUTDOWN);
        }
@@ -1329,19 +1329,19 @@ static int udc_dequeue(struct usb_ep *usbep, struct 
usb_request *usbreq)
                                /* stop potential receive DMA */
                                tmp = readl(&udc->regs->ctl);
                                writel(tmp & AMD_UNMASK_BIT(UDC_DEVCTL_RDE),
-                                                       &udc->regs->ctl);
+                                      &udc->regs->ctl);
                                /*
                                 * Cancel transfer later in ISR
                                 * if descriptor was touched.
                                 */
                                dma_sts = AMD_GETBITS(req->td_data->status,
-                                                       UDC_DMA_OUT_STS_BS);
+                                                     UDC_DMA_OUT_STS_BS);
                                if (dma_sts != UDC_DMA_OUT_STS_BS_HOST_READY)
                                        ep->cancel_transfer = 1;
                                else {
                                        udc_init_bna_dummy(ep->req);
                                        writel(ep->bna_dummy_req->td_phys,
-                                               &ep->regs->desptr);
+                                              &ep->regs->desptr);
                                }
                                writel(tmp, &udc->regs->ctl);
                        }
@@ -1474,7 +1474,7 @@ static int udc_wakeup(struct usb_gadget *gadget)
 }
 
 static int amd5536_udc_start(struct usb_gadget *g,
-               struct usb_gadget_driver *driver);
+                            struct usb_gadget_driver *driver);
 static int amd5536_udc_stop(struct usb_gadget *g);
 
 static const struct usb_gadget_ops udc_ops = {
@@ -1490,11 +1490,11 @@ static void make_ep_lists(struct udc *dev)
        /* make gadget ep lists */
        INIT_LIST_HEAD(&dev->gadget.ep_list);
        list_add_tail(&dev->ep[UDC_EPIN_STATUS_IX].ep.ep_list,
-                                               &dev->gadget.ep_list);
+                     &dev->gadget.ep_list);
        list_add_tail(&dev->ep[UDC_EPIN_IX].ep.ep_list,
-                                               &dev->gadget.ep_list);
+                     &dev->gadget.ep_list);
        list_add_tail(&dev->ep[UDC_EPOUT_IX].ep.ep_list,
-                                               &dev->gadget.ep_list);
+                     &dev->gadget.ep_list);
 
        /* fifo config */
        dev->ep[UDC_EPIN_STATUS_IX].fifo_depth = UDC_EPIN_SMALLINT_BUFF_SIZE;
@@ -1721,7 +1721,7 @@ static void udc_tasklet_disconnect(unsigned long par)
 
        /* disable ep0 */
        ep_init(dev->regs,
-                       &dev->ep[UDC_EP0IN_IX]);
+               &dev->ep[UDC_EP0IN_IX]);
 
        if (!soft_reset_occured) {
                /* init controller by soft reset */
@@ -1897,40 +1897,40 @@ static void activate_control_endpoints(struct udc *dev)
        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->bufin_framenum);
        if (dev->gadget.speed == USB_SPEED_FULL)
                tmp = AMD_ADDBITS(tmp, UDC_FS_EPIN0_BUFF_SIZE,
-                                       UDC_EPIN_BUFF_SIZE);
+                                 UDC_EPIN_BUFF_SIZE);
        else if (dev->gadget.speed == USB_SPEED_HIGH)
                tmp = AMD_ADDBITS(tmp, UDC_EPIN0_BUFF_SIZE,
-                                       UDC_EPIN_BUFF_SIZE);
+                                 UDC_EPIN_BUFF_SIZE);
        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->bufin_framenum);
 
        /* set max packet size of EP0_IN */
        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->bufout_maxpkt);
        if (dev->gadget.speed == USB_SPEED_FULL)
                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0IN_MAX_PKT_SIZE,
-                                       UDC_EP_MAX_PKT_SIZE);
+                                 UDC_EP_MAX_PKT_SIZE);
        else if (dev->gadget.speed == USB_SPEED_HIGH)
                tmp = AMD_ADDBITS(tmp, UDC_EP0IN_MAX_PKT_SIZE,
-                               UDC_EP_MAX_PKT_SIZE);
+                                 UDC_EP_MAX_PKT_SIZE);
        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->bufout_maxpkt);
 
        /* set max packet size of EP0_OUT */
        tmp = readl(&dev->ep[UDC_EP0OUT_IX].regs->bufout_maxpkt);
        if (dev->gadget.speed == USB_SPEED_FULL)
                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0OUT_MAX_PKT_SIZE,
-                                       UDC_EP_MAX_PKT_SIZE);
+                                 UDC_EP_MAX_PKT_SIZE);
        else if (dev->gadget.speed == USB_SPEED_HIGH)
                tmp = AMD_ADDBITS(tmp, UDC_EP0OUT_MAX_PKT_SIZE,
-                                       UDC_EP_MAX_PKT_SIZE);
+                                 UDC_EP_MAX_PKT_SIZE);
        writel(tmp, &dev->ep[UDC_EP0OUT_IX].regs->bufout_maxpkt);
 
        /* set max packet size of EP0 in UDC CSR */
        tmp = readl(&dev->csr->ne[0]);
        if (dev->gadget.speed == USB_SPEED_FULL)
                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0OUT_MAX_PKT_SIZE,
-                                       UDC_CSR_NE_MAX_PKT);
+                                 UDC_CSR_NE_MAX_PKT);
        else if (dev->gadget.speed == USB_SPEED_HIGH)
                tmp = AMD_ADDBITS(tmp, UDC_EP0OUT_MAX_PKT_SIZE,
-                                       UDC_CSR_NE_MAX_PKT);
+                                 UDC_CSR_NE_MAX_PKT);
        writel(tmp, &dev->csr->ne[0]);
 
        if (use_dma) {
@@ -1938,9 +1938,9 @@ static void activate_control_endpoints(struct udc *dev)
                        AMD_BIT(UDC_DMA_OUT_STS_L);
                /* write dma desc address */
                writel(dev->ep[UDC_EP0OUT_IX].td_stp_dma,
-                       &dev->ep[UDC_EP0OUT_IX].regs->subptr);
+                      &dev->ep[UDC_EP0OUT_IX].regs->subptr);
                writel(dev->ep[UDC_EP0OUT_IX].td_phys,
-                       &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                      &dev->ep[UDC_EP0OUT_IX].regs->desptr);
                /* stop RDE timer */
                if (timer_pending(&udc_timer)) {
                        set_rde = 0;
@@ -1990,7 +1990,7 @@ static int setup_ep0(struct udc *dev)
 
 /* Called by gadget driver to register itself */
 static int amd5536_udc_start(struct usb_gadget *g,
-               struct usb_gadget_driver *driver)
+                            struct usb_gadget_driver *driver)
 {
        struct udc *dev = to_amd5536_udc(g);
        u32 tmp;
@@ -2084,7 +2084,7 @@ static void udc_process_cnak_queue(struct udc *dev)
                writel(reg, &dev->ep[UDC_EP0OUT_IX].regs->ctl);
                dev->ep[UDC_EP0OUT_IX].naking = 0;
                UDC_QUEUE_CNAK(&dev->ep[UDC_EP0OUT_IX],
-                               dev->ep[UDC_EP0OUT_IX].num);
+                              dev->ep[UDC_EP0OUT_IX].num);
        }
 }
 
@@ -2133,7 +2133,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                /* BNA event ? */
                if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
                        DBG(dev, "BNA ep%dout occurred - DESPTR = %x\n",
-                                       ep->num, readl(&ep->regs->desptr));
+                           ep->num, readl(&ep->regs->desptr));
                        /* clear BNA */
                        writel(tmp | AMD_BIT(UDC_EPSTS_BNA), &ep->regs->sts);
                        if (!ep->cancel_transfer)
@@ -2158,7 +2158,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
 
                /* next request */
                req = list_entry(ep->queue.next,
-                       struct udc_request, queue);
+                                struct udc_request, queue);
        } else {
                req = NULL;
                udc_rxfifo_pending = 1;
@@ -2176,7 +2176,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                        /* next request */
                        if (!list_empty(&ep->queue) && !ep->halted) {
                                req = list_entry(ep->queue.next,
-                                       struct udc_request, queue);
+                                                struct udc_request, queue);
                        } else
                                req = NULL;
                }
@@ -2188,7 +2188,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                /* check for DMA done */
                if (!use_dma_ppb) {
                        dma_done = AMD_GETBITS(req->td_data->status,
-                                               UDC_DMA_OUT_STS_BS);
+                                              UDC_DMA_OUT_STS_BS);
                /* packet per buffer mode - rx bytes */
                } else {
                        /*
@@ -2198,7 +2198,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                        if (ep->bna_occurred) {
                                VDBG(dev, "Recover desc. from BNA dummy\n");
                                memcpy(req->td_data, ep->bna_dummy_req->td_data,
-                                               sizeof(struct udc_data_dma));
+                                      sizeof(struct udc_data_dma));
                                ep->bna_occurred = 0;
                                udc_init_bna_dummy(ep->req);
                        }
@@ -2210,7 +2210,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                        if (!use_dma_ppb) {
                                /* received number bytes */
                                count = AMD_GETBITS(req->td_data->status,
-                                               UDC_DMA_OUT_STS_RXBYTES);
+                                                   UDC_DMA_OUT_STS_RXBYTES);
                                VDBG(dev, "rx bytes=%u\n", count);
                        /* packet per buffer mode - rx bytes */
                        } else {
@@ -2223,7 +2223,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                                } else {
                                        /* last desc. counts bytes */
                                        count = AMD_GETBITS(td->status,
-                                               UDC_DMA_OUT_STS_RXBYTES);
+                                                           
UDC_DMA_OUT_STS_RXBYTES);
                                        if (!count && req->req.length
                                                == UDC_DMA_MAXPACKET) {
                                                /*
@@ -2240,7 +2240,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                        if (count > tmp) {
                                if ((tmp % ep->ep.maxpacket) != 0) {
                                        DBG(dev, "%s: rx %db, space=%db\n",
-                                               ep->ep.name, count, tmp);
+                                           ep->ep.name, count, tmp);
                                        req->req.status = -EOVERFLOW;
                                }
                                count = tmp;
@@ -2253,7 +2253,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                        /* next request */
                        if (!list_empty(&ep->queue) && !ep->halted) {
                                req = list_entry(ep->queue.next,
-                                       struct udc_request,
+                                                struct udc_request,
                                        queue);
                                /*
                                 * DMA may be already started by udc_queue()
@@ -2267,7 +2267,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                                                goto finished;
                                        /* write desc pointer */
                                        writel(req->td_phys,
-                                               &ep->regs->desptr);
+                                              &ep->regs->desptr);
                                        req->dma_going = 1;
                                        /* enable DMA */
                                        udc_set_rde(dev);
@@ -2280,7 +2280,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int 
ep_ix)
                                if (ep->bna_dummy_req) {
                                        /* write desc pointer */
                                        writel(ep->bna_dummy_req->td_phys,
-                                               &ep->regs->desptr);
+                                              &ep->regs->desptr);
                                        ep->bna_occurred = 0;
                                }
 
@@ -2375,7 +2375,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int 
ep_ix)
                ret_val = IRQ_HANDLED;
                if (!ep->cancel_transfer && !list_empty(&ep->queue)) {
                        req = list_entry(ep->queue.next,
-                                       struct udc_request, queue);
+                                        struct udc_request, queue);
                        /*
                         * length bytes transferred
                         * check dma done of last desc. in PPBDU mode
@@ -2385,7 +2385,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int 
ep_ix)
                                if (td) {
                                        dma_done =
                                                AMD_GETBITS(td->status,
-                                               UDC_DMA_IN_STS_BS);
+                                                           UDC_DMA_IN_STS_BS);
                                        /* don't care DMA done */
                                        req->req.actual = req->req.length;
                                }
@@ -2420,7 +2420,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int 
ep_ix)
                if (!list_empty(&ep->queue)) {
                        /* next request */
                        req = list_entry(ep->queue.next,
-                                       struct udc_request, queue);
+                                        struct udc_request, queue);
                        /* FIFO mode */
                        if (!use_dma) {
                                /* write fifo */
@@ -2437,7 +2437,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int 
ep_ix)
                        /* DMA */
                        } else if (req && !req->dma_going) {
                                VDBG(dev, "IN DMA : req=%p req->td_data=%p\n",
-                                       req, req->td_data);
+                                    req, req->td_data);
                                if (req->td_data) {
 
                                        req->dma_going = 1;
@@ -2476,7 +2476,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int 
ep_ix)
                                &dev->regs->ep_irqmsk);
                        tmp |= AMD_BIT(ep->num);
                        writel(tmp,
-                               &dev->regs->ep_irqmsk);
+                              &dev->regs->ep_irqmsk);
                }
        }
        /* clear status bits */
@@ -2510,7 +2510,7 @@ __acquires(dev->lock)
        if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
                VDBG(dev, "ep0: BNA set\n");
                writel(AMD_BIT(UDC_EPSTS_BNA),
-                       &dev->ep[UDC_EP0OUT_IX].regs->sts);
+                      &dev->ep[UDC_EP0OUT_IX].regs->sts);
                ep->bna_occurred = 1;
                ret_val = IRQ_HANDLED;
                goto finished;
@@ -2537,7 +2537,7 @@ __acquires(dev->lock)
 
                        /* clear OUT bits in ep status */
                        writel(UDC_EPSTS_OUT_CLEAR,
-                               &dev->ep[UDC_EP0OUT_IX].regs->sts);
+                              &dev->ep[UDC_EP0OUT_IX].regs->sts);
 
                        setup_data.data[0] =
                                dev->ep[UDC_EP0OUT_IX].td_stp->data12;
@@ -2566,7 +2566,7 @@ __acquires(dev->lock)
                        if (ep->bna_dummy_req) {
                                /* write desc pointer */
                                writel(ep->bna_dummy_req->td_phys,
-                                       &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                                      &dev->ep[UDC_EP0OUT_IX].regs->desptr);
                                ep->bna_occurred = 0;
                        }
 
@@ -2639,7 +2639,7 @@ __acquires(dev->lock)
                if (!use_dma) {
                        /* clear OUT bits in ep status */
                        writel(UDC_EPSTS_OUT_CLEAR,
-                               &dev->ep[UDC_EP0OUT_IX].regs->sts);
+                              &dev->ep[UDC_EP0OUT_IX].regs->sts);
                }
 
        /* data packet 0 bytes */
@@ -2668,7 +2668,7 @@ __acquires(dev->lock)
                                ret_val |= udc_data_out_isr(dev, UDC_EP0OUT_IX);
                                /* re-program desc. pointer for possible ZLPs */
                                writel(dev->ep[UDC_EP0OUT_IX].td_phys,
-                                       &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                                      &dev->ep[UDC_EP0OUT_IX].regs->desptr);
                                /* enable RDE */
                                udc_ep0_set_rde(dev);
                        }
@@ -2724,7 +2724,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
 
                /* clear TDC bit */
                writel(AMD_BIT(UDC_EPSTS_TDC),
-                               &dev->ep[UDC_EP0IN_IX].regs->sts);
+                      &dev->ep[UDC_EP0IN_IX].regs->sts);
 
        /* status reg has IN bit set ? */
        } else if (tmp & AMD_BIT(UDC_EPSTS_IN)) {
@@ -2733,7 +2733,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
                if (ep->dma) {
                        /* clear IN bit */
                        writel(AMD_BIT(UDC_EPSTS_IN),
-                               &dev->ep[UDC_EP0IN_IX].regs->sts);
+                              &dev->ep[UDC_EP0IN_IX].regs->sts);
                }
                if (dev->stall_ep0in) {
                        DBG(dev, "stall ep0in\n");
@@ -2745,7 +2745,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
                        if (!list_empty(&ep->queue)) {
                                /* next request */
                                req = list_entry(ep->queue.next,
-                                               struct udc_request, queue);
+                                                struct udc_request, queue);
 
                                if (ep->dma) {
                                        /* write desc pointer */
@@ -2762,7 +2762,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
                                        readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
                                        tmp |= AMD_BIT(UDC_EPCTL_P);
                                        writel(tmp,
-                                       &dev->ep[UDC_EP0IN_IX].regs->ctl);
+                                              
&dev->ep[UDC_EP0IN_IX].regs->ctl);
 
                                        /* all bytes will be transferred */
                                        req->req.actual = req->req.length;
@@ -2794,7 +2794,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
                if (!ep->dma) {
                        /* clear IN bit */
                        writel(AMD_BIT(UDC_EPSTS_IN),
-                               &dev->ep[UDC_EP0IN_IX].regs->sts);
+                              &dev->ep[UDC_EP0IN_IX].regs->sts);
                }
        }
 
@@ -2846,7 +2846,7 @@ __acquires(dev->lock)
                        tmp = readl(&dev->csr->ne[udc_csr_epix]);
                        /* ep cfg */
                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_config,
-                                               UDC_CSR_NE_CFG);
+                                         UDC_CSR_NE_CFG);
                        /* write reg */
                        writel(tmp, &dev->csr->ne[udc_csr_epix]);
 
@@ -2879,7 +2879,7 @@ __acquires(dev->lock)
                setup_data.request.wIndex = cpu_to_le16(dev->cur_intf);
 
                DBG(dev, "SET_INTERFACE interrupt: alt=%d intf=%d\n",
-                               dev->cur_alt, dev->cur_intf);
+                   dev->cur_alt, dev->cur_intf);
 
                /* programm the NE registers */
                for (i = 0; i < UDC_EP_NUM; i++) {
@@ -2900,11 +2900,11 @@ __acquires(dev->lock)
                        tmp = readl(&dev->csr->ne[udc_csr_epix]);
                        /* ep interface */
                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_intf,
-                                               UDC_CSR_NE_INTF);
+                                         UDC_CSR_NE_INTF);
                        /* tmp = AMD_ADDBITS(tmp, 2, UDC_CSR_NE_INTF); */
                        /* ep alt */
                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_alt,
-                                               UDC_CSR_NE_ALT);
+                                         UDC_CSR_NE_ALT);
                        /* write reg */
                        writel(tmp, &dev->csr->ne[udc_csr_epix]);
 
@@ -3137,7 +3137,7 @@ static void udc_pci_remove(struct pci_dev *pdev)
        free_irq(pdev->irq, dev);
        iounmap(dev->virt_addr);
        release_mem_region(pci_resource_start(pdev, 0),
-                               pci_resource_len(pdev, 0));
+                          pci_resource_len(pdev, 0));
        pci_disable_device(pdev);
 
        udc_remove(dev);
@@ -3188,7 +3188,7 @@ static int init_dma_pools(struct udc *dev)
 
        /* data: 0 packets !? */
        td_data = dma_pool_alloc(dev->stp_requests, GFP_KERNEL,
-                               &dev->ep[UDC_EP0OUT_IX].td_phys);
+                                &dev->ep[UDC_EP0OUT_IX].td_phys);
        if (!td_data) {
                retval = -ENOMEM;
                goto err_alloc_phys;
@@ -3233,7 +3233,7 @@ static int udc_probe(struct udc *dev)
 
        snprintf(tmp, sizeof tmp, "%d", dev->irq);
        dev_info(&dev->pdev->dev,
-               "irq %s, pci mem %08lx, chip rev %02x(Geode5536 %s)\n",
+                "irq %s, pci mem %08lx, chip rev %02x(Geode5536 %s)\n",
                tmp, dev->phys_addr, dev->chiprev,
                (dev->chiprev == UDC_HSA0_REV) ? "A0" : "B1");
        strcpy(tmp, UDC_DRIVER_VERSION_STRING);
@@ -3243,11 +3243,11 @@ static int udc_probe(struct udc *dev)
                goto finished;
        }
        dev_info(&dev->pdev->dev,
-               "driver version: %s(for Geode5536 B1)\n", tmp);
+                "driver version: %s(for Geode5536 B1)\n", tmp);
        udc = dev;
 
        retval = usb_add_gadget_udc_release(&udc->pdev->dev, &dev->gadget,
-                       gadget_release);
+                                           gadget_release);
        if (retval)
                goto finished;
 
-- 
1.9.1

--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to