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

usb: musb: patches for v3.7 merge window

Here we have a bunch of miscellaneous cleanups and fixes
to the musb driver. It fixes a bunch of mistakes errors
which nobody has triggered before, so I'm not Ccing stable
tree.

We are finally improving OMAP's VBUS/ID Mailbox usage so
that we can introduce our PHY drivers properly. Also, we're
adding support for multiple instances of the MUSB IP in
the same SoC, as seen on some platforms from TI which
have 2 MUSB instances.

Other than that, we have some small fixes like not kicking
DMA for a zero byte transfer, or properly handling NAK timeout
on MUSB's host side, and the enabling of DMA Mode1 for any
transfers which are aligned to wMaxPacketSize.

All patches have been pending on mailing list for a long time
and I don't expect any big surprises with this pull request.

1 files changed, 34 insertions, 32 deletions

diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 863a9b6286c3..606bfd00cde6 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -116,8 +116,7 @@ static void davinci_musb_enable(struct musb *musb)
                 dma_off = 0;
 
         /* force a DRVVBUS irq so we can start polling for ID change */
-        if (is_otg_enabled(musb))
-                musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
+        musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
                         DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);
 }
 
@@ -235,10 +234,8 @@ static void otg_timer(unsigned long _musb)
                         MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
                 break;
         case OTG_STATE_B_IDLE:
-                if (!is_peripheral_enabled(musb))
-                        break;
-
-                /* There's no ID-changed IRQ, so we have no good way to tell
+                /*
+                 * There's no ID-changed IRQ, so we have no good way to tell
                  * when to switch to the A-Default state machine (by setting
                  * the DEVCTL.SESSION flag).
                  *
@@ -316,8 +313,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                 u8      devctl = musb_readb(mregs, MUSB_DEVCTL);
                 int     err = musb->int_usb & MUSB_INTR_VBUSERROR;
 
-                err = is_host_enabled(musb)
-                                && (musb->int_usb & MUSB_INTR_VBUSERROR);
+                err = musb->int_usb & MUSB_INTR_VBUSERROR;
                 if (err) {
                         /* The Mentor core doesn't debounce VBUS as needed
                          * to cope with device connect current spikes. This
@@ -333,7 +329,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
                         WARNING("VBUS error workaround (delay coming)\n");
-                } else if (is_host_enabled(musb) && drvvbus) {
+                } else if (drvvbus) {
                         MUSB_HST_MODE(musb);
                         otg->default_a = 1;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -366,8 +362,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
         musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);
 
         /* poll for ID change */
-        if (is_otg_enabled(musb)
-                        && musb->xceiv->state == OTG_STATE_B_IDLE)
+        if (musb->xceiv->state == OTG_STATE_B_IDLE)
                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -398,8 +393,7 @@ static int davinci_musb_init(struct musb *musb)
         if (revision == 0)
                 goto fail;
 
-        if (is_host_enabled(musb))
-                setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+        setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
         davinci_musb_source_power(musb, 0, 1);
 
@@ -420,12 +414,7 @@ static int davinci_musb_init(struct musb *musb)
         if (cpu_is_davinci_dm355()) {
                 u32     deepsleep = __raw_readl(DM355_DEEPSLEEP);
 
-                if (is_host_enabled(musb)) {
-                        deepsleep &= ~DRVVBUS_OVERRIDE;
-                } else {
-                        deepsleep &= ~DRVVBUS_FORCE;
-                        deepsleep |= DRVVBUS_OVERRIDE;
-                }
+                deepsleep &= ~DRVVBUS_FORCE;
                 __raw_writel(deepsleep, DM355_DEEPSLEEP);
         }
 
@@ -454,8 +443,7 @@ unregister:
 
 static int davinci_musb_exit(struct musb *musb)
 {
-        if (is_host_enabled(musb))
-                del_timer_sync(&otg_workaround);
+        del_timer_sync(&otg_workaround);
 
         /* force VBUS off */
         if (cpu_is_davinci_dm355()) {
@@ -469,7 +457,7 @@ static int davinci_musb_exit(struct musb *musb)
         davinci_musb_source_power(musb, 0 /*off*/, 1);
 
         /* delay, to avoid problems with module reload */
-        if (is_host_enabled(musb) && musb->xceiv->otg->default_a) {
+        if (musb->xceiv->otg->default_a) {
                 int     maxdelay = 30;
                 u8      devctl, warn = 0;
 
@@ -524,6 +512,7 @@ static int __devinit davinci_probe(struct platform_device *pdev)
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -531,25 +520,34 @@ static int __devinit davinci_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
         clk = clk_get(&pdev->dev, "usb");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
-                goto err2;
+                goto err3;
         }
 
         ret = clk_enable(clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable clock\n");
-                goto err3;
+                goto err4;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &davinci_dmamask;
         musb->dev.coherent_dma_mask     = davinci_dmamask;
@@ -566,32 +564,35 @@ static int __devinit davinci_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err4;
+                goto err5;
         }
 
         return 0;
 
-err4:
+err5:
         clk_disable(clk);
 
-err3:
+err4:
         clk_put(clk);
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -603,6 +604,7 @@ static int __devexit davinci_remove(struct platform_device *pdev)
 {
         struct davinci_glue             *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         clk_disable(glue->clk);