1 files changed, 281 insertions, 34 deletions

diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index a416421abfa2..f380bf97e5af 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -52,7 +52,6 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         struct resource *res;
         int irq;
         int retval;
-        unsigned int temp;
 
         pr_debug("initializing FSL-SOC USB Controller\n");
 
@@ -116,17 +115,52 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
                 goto err3;
         }
 
-        /* Enable USB controller */
-        temp = in_be32(hcd->regs + 0x500);
-        out_be32(hcd->regs + 0x500, temp | 0x4);
+        pdata->regs = hcd->regs;
 
-        /* Set to Host mode */
-        temp = in_le32(hcd->regs + 0x1a8);
-        out_le32(hcd->regs + 0x1a8, temp | 0x3);
+        if (pdata->power_budget)
+                hcd->power_budget = pdata->power_budget;
+
+        /*
+         * do platform specific init: check the clock, grab/config pins, etc.
+         */
+        if (pdata->init && pdata->init(pdev)) {
+                retval = -ENODEV;
+                goto err3;
+        }
+
+        /* Enable USB controller, 83xx or 8536 */
+        if (pdata->have_sysif_regs)
+                setbits32(hcd->regs + FSL_SOC_USB_CTRL, 0x4);
+
+        /* Don't need to set host mode here. It will be done by tdi_reset() */
 
         retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
                 goto err4;
+
+#ifdef CONFIG_USB_OTG
+        if (pdata->operating_mode == FSL_USB2_DR_OTG) {
+                struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+                ehci->transceiver = otg_get_transceiver();
+                dev_dbg(&pdev->dev, "hcd=0x%p  ehci=0x%p, transceiver=0x%p\n",
+                        hcd, ehci, ehci->transceiver);
+
+                if (ehci->transceiver) {
+                        retval = otg_set_host(ehci->transceiver,
+                                              &ehci_to_hcd(ehci)->self);
+                        if (retval) {
+                                if (ehci->transceiver)
+                                        put_device(ehci->transceiver->dev);
+                                goto err4;
+                        }
+                } else {
+                        dev_err(&pdev->dev, "can't find transceiver\n");
+                        retval = -ENODEV;
+                        goto err4;
+                }
+        }
+#endif
         return retval;
 
       err4:
@@ -137,6 +171,8 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         usb_put_hcd(hcd);
       err1:
         dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
+        if (pdata->exit)
+                pdata->exit(pdev);
         return retval;
 }
 
@@ -154,17 +190,36 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
 static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
                                struct platform_device *pdev)
 {
+        struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        if (ehci->transceiver) {
+                otg_set_host(ehci->transceiver, NULL);
+                put_device(ehci->transceiver->dev);
+        }
+
         usb_remove_hcd(hcd);
+
+        /*
+         * do platform specific un-initialization:
+         * release iomux pins, disable clock, etc.
+         */
+        if (pdata->exit)
+                pdata->exit(pdev);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 }
 
