Patched in Tegra support.

1 files changed, 92 insertions, 37 deletions

diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index ec7f5d2c90d..555a73c864b 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -24,23 +24,47 @@
 #include <linux/usb/ulpi.h>
 #include <linux/slab.h>
 
-#include <linux/platform_data/usb-ehci-mxc.h>
+#include <mach/hardware.h>
+#include <mach/mxc_ehci.h>
 
 #include <asm/mach-types.h>
 
 #define ULPI_VIEWPORT_OFFSET    0x170
 
 struct ehci_mxc_priv {
-        struct clk *usbclk, *ahbclk, *phyclk;
+        struct clk *usbclk, *ahbclk, *phy1clk;
         struct usb_hcd *hcd;
 };
 
 /* called during probe() after chip reset completes */
 static int ehci_mxc_setup(struct usb_hcd *hcd)
 {
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
         hcd->has_tt = 1;
 
-        return ehci_setup(hcd);
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+
+        ehci_port_power(ehci, 0);
+        return 0;
 }
 
 static const struct hc_driver ehci_mxc_hc_driver = {
@@ -112,7 +136,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (!hcd)
                 return -ENOMEM;
 
-        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv) {
                 ret = -ENOMEM;
                 goto err_alloc;
@@ -122,40 +146,51 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(dev, "Found HC with no register addr. Check setup!\n");
                 ret = -ENODEV;
-                goto err_alloc;
+                goto err_get_resource;
         }
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto err_request_mem;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
                 dev_err(dev, "error mapping memory\n");
                 ret = -EFAULT;
-                goto err_alloc;
+                goto err_ioremap;
         }
 
         /* enable clocks */
-        priv->usbclk = devm_clk_get(&pdev->dev, "ipg");
+        priv->usbclk = clk_get(dev, "usb");
         if (IS_ERR(priv->usbclk)) {
                 ret = PTR_ERR(priv->usbclk);
-                goto err_alloc;
+                goto err_clk;
         }
-        clk_prepare_enable(priv->usbclk);
+        clk_enable(priv->usbclk);
 
-        priv->ahbclk = devm_clk_get(&pdev->dev, "ahb");
-        if (IS_ERR(priv->ahbclk)) {
-                ret = PTR_ERR(priv->ahbclk);
-                goto err_clk_ahb;
+        if (!cpu_is_mx35() && !cpu_is_mx25()) {
+                priv->ahbclk = clk_get(dev, "usb_ahb");
+                if (IS_ERR(priv->ahbclk)) {
+                        ret = PTR_ERR(priv->ahbclk);
+                        goto err_clk_ahb;
+                }
+                clk_enable(priv->ahbclk);
         }
-        clk_prepare_enable(priv->ahbclk);
 
         /* "dr" device has its own clock on i.MX51 */
-        priv->phyclk = devm_clk_get(&pdev->dev, "phy");
-        if (IS_ERR(priv->phyclk))
-                priv->phyclk = NULL;
-        if (priv->phyclk)
-                clk_prepare_enable(priv->phyclk);
+        if (cpu_is_mx51() && (pdev->id == 0)) {
+                priv->phy1clk = clk_get(dev, "usb_phy1");
+                if (IS_ERR(priv->phy1clk)) {
+                        ret = PTR_ERR(priv->phy1clk);
+                        goto err_clk_phy;
+                }
+                clk_enable(priv->phy1clk);
+        }
 
 
         /* call platform specific init function */
@@ -185,13 +220,13 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         /* Initialize the transceiver */
         if (pdata->otg) {
                 pdata->otg->io_priv = hcd->regs + ULPI_VIEWPORT_OFFSET;
-                ret = usb_phy_init(pdata->otg);
+                ret = otg_init(pdata->otg);
                 if (ret) {
                         dev_err(dev, "unable to init transceiver, probably missing\n");
                         ret = -ENODEV;
                         goto err_add;
                 }
-                ret = otg_set_vbus(pdata->otg->otg, 1);
+                ret = otg_set_vbus(pdata->otg, 1);
                 if (ret) {
                         dev_err(dev, "unable to enable vbus on transceiver\n");
                         goto err_add;
@@ -201,7 +236,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         priv->hcd = hcd;
         platform_set_drvdata(pdev, priv);
 
-        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (ret)
                 goto err_add;
 
@@ -212,11 +247,9 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
                  * It's in violation of USB specs
                  */
                 if (machine_is_mx51_efikamx() || machine_is_mx51_efikasb()) {
-                        flags = usb_phy_io_read(pdata->otg,
-                                                        ULPI_OTG_CTRL);
+                        flags = otg_io_read(pdata->otg, ULPI_OTG_CTRL);
                         flags |= ULPI_OTG_CTRL_CHRGVBUS;
-                        ret = usb_phy_io_write(pdata->otg, flags,
-                                                        ULPI_OTG_CTRL);
+                        ret = otg_io_write(pdata->otg, flags, ULPI_OTG_CTRL);
                         if (ret) {
                                 dev_err(dev, "unable to set CHRVBUS\n");
                                 goto err_add;
@@ -230,12 +263,25 @@ err_add:
         if (pdata && pdata->exit)
                 pdata->exit(pdev);
 err_init:
-        if (priv->phyclk)
-                clk_disable_unprepare(priv->phyclk);
-
-        clk_disable_unprepare(priv->ahbclk);
+        if (priv->phy1clk) {
+                clk_disable(priv->phy1clk);
+                clk_put(priv->phy1clk);
+        }
+err_clk_phy:
+        if (priv->ahbclk) {
+                clk_disable(priv->ahbclk);
+                clk_put(priv->ahbclk);
+        }
 err_clk_ahb:
-        clk_disable_unprepare(priv->usbclk);
+        clk_disable(priv->usbclk);
+        clk_put(priv->usbclk);
+err_clk:
+        iounmap(hcd->regs);
+err_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_request_mem:
+err_get_resource:
+        kfree(priv);
 err_alloc:
         usb_put_hcd(hcd);
         return ret;
@@ -251,17 +297,26 @@ static int __exit ehci_mxc_drv_remove(struct platform_device *pdev)
                 pdata->exit(pdev);
 
         if (pdata->otg)
-                usb_phy_shutdown(pdata->otg);
+                otg_shutdown(pdata->otg);
 
         usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
-        clk_disable_unprepare(priv->usbclk);
-        clk_disable_unprepare(priv->ahbclk);
+        clk_disable(priv->usbclk);
+        clk_put(priv->usbclk);
+        if (priv->ahbclk) {
+                clk_disable(priv->ahbclk);
+                clk_put(priv->ahbclk);
+        }
+        if (priv->phy1clk) {
+                clk_disable(priv->phy1clk);
+                clk_put(priv->phy1clk);
+        }
 
-        if (priv->phyclk)
-                clk_disable_unprepare(priv->phyclk);
+        kfree(priv);
 
         return 0;
 }