7 files changed, 136 insertions, 60 deletions

diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index 351d48550c33..4095cce05e6a 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -704,8 +704,8 @@ static int queue_dma(struct usba_udc *udc, struct usba_ep *ep,
         unsigned long flags;
         int ret;
 
-        DBG(DBG_DMA, "%s: req l/%u d/%08x %c%c%c\n",
-                ep->ep.name, req->req.length, req->req.dma,
+        DBG(DBG_DMA, "%s: req l/%u d/%pad %c%c%c\n",
+                ep->ep.name, req->req.length, &req->req.dma,
                 req->req.zero ? 'Z' : 'z',
                 req->req.short_not_ok ? 'S' : 's',
                 req->req.no_interrupt ? 'I' : 'i');
@@ -2203,7 +2203,7 @@ static int usba_udc_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int usba_udc_suspend(struct device *dev)
 {
         struct usba_udc *udc = dev_get_drvdata(dev);
diff --git a/drivers/usb/gadget/udc/bdc/bdc_ep.c b/drivers/usb/gadget/udc/bdc/bdc_ep.c
index b04980cf6dc4..1efa61265d8d 100644
--- a/drivers/usb/gadget/udc/bdc/bdc_ep.c
+++ b/drivers/usb/gadget/udc/bdc/bdc_ep.c
@@ -779,7 +779,7 @@ static int ep_dequeue(struct bdc_ep *ep, struct bdc_req *req)
         /* The current hw dequeue pointer */
         tmp_32 = bdc_readl(bdc->regs, BDC_EPSTS0(0));
         deq_ptr_64 = tmp_32;
-        tmp_32 = bdc_readl(bdc->regs, BDC_EPSTS0(1));
+        tmp_32 = bdc_readl(bdc->regs, BDC_EPSTS1(0));
         deq_ptr_64 |= ((u64)tmp_32 << 32);
 
         /* we have the dma addr of next bd that will be fetched by hardware */
diff --git a/drivers/usb/gadget/udc/fotg210-udc.c b/drivers/usb/gadget/udc/fotg210-udc.c
index e547ea7f56b1..1137e3384218 100644
--- a/drivers/usb/gadget/udc/fotg210-udc.c
+++ b/drivers/usb/gadget/udc/fotg210-udc.c
@@ -1171,7 +1171,7 @@ static int fotg210_udc_probe(struct platform_device *pdev)
                           udc_name, fotg210);
         if (ret < 0) {
                 pr_err("request_irq error (%d)\n", ret);
-                goto err_irq;
+                goto err_req;
         }
 
         ret = usb_add_gadget_udc(&pdev->dev, &fotg210->gadget);
@@ -1183,7 +1183,6 @@ static int fotg210_udc_probe(struct platform_device *pdev)
         return 0;
 
 err_add_udc:
-err_irq:
         free_irq(ires->start, fotg210);
 
 err_req:
diff --git a/drivers/usb/gadget/udc/mv_udc_core.c b/drivers/usb/gadget/udc/mv_udc_core.c
index d32160d6463f..5da37c957b53 100644
--- a/drivers/usb/gadget/udc/mv_udc_core.c
+++ b/drivers/usb/gadget/udc/mv_udc_core.c
@@ -2167,7 +2167,7 @@ static int mv_udc_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        udc->phy_regs = ioremap(r->start, resource_size(r));
+        udc->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
         if (udc->phy_regs == NULL) {
                 dev_err(&pdev->dev, "failed to map phy I/O memory\n");
                 return -EBUSY;
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index 9871b90195ad..2bee912ca65b 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -123,6 +123,11 @@ static char *type_string(u8 bmAttributes)
 #define valid_bit       cpu_to_le32(BIT(VALID_BIT))
 #define dma_done_ie     cpu_to_le32(BIT(DMA_DONE_INTERRUPT_ENABLE))
 
+static void ep_clear_seqnum(struct net2280_ep *ep);
+static void stop_activity(struct net2280 *dev,
+                                        struct usb_gadget_driver *driver);
+static void ep0_start(struct net2280 *dev);
+
 /*-------------------------------------------------------------------------*/
 static inline void enable_pciirqenb(struct net2280_ep *ep)
 {
@@ -142,7 +147,9 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 {
         struct net2280          *dev;
         struct net2280_ep       *ep;
-        u32                     max, tmp;
+        u32                     max;
+        u32 tmp = 0;
+        u32 type;
         unsigned long           flags;
         static const u32 ep_key[9] = { 1, 0, 1, 0, 1, 1, 0, 1, 0 };
         int ret = 0;
@@ -198,15 +205,29 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 
         /* set type, direction, address; reset fifo counters */
         writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
-        tmp = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
-        if (tmp == USB_ENDPOINT_XFER_INT) {
+
+        if ((dev->quirks & PLX_SUPERSPEED) && dev->enhanced_mode) {
+                tmp = readl(&ep->cfg->ep_cfg);
+                /* If USB ep number doesn't match hardware ep number */
+                if ((tmp & 0xf) != usb_endpoint_num(desc)) {
+                        ret = -EINVAL;
+                        spin_unlock_irqrestore(&dev->lock, flags);
+                        goto print_err;
+                }
+                if (ep->is_in)
+                        tmp &= ~USB3380_EP_CFG_MASK_IN;
+                else
+                        tmp &= ~USB3380_EP_CFG_MASK_OUT;
+        }
+        type = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
+        if (type == USB_ENDPOINT_XFER_INT) {
                 /* erratum 0105 workaround prevents hs NYET */
                 if (dev->chiprev == 0100 &&
                                 dev->gadget.speed == USB_SPEED_HIGH &&
                                 !(desc->bEndpointAddress & USB_DIR_IN))
                         writel(BIT(CLEAR_NAK_OUT_PACKETS_MODE),
                                 &ep->regs->ep_rsp);
-        } else if (tmp == USB_ENDPOINT_XFER_BULK) {
+        } else if (type == USB_ENDPOINT_XFER_BULK) {
                 /* catch some particularly blatant driver bugs */
                 if ((dev->gadget.speed == USB_SPEED_SUPER && max != 1024) ||
                     (dev->gadget.speed == USB_SPEED_HIGH && max != 512) ||
@@ -216,10 +237,10 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                         goto print_err;
                 }
         }
-        ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
+        ep->is_iso = (type == USB_ENDPOINT_XFER_ISOC);
         /* Enable this endpoint */
         if (dev->quirks & PLX_LEGACY) {
-                tmp <<= ENDPOINT_TYPE;
+                tmp |= type << ENDPOINT_TYPE;
                 tmp |= desc->bEndpointAddress;
                 /* default full fifo lines */
                 tmp |= (4 << ENDPOINT_BYTE_COUNT);
@@ -228,17 +249,17 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
         } else {
                 /* In Legacy mode, only OUT endpoints are used */
                 if (dev->enhanced_mode && ep->is_in) {
-                        tmp <<= IN_ENDPOINT_TYPE;
+                        tmp |= type << IN_ENDPOINT_TYPE;
                         tmp |= BIT(IN_ENDPOINT_ENABLE);
-                        /* Not applicable to Legacy */
-                        tmp |= BIT(ENDPOINT_DIRECTION);
                 } else {
-                        tmp <<= OUT_ENDPOINT_TYPE;
+                        tmp |= type << OUT_ENDPOINT_TYPE;
                         tmp |= BIT(OUT_ENDPOINT_ENABLE);
                         tmp |= (ep->is_in << ENDPOINT_DIRECTION);
                 }
 
-                tmp |= usb_endpoint_num(desc);
+                tmp |= (4 << ENDPOINT_BYTE_COUNT);
+                if (!dev->enhanced_mode)
+                        tmp |= usb_endpoint_num(desc);
                 tmp |= (ep->ep.maxburst << MAX_BURST_SIZE);
         }
 
@@ -256,6 +277,8 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                         BIT(CLEAR_NAK_OUT_PACKETS_MODE), &ep->regs->ep_rsp);
         }
 
+        if (dev->quirks & PLX_SUPERSPEED)
+                ep_clear_seqnum(ep);
         writel(tmp, &ep->cfg->ep_cfg);
 
         /* enable irqs */
@@ -441,6 +464,13 @@ static void ep_reset_338x(struct net2280_regs __iomem *regs,
                BIT(DATA_PACKET_TRANSMITTED_INTERRUPT) |
                BIT(DATA_OUT_PING_TOKEN_INTERRUPT) |
                BIT(DATA_IN_TOKEN_INTERRUPT), &ep->regs->ep_stat);
+
+        tmp = readl(&ep->cfg->ep_cfg);
+        if (ep->is_in)
+                tmp &= ~USB3380_EP_CFG_MASK_IN;
+        else
+                tmp &= ~USB3380_EP_CFG_MASK_OUT;
+        writel(tmp, &ep->cfg->ep_cfg);
 }
 
 static void nuke(struct net2280_ep *);
@@ -1468,11 +1498,14 @@ static int net2280_pullup(struct usb_gadget *_gadget, int is_on)
         spin_lock_irqsave(&dev->lock, flags);
         tmp = readl(&dev->usb->usbctl);
         dev->softconnect = (is_on != 0);
-        if (is_on)
-                tmp |= BIT(USB_DETECT_ENABLE);
-        else
-                tmp &= ~BIT(USB_DETECT_ENABLE);
-        writel(tmp, &dev->usb->usbctl);
+        if (is_on) {
+                ep0_start(dev);
+                writel(tmp | BIT(USB_DETECT_ENABLE), &dev->usb->usbctl);
+        } else {
+                writel(tmp & ~BIT(USB_DETECT_ENABLE), &dev->usb->usbctl);
+                stop_activity(dev, dev->driver);
+        }
+
         spin_unlock_irqrestore(&dev->lock, flags);
 
         return 0;
@@ -1860,8 +1893,8 @@ static void defect7374_enable_data_eps_zero(struct net2280 *dev)
         tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_DIRECTION) |
                         (2 << OUT_ENDPOINT_TYPE) | (2 << IN_ENDPOINT_TYPE) |
                         ((dev->enhanced_mode) ?
-                         BIT(OUT_ENDPOINT_ENABLE) : BIT(ENDPOINT_ENABLE)) |
-                        BIT(IN_ENDPOINT_ENABLE));
+                         BIT(OUT_ENDPOINT_ENABLE) | BIT(IN_ENDPOINT_ENABLE) :
+                         BIT(ENDPOINT_ENABLE)));
 
         for (i = 1; i < 5; i++)
                 writel(tmp, &dev->ep[i].cfg->ep_cfg);
