Merge tag 'usb-for-v3.15' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-next

Felipe writes:

usb: patches for v3.15

another substantial pull request with new features all over
the place.

dwc3 got a bit closer towards hibernation support with after
a few patches re-factoring code to be reused for hibernation.
Also in dwc3 two new workarounds for known silicon bugs have
been implemented, some randconfig build errors have been fixed,
and it was taught about the new generic phy layer.

MUSB on AM335x now supports isochronous transfers thanks to
George Cherian's work.

The atmel_usba driver got two crash fixes: one when no endpoint
was specified in DeviceTree data and another when stopping the UDC
in DEBUG builds.

Function FS got a much needed fix to ffs_epfile_io() which was
copying too much data to userspace in some cases.

The printer gadget got a fix for a possible deadlock and plugged
a memory leak.

Ethernet drivers now use NAPI for RX which gives improved throughput.

Other than that, the usual miscelaneous fixes, cleanups, and
the like.

Signed-of-by: Felipe Balbi <balbi@ti.com>

5 files changed, 153 insertions, 11 deletions

diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 688dc8bb192d..8b789792f6fa 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -43,6 +43,7 @@ config USB_MUSB_HOST
 config USB_MUSB_GADGET
         bool "Gadget only mode"
         depends on USB_GADGET=y || USB_GADGET=USB_MUSB_HDRC
+        depends on HAS_DMA
         help
           Select this when you want to use MUSB in gadget mode only,
           thereby the host feature will be regressed.
@@ -50,6 +51,7 @@ config USB_MUSB_GADGET
 config USB_MUSB_DUAL_ROLE
         bool "Dual Role mode"
         depends on ((USB=y || USB=USB_MUSB_HDRC) && (USB_GADGET=y || USB_GADGET=USB_MUSB_HDRC))