-static void mpc83xx_setup_phy(struct ehci_hcd *ehci,
-                              enum fsl_usb2_phy_modes phy_mode,
-                              unsigned int port_offset)
+static void ehci_fsl_setup_phy(struct ehci_hcd *ehci,
+                               enum fsl_usb2_phy_modes phy_mode,
+                               unsigned int port_offset)
 {
-        u32 portsc = 0;
+        u32 portsc;
+
+        portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]);
+        portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW);
+
         switch (phy_mode) {
         case FSL_USB2_PHY_ULPI:
                 portsc |= PORT_PTS_ULPI;
@@ -184,20 +239,21 @@ static void mpc83xx_setup_phy(struct ehci_hcd *ehci,
         ehci_writel(ehci, portsc, &ehci->regs->port_status[port_offset]);
 }
 
-static void mpc83xx_usb_setup(struct usb_hcd *hcd)
+static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 {
-        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct usb_hcd *hcd = ehci_to_hcd(ehci);
         struct fsl_usb2_platform_data *pdata;
         void __iomem *non_ehci = hcd->regs;
         u32 temp;
 
-        pdata =
-            (struct fsl_usb2_platform_data *)hcd->self.controller->
-            platform_data;
+        pdata = hcd->self.controller->platform_data;
+
         /* Enable PHY interface in the control reg. */
-        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
-        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
-        out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
+        if (pdata->have_sysif_regs) {
+                temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+                out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
+                out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
+        }
 
 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
         /*
@@ -214,7 +270,7 @@ static void mpc83xx_usb_setup(struct usb_hcd *hcd)
 
         if ((pdata->operating_mode == FSL_USB2_DR_HOST) ||
                         (pdata->operating_mode == FSL_USB2_DR_OTG))
-                mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
+                ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
 
         if (pdata->operating_mode == FSL_USB2_MPH_HOST) {
                 unsigned int chip, rev, svr;
@@ -228,27 +284,27 @@ static void mpc83xx_usb_setup(struct usb_hcd *hcd)
                         ehci->has_fsl_port_bug = 1;
 
                 if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
-                        mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
+                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
                 if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
-                        mpc83xx_setup_phy(ehci, pdata->phy_mode, 1);
+                        ehci_fsl_setup_phy(ehci, pdata->phy_mode, 1);
         }
 
-        /* put controller in host mode. */
-        ehci_writel(ehci, 0x00000003, non_ehci + FSL_SOC_USB_USBMODE);
+        if (pdata->have_sysif_regs) {
 #ifdef CONFIG_PPC_85xx
-        out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
-        out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
+                out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
+                out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
 #else
-        out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
-        out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
+                out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
+                out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
 #endif
-        out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
+                out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
+        }
 }
 
 /* called after powerup, by probe or system-pm "wakeup" */
 static int ehci_fsl_reinit(struct ehci_hcd *ehci)
 {
-        mpc83xx_usb_setup(ehci_to_hcd(ehci));
+        ehci_fsl_usb_setup(ehci);
         ehci_port_power(ehci, 0);
 
         return 0;
@@ -259,17 +315,24 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         int retval;
+        struct fsl_usb2_platform_data *pdata;
+
+        pdata = hcd->self.controller->platform_data;
+        ehci->big_endian_desc = pdata->big_endian_desc;
+        ehci->big_endian_mmio = pdata->big_endian_mmio;
 
         /* EHCI registers start at offset 0x100 */
         ehci->caps = hcd->regs + 0x100;
         ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+                HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
         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;
+
         retval = ehci_halt(ehci);
         if (retval)
                 return retval;
@@ -279,8 +342,6 @@ static int ehci_fsl_setup(struct usb_hcd *hcd)
         if (retval)
                 return retval;
 
-        hcd->has_tt = 1;
-
         ehci->sbrn = 0x20;
 
         ehci_reset(ehci);
@@ -300,6 +361,149 @@ struct ehci_fsl {
 
 #ifdef CONFIG_PM
 
+#ifdef CONFIG_PPC_MPC512x
+static int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+#ifdef DEBUG
+        u32 mode = ehci_readl(ehci, hcd->regs + FSL_SOC_USB_USBMODE);
+        mode &= USBMODE_CM_MASK;
+        tmp = ehci_readl(ehci, hcd->regs + 0x140);      /* usbcmd */
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d "
+                "mode=%d  usbcmd %08x\n", pdata->suspended,
+                pdata->already_suspended, mode, tmp);
+#endif
+
+        /*
+         * If the controller is already suspended, then this must be a
+         * PM suspend.  Remember this fact, so that we will leave the
+         * controller suspended at PM resume time.
+         */
+        if (pdata->suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 1;
+                return 0;
+        }
+
+        dev_dbg(dev, "suspending...\n");
+
+        hcd->state = HC_STATE_SUSPENDED;
+        dev->power.power_state = PMSG_SUSPEND;
+
+        /* ignore non-host interrupts */
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* stop the controller */
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp &= ~CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        /* save EHCI registers */
+        pdata->pm_command = ehci_readl(ehci, &ehci->regs->command);
+        pdata->pm_command &= ~CMD_RUN;
+        pdata->pm_status  = ehci_readl(ehci, &ehci->regs->status);
+        pdata->pm_intr_enable  = ehci_readl(ehci, &ehci->regs->intr_enable);
+        pdata->pm_frame_index  = ehci_readl(ehci, &ehci->regs->frame_index);
+        pdata->pm_segment  = ehci_readl(ehci, &ehci->regs->segment);
+        pdata->pm_frame_list  = ehci_readl(ehci, &ehci->regs->frame_list);
+        pdata->pm_async_next  = ehci_readl(ehci, &ehci->regs->async_next);
+        pdata->pm_configured_flag  =
+                ehci_readl(ehci, &ehci->regs->configured_flag);
+        pdata->pm_portsc = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        pdata->pm_usbgenctrl = ehci_readl(ehci,
+                                          hcd->regs + FSL_SOC_USB_USBGENCTRL);
+
+        /* clear the W1C bits */
+        pdata->pm_portsc &= cpu_to_hc32(ehci, ~PORT_RWC_BITS);
+
+        pdata->suspended = 1;
+
+        /* clear PP to cut power to the port */
+        tmp = ehci_readl(ehci, &ehci->regs->port_status[0]);
+        tmp &= ~PORT_POWER;
+        ehci_writel(ehci, tmp, &ehci->regs->port_status[0]);
+
+        return 0;
+}
+
+static int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        struct fsl_usb2_platform_data *pdata = dev->platform_data;
+        u32 tmp;
+
+        dev_dbg(dev, "suspend=%d already_suspended=%d\n",
+                pdata->suspended, pdata->already_suspended);
+
+        /*
+         * If the controller was already suspended at suspend time,
+         * then don't resume it now.
+         */
+        if (pdata->already_suspended) {
+                dev_dbg(dev, "already suspended, leaving early\n");
+                pdata->already_suspended = 0;
+                return 0;
+        }
+
+        if (!pdata->suspended) {
+                dev_dbg(dev, "not suspended, leaving early\n");
+                return 0;
+        }
+
+        pdata->suspended = 0;
+
+        dev_dbg(dev, "resuming...\n");
+
+        /* set host mode */
+        tmp = USBMODE_CM_HOST | (pdata->es ? USBMODE_ES : 0);
+        ehci_writel(ehci, tmp, hcd->regs + FSL_SOC_USB_USBMODE);
+
+        ehci_writel(ehci, pdata->pm_usbgenctrl,
+                    hcd->regs + FSL_SOC_USB_USBGENCTRL);
+        ehci_writel(ehci, ISIPHYCTRL_PXE | ISIPHYCTRL_PHYE,
+                    hcd->regs + FSL_SOC_USB_ISIPHYCTRL);
+
+        /* restore EHCI registers */
+        ehci_writel(ehci, pdata->pm_command, &ehci->regs->command);
+        ehci_writel(ehci, pdata->pm_intr_enable, &ehci->regs->intr_enable);
+        ehci_writel(ehci, pdata->pm_frame_index, &ehci->regs->frame_index);
+        ehci_writel(ehci, pdata->pm_segment, &ehci->regs->segment);
+        ehci_writel(ehci, pdata->pm_frame_list, &ehci->regs->frame_list);
+        ehci_writel(ehci, pdata->pm_async_next, &ehci->regs->async_next);
+        ehci_writel(ehci, pdata->pm_configured_flag,
+                    &ehci->regs->configured_flag);
+        ehci_writel(ehci, pdata->pm_portsc, &ehci->regs->port_status[0]);
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        hcd->state = HC_STATE_RUNNING;
+        dev->power.power_state = PMSG_ON;
+
+        tmp = ehci_readl(ehci, &ehci->regs->command);
+        tmp |= CMD_RUN;
+        ehci_writel(ehci, tmp, &ehci->regs->command);
+
+        usb_hcd_resume_root_hub(hcd);
+
+        return 0;
+}
+#else
+static inline int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static inline int ehci_fsl_mpc512x_drv_resume(struct device *dev)
+{
+        return 0;
+}
+#endif /* CONFIG_PPC_MPC512x */
+
 static struct ehci_fsl *hcd_to_ehci_fsl(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
@@ -313,6 +517,11 @@ static int ehci_fsl_drv_suspend(struct device *dev)
         struct ehci_fsl *ehci_fsl = hcd_to_ehci_fsl(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_suspend(dev);
+        }
+
         ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),
                         device_may_wakeup(dev));
         if (!fsl_deep_sleep())