@@ -1975,9 +2008,15 @@ static void usb_reset_338x(struct net2280 *dev)
         /* clear old dma and irq state */
         for (tmp = 0; tmp < 4; tmp++) {
                 struct net2280_ep *ep = &dev->ep[tmp + 1];
+                struct net2280_dma_regs __iomem *dma;
 
-                if (ep->dma)
+                if (ep->dma) {
                         abort_dma(ep);
+                } else {
+                        dma = &dev->dma[tmp];
+                        writel(BIT(DMA_ABORT), &dma->dmastat);
+                        writel(0, &dma->dmactl);
+                }
         }
 
         writel(~0, &dev->regs->irqstat0), writel(~0, &dev->regs->irqstat1);
@@ -2065,6 +2104,12 @@ static void usb_reinit_338x(struct net2280 *dev)
 
                 if (dev->enhanced_mode) {
                         ep->cfg = &dev->epregs[ne[i]];
+                        /*
+                         * Set USB endpoint number, hardware allows same number
+                         * in both directions.
+                         */
+                         if (i > 0 && i < 5)
+                                writel(ne[i], &ep->cfg->ep_cfg);
                         ep->regs = (struct net2280_ep_regs __iomem *)
                                 (((void __iomem *)&dev->epregs[ne[i]]) +
                                 ep_reg_addr[i]);
@@ -2874,6 +2919,26 @@ next_endpoints3:
         return;
 }
 