+        depends on HAS_DMA
         help
           This is the default mode of working of MUSB controller where
           both host and gadget features are enabled.
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 239ad0b1ceb6..07576907e2c6 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -438,7 +438,6 @@ void musb_hnp_stop(struct musb *musb)
 static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 u8 devctl)
 {
-        struct usb_otg *otg = musb->xceiv->otg;
         irqreturn_t handled = IRQ_NONE;
 
         dev_dbg(musb->controller, "<== DevCtl=%02x, int_usb=0x%x\n", devctl,
@@ -656,7 +655,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 break;
                 case OTG_STATE_B_PERIPHERAL:
                         musb_g_suspend(musb);
-                        musb->is_active = otg->gadget->b_hnp_enable;
+                        musb->is_active = musb->g.b_hnp_enable;
                         if (musb->is_active) {
                                 musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                                 dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
@@ -672,7 +671,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         break;
                 case OTG_STATE_A_HOST:
                         musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                        musb->is_active = otg->host->b_hnp_enable;
+                        musb->is_active = musb->hcd->self.b_hnp_enable;
                         break;
                 case OTG_STATE_B_HOST:
                         /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index f88929609bac..7b8bbf53127e 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -39,6 +39,7 @@ struct cppi41_dma_channel {
         u32 transferred;
         u32 packet_sz;
         struct list_head tx_check;
+        struct work_struct dma_completion;
 };
 
 #define MUSB_DMA_NUM_CHANNELS 15
@@ -112,6 +113,18 @@ static bool musb_is_tx_fifo_empty(struct musb_hw_ep *hw_ep)
         return true;
 }
 
+static bool is_isoc(struct musb_hw_ep *hw_ep, bool in)
+{
+        if (in && hw_ep->in_qh) {
+                if (hw_ep->in_qh->type == USB_ENDPOINT_XFER_ISOC)
+                        return true;
+        } else if (hw_ep->out_qh) {
+                if (hw_ep->out_qh->type == USB_ENDPOINT_XFER_ISOC)
+                        return true;
+        }
+        return false;
+}
+
 static void cppi41_dma_callback(void *private_data);
 
 static void cppi41_trans_done(struct cppi41_dma_channel *cppi41_channel)
@@ -119,7 +132,8 @@ static void cppi41_trans_done(struct cppi41_dma_channel *cppi41_channel)
         struct musb_hw_ep *hw_ep = cppi41_channel->hw_ep;
         struct musb *musb = hw_ep->musb;
 
-        if (!cppi41_channel->prog_len) {
+        if (!cppi41_channel->prog_len ||
+            (cppi41_channel->channel.status == MUSB_DMA_STATUS_FREE)) {
 
                 /* done, complete */
                 cppi41_channel->channel.actual_len =
@@ -165,6 +179,32 @@ static void cppi41_trans_done(struct cppi41_dma_channel *cppi41_channel)
         }
 }
 
+static void cppi_trans_done_work(struct work_struct *work)
+{
+        unsigned long flags;
+        struct cppi41_dma_channel *cppi41_channel =
+                container_of(work, struct cppi41_dma_channel, dma_completion);
+        struct cppi41_dma_controller *controller = cppi41_channel->controller;
+        struct musb *musb = controller->musb;
+        struct musb_hw_ep *hw_ep = cppi41_channel->hw_ep;
+        bool empty;
+
+        if (!cppi41_channel->is_tx && is_isoc(hw_ep, 1)) {
+                spin_lock_irqsave(&musb->lock, flags);
+                cppi41_trans_done(cppi41_channel);
+                spin_unlock_irqrestore(&musb->lock, flags);
+        } else {
+                empty = musb_is_tx_fifo_empty(hw_ep);
+                if (empty) {
+                        spin_lock_irqsave(&musb->lock, flags);
+                        cppi41_trans_done(cppi41_channel);
+                        spin_unlock_irqrestore(&musb->lock, flags);
+                } else {
+                        schedule_work(&cppi41_channel->dma_completion);
+                }
+        }
+}
+
 static enum hrtimer_restart cppi41_recheck_tx_req(struct hrtimer *timer)
 {
         struct cppi41_dma_controller *controller;
@@ -228,6 +268,14 @@ static void cppi41_dma_callback(void *private_data)
                         transferred < cppi41_channel->packet_sz)
                 cppi41_channel->prog_len = 0;
 
+        if (!cppi41_channel->is_tx) {
+                if (is_isoc(hw_ep, 1))
+                        schedule_work(&cppi41_channel->dma_completion);
+                else
+                        cppi41_trans_done(cppi41_channel);
+                goto out;
+        }
+
         empty = musb_is_tx_fifo_empty(hw_ep);
         if (empty) {
                 cppi41_trans_done(cppi41_channel);
@@ -264,6 +312,10 @@ static void cppi41_dma_callback(void *private_data)
                                 goto out;
                         }
                 }
+                if (is_isoc(hw_ep, 0)) {
+                        schedule_work(&cppi41_channel->dma_completion);
+                        goto out;
+                }
                 list_add_tail(&cppi41_channel->tx_check,
                                 &controller->early_tx_list);
                 if (!hrtimer_active(&controller->early_tx)) {
@@ -448,12 +500,25 @@ static int cppi41_dma_channel_program(struct dma_channel *channel,
                                 dma_addr_t dma_addr, u32 len)
 {
         int ret;
+        struct cppi41_dma_channel *cppi41_channel = channel->private_data;
+        int hb_mult = 0;
 
         BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN ||
                 channel->status == MUSB_DMA_STATUS_BUSY);
 
+        if (is_host_active(cppi41_channel->controller->musb)) {
+                if (cppi41_channel->is_tx)
+                        hb_mult = cppi41_channel->hw_ep->out_qh->hb_mult;
+                else
+                        hb_mult = cppi41_channel->hw_ep->in_qh->hb_mult;
+        }
+
         channel->status = MUSB_DMA_STATUS_BUSY;
         channel->actual_len = 0;
+
+        if (hb_mult)
+                packet_sz = hb_mult * (packet_sz & 0x7FF);
+
         ret = cppi41_configure_channel(channel, packet_sz, mode, dma_addr, len);
         if (!ret)
                 channel->status = MUSB_DMA_STATUS_FREE;
@@ -607,6 +672,8 @@ static int cppi41_dma_controller_start(struct cppi41_dma_controller *controller)
                 cppi41_channel->port_num = port;
                 cppi41_channel->is_tx = is_tx;
                 INIT_LIST_HEAD(&cppi41_channel->tx_check);
+                INIT_WORK(&cppi41_channel->dma_completion,
+                          cppi_trans_done_work);
 
                 musb_dma = &cppi41_channel->channel;
                 musb_dma->private_data = cppi41_channel;
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 7a109eae9b9a..3372ded5def7 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -45,6 +45,8 @@
 #include <linux/of_irq.h>
 #include <linux/usb/of.h>
 
+#include <linux/debugfs.h>
+
 #include "musb_core.h"
 
 static const struct of_device_id musb_dsps_of_match[];
@@ -136,6 +138,26 @@ struct dsps_glue {
         unsigned long last_timer;    /* last timer data for each instance */
 
         struct dsps_context context;
+        struct debugfs_regset32 regset;
+        struct dentry *dbgfs_root;
+};
+
+static const struct debugfs_reg32 dsps_musb_regs[] = {
+        { "revision",           0x00 },
+        { "control",            0x14 },
+        { "status",             0x18 },
+        { "eoi",                0x24 },
+        { "intr0_stat",         0x30 },
+        { "intr1_stat",         0x34 },
+        { "intr0_set",          0x38 },
+        { "intr1_set",          0x3c },
+        { "txmode",             0x70 },
+        { "rxmode",             0x74 },
+        { "autoreq",            0xd0 },
+        { "srpfixtime",         0xd4 },
+        { "tdown",              0xd8 },
+        { "phy_utmi",           0xe0 },
+        { "mode",               0xe8 },
 };
 
 static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
@@ -368,6 +390,30 @@ out:
         return ret;
 }
 
+static int dsps_musb_dbg_init(struct musb *musb, struct dsps_glue *glue)
+{
+        struct dentry *root;
+        struct dentry *file;
+        char buf[128];
+
+        sprintf(buf, "%s.dsps", dev_name(musb->controller));
+        root = debugfs_create_dir(buf, NULL);
+        if (!root)
+                return -ENOMEM;
+        glue->dbgfs_root = root;
+
+        glue->regset.regs = dsps_musb_regs;
+        glue->regset.nregs = ARRAY_SIZE(dsps_musb_regs);
+        glue->regset.base = musb->ctrl_base;
+
+        file = debugfs_create_regset32("regdump", S_IRUGO, root, &glue->regset);
+        if (!file) {
+                debugfs_remove_recursive(root);
+                return -ENOMEM;
+        }
+        return 0;
+}
+
 static int dsps_musb_init(struct musb *musb)
 {
         struct device *dev = musb->controller;
@@ -377,6 +423,7 @@ static int dsps_musb_init(struct musb *musb)
         void __iomem *reg_base;
         struct resource *r;
         u32 rev, val;
+        int ret;
 
         r = platform_get_resource_byname(parent, IORESOURCE_MEM, "control");
         if (!r)
@@ -410,6 +457,10 @@ static int dsps_musb_init(struct musb *musb)
         val &= ~(1 << wrp->otg_disable);
         dsps_writel(musb->ctrl_base, wrp->phy_utmi, val);
 
+        ret = dsps_musb_dbg_init(musb, glue);
+        if (ret)
+                return ret;
+
         return 0;
 }
 
@@ -616,7 +667,7 @@ static int dsps_probe(struct platform_device *pdev)
         wrp = match->data;
 
         /* allocate glue */
-        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
         if (!glue) {
                 dev_err(&pdev->dev, "unable to allocate glue memory\n");
                 return -ENOMEM;
@@ -644,7 +695,6 @@ err3:
         pm_runtime_put(&pdev->dev);
 err2:
         pm_runtime_disable(&pdev->dev);
-        kfree(glue);
         return ret;
 }
 
@@ -657,7 +707,9 @@ static int dsps_remove(struct platform_device *pdev)
         /* disable usbss clocks */
         pm_runtime_put(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
-        kfree(glue);
+
+        debugfs_remove_recursive(glue->dbgfs_root);
+
         return 0;
 }
 
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index abb38c3833ef..eb06291a40c8 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -1694,7 +1694,8 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         | MUSB_RXCSR_RXPKTRDY);
                 musb_writew(hw_ep->regs, MUSB_RXCSR, val);
 
