1 files changed, 54 insertions, 81 deletions

diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index c474cec064e4..9d8f1dd57cb3 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -13,7 +13,9 @@
  */
 
 #include <linux/clk.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/of_gpio.h>
 #include <plat/ehci.h>
 #include <plat/usb-phy.h>
 
@@ -40,7 +42,7 @@ static const struct hc_driver s5p_ehci_hc_driver = {
         .irq                    = ehci_irq,
         .flags                  = HCD_MEMORY | HCD_USB2,
 
-        .reset                  = ehci_init,
+        .reset                  = ehci_setup,
         .start                  = ehci_run,
         .stop                   = ehci_stop,
         .shutdown               = ehci_shutdown,
@@ -63,6 +65,26 @@ static const struct hc_driver s5p_ehci_hc_driver = {
         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 };
 
+static void s5p_setup_vbus_gpio(struct platform_device *pdev)
+{
+        int err;
+        int gpio;
+
+        if (!pdev->dev.of_node)
+                return;
+
+        gpio = of_get_named_gpio(pdev->dev.of_node,
+                        "samsung,vbus-gpio", 0);
+        if (!gpio_is_valid(gpio))
+                return;
+
+        err = gpio_request_one(gpio, GPIOF_OUT_INIT_HIGH, "ehci_vbus_gpio");
+        if (err)
+                dev_err(&pdev->dev, "can't request ehci vbus gpio %d", gpio);
+}
+
+static u64 ehci_s5p_dma_mask = DMA_BIT_MASK(32);
+
 static int __devinit s5p_ehci_probe(struct platform_device *pdev)
 {
         struct s5p_ehci_platdata *pdata;
@@ -79,7 +101,20 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        s5p_ehci = kzalloc(sizeof(struct s5p_ehci_hcd), GFP_KERNEL);
+        /*
+         * Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we move to full device tree support this will vanish off.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &ehci_s5p_dma_mask;
+        if (!pdev->dev.coherent_dma_mask)
+                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+
+        s5p_setup_vbus_gpio(pdev);
+
+        s5p_ehci = devm_kzalloc(&pdev->dev, sizeof(struct s5p_ehci_hcd),
+                                GFP_KERNEL);
         if (!s5p_ehci)
                 return -ENOMEM;
 
@@ -89,8 +124,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
                                         dev_name(&pdev->dev));
         if (!hcd) {
                 dev_err(&pdev->dev, "Unable to create HCD\n");
-                err = -ENOMEM;
-                goto fail_hcd;
+                return -ENOMEM;
         }
 
         s5p_ehci->hcd = hcd;
@@ -115,7 +149,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = ioremap(res->start, resource_size(res));
+        hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
         if (!hcd->regs) {
                 dev_err(&pdev->dev, "Failed to remap I/O memory\n");
                 err = -ENOMEM;
@@ -126,7 +160,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
         if (!irq) {
                 dev_err(&pdev->dev, "Failed to get IRQ\n");
                 err = -ENODEV;
-                goto fail;
+                goto fail_io;
         }
 
         if (pdata->phy_init)
@@ -134,40 +168,26 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs +
-                HC_LENGTH(ehci, readl(&ehci->caps->hc_capbase));
 
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
 
-        dbg_hcs_params(ehci, "reset");
-        dbg_hcc_params(ehci, "reset");
-
-        /* cache this readonly data; minimize chip reads */
-        ehci->hcs_params = readl(&ehci->caps->hcs_params);
-
-        ehci_reset(ehci);
-
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
-                goto fail;
+                goto fail_io;
         }
 
         platform_set_drvdata(pdev, s5p_ehci);
 
         return 0;
 
-fail:
-        iounmap(hcd->regs);
 fail_io:
         clk_disable(s5p_ehci->clk);
 fail_clken:
         clk_put(s5p_ehci->clk);
 fail_clk:
         usb_put_hcd(hcd);
-fail_hcd:
-        kfree(s5p_ehci);
         return err;
 }
 