+static void usb338x_handle_ep_intr(struct net2280 *dev, u32 stat0)
+{
+        u32 index;
+        u32 bit;
+
+        for (index = 0; index < ARRAY_SIZE(ep_bit); index++) {
+                bit = BIT(ep_bit[index]);
+
+                if (!stat0)
+                        break;
+
+                if (!(stat0 & bit))
+                        continue;
+
+                stat0 &= ~bit;
+
+                handle_ep_small(&dev->ep[index]);
+        }
+}
+
 static void handle_stat0_irqs(struct net2280 *dev, u32 stat)
 {
         struct net2280_ep       *ep;
@@ -3098,20 +3163,31 @@ do_stall:
 #undef  w_length
 
 next_endpoints:
-        /* endpoint data irq ? */
-        scratch = stat & 0x7f;
-        stat &= ~0x7f;
-        for (num = 0; scratch; num++) {
-                u32             t;
-
-                /* do this endpoint's FIFO and queue need tending? */
-                t = BIT(num);
-                if ((scratch & t) == 0)
-                        continue;
-                scratch ^= t;
+        if ((dev->quirks & PLX_SUPERSPEED) && dev->enhanced_mode) {
+                u32 mask = (BIT(ENDPOINT_0_INTERRUPT) |
+                        USB3380_IRQSTAT0_EP_INTR_MASK_IN |
+                        USB3380_IRQSTAT0_EP_INTR_MASK_OUT);
+
+                if (stat & mask) {
+                        usb338x_handle_ep_intr(dev, stat & mask);
+                        stat &= ~mask;
+                }
+        } else {
+                /* endpoint data irq ? */
+                scratch = stat & 0x7f;
+                stat &= ~0x7f;
+                for (num = 0; scratch; num++) {
+                        u32             t;
+
+                        /* do this endpoint's FIFO and queue need tending? */
+                        t = BIT(num);
+                        if ((scratch & t) == 0)
+                                continue;
+                        scratch ^= t;
 
-                ep = &dev->ep[num];
-                handle_ep_small(ep);
+                        ep = &dev->ep[num];
+                        handle_ep_small(ep);
+                }
         }
 
         if (stat)
diff --git a/drivers/usb/gadget/udc/s3c2410_udc.c b/drivers/usb/gadget/udc/s3c2410_udc.c
index 99fd9a5667df..5d9aa81969b4 100644
--- a/drivers/usb/gadget/udc/s3c2410_udc.c
+++ b/drivers/usb/gadget/udc/s3c2410_udc.c
@@ -92,40 +92,38 @@ static struct s3c2410_udc_mach_info *udc_info;
 
 static uint32_t s3c2410_ticks = 0;
 
-static int dprintk(int level, const char *fmt, ...)
+__printf(2, 3)
+static void dprintk(int level, const char *fmt, ...)
 {
-        static char printk_buf[1024];
         static long prevticks;
         static int invocation;
+        struct va_format vaf;
         va_list args;
-        int len;
 
         if (level > USB_S3C2410_DEBUG_LEVEL)
-                return 0;
+                return;
+
+        va_start(args, fmt);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
 
         if (s3c2410_ticks != prevticks) {
                 prevticks = s3c2410_ticks;
                 invocation = 0;
         }
 
-        len = scnprintf(printk_buf,
-                        sizeof(printk_buf), "%1lu.%02d USB: ",
-                        prevticks, invocation++);
+        pr_debug("%1lu.%02d USB: %pV", prevticks, invocation++, &vaf);
 
-        va_start(args, fmt);
-        len = vscnprintf(printk_buf+len,
-                        sizeof(printk_buf)-len, fmt, args);
         va_end(args);
-
-        pr_debug("%s", printk_buf);
-        return len;
 }
 #else
-static int dprintk(int level, const char *fmt, ...)
+__printf(2, 3)
+static void dprintk(int level, const char *fmt, ...)
 {
-        return 0;
 }
 #endif
+
 static int s3c2410_udc_debugfs_seq_show(struct seq_file *m, void *p)
 {
         u32 addr_reg, pwr_reg, ep_int_reg, usb_int_reg;
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c
index d69c35558f68..89ed5e71a199 100644
--- a/drivers/usb/gadget/udc/udc-core.c
+++ b/drivers/usb/gadget/udc/udc-core.c
@@ -60,13 +60,15 @@ static DEFINE_MUTEX(udc_lock);
 int usb_gadget_map_request(struct usb_gadget *gadget,
                 struct usb_request *req, int is_in)
 {
+        struct device *dev = gadget->dev.parent;
+
         if (req->length == 0)
                 return 0;
 
         if (req->num_sgs) {
                 int     mapped;
 
-                mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
+                mapped = dma_map_sg(dev, req->sg, req->num_sgs,
                                 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
                 if (mapped == 0) {
                         dev_err(&gadget->dev, "failed to map SGs\n");
@@ -75,11 +77,11 @@ int usb_gadget_map_request(struct usb_gadget *gadget,
 
                 req->num_mapped_sgs = mapped;
         } else {
-                req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
+                req->dma = dma_map_single(dev, req->buf, req->length,
                                 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 
-                if (dma_mapping_error(&gadget->dev, req->dma)) {
-                        dev_err(&gadget->dev, "failed to map buffer\n");
+                if (dma_mapping_error(dev, req->dma)) {
+                        dev_err(dev, "failed to map buffer\n");
                         return -EFAULT;
                 }
         }
@@ -95,12 +97,12 @@ void usb_gadget_unmap_request(struct usb_gadget *gadget,
                 return;
 
         if (req->num_mapped_sgs) {
-                dma_unmap_sg(&gadget->dev, req->sg, req->num_mapped_sgs,
+                dma_unmap_sg(gadget->dev.parent, req->sg, req->num_mapped_sgs,
                                 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
 
                 req->num_mapped_sgs = 0;
         } else {
-                dma_unmap_single(&gadget->dev, req->dma, req->length,
+                dma_unmap_single(gadget->dev.parent, req->dma, req->length,
                                 is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
         }
 }
@@ -321,6 +323,7 @@ err4:
 
 err3:
         put_device(&udc->dev);
+        device_del(&gadget->dev);
 
 err2:
         put_device(&gadget->dev);