@@ -329,6 +538,11 @@ static int ehci_fsl_drv_resume(struct device *dev)
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
 
+        if (of_device_is_compatible(dev->parent->of_node,
+                                    "fsl,mpc5121-usb2-dr")) {
+                return ehci_fsl_mpc512x_drv_resume(dev);
+        }
+
         ehci_prepare_ports_for_controller_resume(ehci);
         if (!fsl_deep_sleep())
                 return 0;
@@ -363,6 +577,38 @@ static struct dev_pm_ops ehci_fsl_pm_ops = {
 #define EHCI_FSL_PM_OPS         NULL
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_USB_OTG
+static int ehci_start_port_reset(struct usb_hcd *hcd, unsigned port)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        u32 status;
+
+        if (!port)
+                return -EINVAL;
+
+        port--;
+
+        /* start port reset before HNP protocol time out */
+        status = readl(&ehci->regs->port_status[port]);
+        if (!(status & PORT_CONNECT))
+                return -ENODEV;
+
+        /* khubd will finish the reset later */
+        if (ehci_is_TDI(ehci)) {
+                writel(PORT_RESET |
+                       (status & ~(PORT_CSC | PORT_PEC | PORT_OCC)),
+                       &ehci->regs->port_status[port]);
+        } else {
+                writel(PORT_RESET, &ehci->regs->port_status[port]);
+        }
+
+        return 0;
+}
+#else
+#define ehci_start_port_reset   NULL
+#endif /* CONFIG_USB_OTG */
+
+
 static const struct hc_driver ehci_fsl_hc_driver = {
         .description = hcd_name,
         .product_desc = "Freescale On-Chip EHCI Host Controller",
@@ -372,7 +618,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
          * generic hardware linkage
          */
         .irq = ehci_irq,
-        .flags = HCD_USB2,
+        .flags = HCD_USB2 | HCD_MEMORY,
 
         /*
          * basic lifecycle operations
@@ -402,6 +648,7 @@ static const struct hc_driver ehci_fsl_hc_driver = {
         .hub_control = ehci_hub_control,
         .bus_suspend = ehci_bus_suspend,
         .bus_resume = ehci_bus_resume,
+        .start_port_reset = ehci_start_port_reset,
         .relinquish_port = ehci_relinquish_port,
         .port_handed_over = ehci_port_handed_over,