@@ -182,13 +202,10 @@ static int __devexit s5p_ehci_remove(struct platform_device *pdev)
         if (pdata && pdata->phy_exit)
                 pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
 
-        iounmap(hcd->regs);
-
         clk_disable(s5p_ehci->clk);
         clk_put(s5p_ehci->clk);
 
         usb_put_hcd(hcd);
-        kfree(s5p_ehci);
 
         return 0;
 }
@@ -207,27 +224,12 @@ static int s5p_ehci_suspend(struct device *dev)
 {
         struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = s5p_ehci->hcd;
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        bool do_wakeup = device_may_wakeup(dev);
         struct platform_device *pdev = to_platform_device(dev);
         struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
-        unsigned long flags;
-        int rc = 0;
-
-        if (time_before(jiffies, ehci->next_statechange))
-                msleep(20);
-
-        /*
-         * Root hub was already suspended. Disable irq emission and
-         * mark HW unaccessible.  The PM and USB cores make sure that
-         * the root hub is either suspended or stopped.
-         */
-        ehci_prepare_ports_for_controller_suspend(ehci, device_may_wakeup(dev));
-        spin_lock_irqsave(&ehci->lock, flags);
-        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
-        (void)ehci_readl(ehci, &ehci->regs->intr_enable);
+        int rc;
 
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        spin_unlock_irqrestore(&ehci->lock, flags);
+        rc = ehci_suspend(hcd, do_wakeup);
 
         if (pdata && pdata->phy_exit)
                 pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
@@ -241,7 +243,6 @@ static int s5p_ehci_resume(struct device *dev)
 {
         struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = s5p_ehci->hcd;
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         struct platform_device *pdev = to_platform_device(dev);
         struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
 
@@ -253,44 +254,7 @@ static int s5p_ehci_resume(struct device *dev)
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
 
-        if (time_before(jiffies, ehci->next_statechange))
-                msleep(100);
-
-        /* Mark hardware accessible again as we are out of D3 state by now */
-        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
-                int     mask = INTR_MASK;
-
-                ehci_prepare_ports_for_controller_resume(ehci);
-                if (!hcd->self.root_hub->do_remote_wakeup)
-                        mask &= ~STS_PCD;
-                ehci_writel(ehci, mask, &ehci->regs->intr_enable);
-                ehci_readl(ehci, &ehci->regs->intr_enable);
-                return 0;
-        }
-
-        usb_root_hub_lost_power(hcd->self.root_hub);
-
-        (void) ehci_halt(ehci);
-        (void) ehci_reset(ehci);
-
-        /* emptying the schedule aborts any urbs */
-        spin_lock_irq(&ehci->lock);
-        if (ehci->reclaim)
-                end_unlink_async(ehci);
-        ehci_work(ehci);
-        spin_unlock_irq(&ehci->lock);
-
-        ehci_writel(ehci, ehci->command, &ehci->regs->command);
-        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
-        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
-
-        /* here we "know" root ports should always stay powered */
-        ehci_port_power(ehci, 1);
-
-        ehci->rh_state = EHCI_RH_SUSPENDED;
-
+        ehci_resume(hcd, false);
         return 0;
 }
 #else
@@ -303,6 +267,14 @@ static const struct dev_pm_ops s5p_ehci_pm_ops = {
         .resume         = s5p_ehci_resume,
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id exynos_ehci_match[] = {
+        { .compatible = "samsung,exynos-ehci" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, exynos_ehci_match);
+#endif
+
 static struct platform_driver s5p_ehci_driver = {
         .probe          = s5p_ehci_probe,
         .remove         = __devexit_p(s5p_ehci_remove),
@@ -311,6 +283,7 @@ static struct platform_driver s5p_ehci_driver = {
                 .name   = "s5p-ehci",
                 .owner  = THIS_MODULE,
                 .pm     = &s5p_ehci_pm_ops,
+                .of_match_table = of_match_ptr(exynos_ehci_match),
         }
 };