-#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA)
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA) || \
+        defined(CONFIG_USB_TI_CPPI41_DMA)
                 if (usb_pipeisoc(pipe)) {
                         struct usb_iso_packet_descriptor *d;
 
@@ -1707,10 +1708,30 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         if (d->status != -EILSEQ && d->status != -EOVERFLOW)
                                 d->status = 0;
 
-                        if (++qh->iso_idx >= urb->number_of_packets)
+                        if (++qh->iso_idx >= urb->number_of_packets) {
                                 done = true;
-                        else
+                        } else {
+#if defined(CONFIG_USB_TI_CPPI41_DMA)
+                                struct dma_controller   *c;
+                                dma_addr_t *buf;
+                                u32 length, ret;
+
+                                c = musb->dma_controller;
+                                buf = (void *)
+                                        urb->iso_frame_desc[qh->iso_idx].offset
+                                        + (u32)urb->transfer_dma;
+
+                                length =
+                                        urb->iso_frame_desc[qh->iso_idx].length;
+
+                                val |= MUSB_RXCSR_DMAENAB;
+                                musb_writew(hw_ep->regs, MUSB_RXCSR, val);
+
+                                ret = c->channel_program(dma, qh->maxpacket,
+                                                0, (u32) buf, length);
+#endif
                                 done = false;
+                        }
 
                 } else  {
                 /* done if urb buffer is full or short packet is recd */
@@ -1750,7 +1771,8 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                 }
 
                 /* we are expecting IN packets */
-#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA)
+#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_UX500_DMA) || \
+        defined(CONFIG_USB_TI_CPPI41_DMA)
                 if (dma) {
                         struct dma_controller   *c;
                         u16                     rx_count;