static int ehci_msm_pm_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); int ret; u32 portsc; dev_dbg(dev, "ehci-msm PM resume\n"); if (!hcd->rh_registered) return 0; /* Notify OTG to bring hw out of LPM before restoring wakeup flags */ ret = usb_phy_set_suspend(phy, 0); if (ret) return ret; ehci_resume(hcd, false); portsc = readl_relaxed(USB_PORTSC); portsc &= ~PORT_RWC_BITS; portsc |= PORT_RESUME; writel_relaxed(portsc, USB_PORTSC); /* Resume root-hub to handle USB event if any else initiate LPM again */ usb_hcd_resume_root_hub(hcd); return ret; }
static int ehci_spear_drv_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); ehci_resume(hcd, false); return 0; }
static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated) { struct ehci_hcd *ehci = hcd_to_ehci(hcd); struct pci_dev *pdev = to_pci_dev(hcd->self.controller); /* The BIOS on systems with the Intel Panther Point chipset may or may * not support xHCI natively. That means that during system resume, it * may switch the ports back to EHCI so that users can use their * keyboard to select a kernel from GRUB after resume from hibernate. * * The BIOS is supposed to remember whether the OS had xHCI ports * enabled before resume, and switch the ports back to xHCI when the * BIOS/OS semaphore is written, but we all know we can't trust BIOS * writers. * * Unconditionally switch the ports back to xHCI after a system resume. * We can't tell whether the EHCI or xHCI controller will be resumed * first, so we have to do the port switchover in both drivers. Writing * a '1' to the port switchover registers should have no effect if the * port was already switched over. */ if (usb_is_intel_switchable_ehci(pdev)) ehci_enable_xhci_companion(); if (ehci_resume(hcd, hibernated) != 0) (void) ehci_pci_reinit(ehci, pdev); return 0; }
static int ehci_msm_pm_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); dev_dbg(dev, "ehci-msm PM resume\n"); ehci_resume(hcd, false); return 0; }
static int hiusb_ehci_hcd_drv_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); hiusb_start_hcd(); ehci_resume(hcd, false); return 0; }
static int ehci_ebus_resume(device_t self) { ehci_softc_t *sc = device_get_softc(self); ehci_resume(sc); bus_generic_resume(self); return (0); }
static int ehci_platform_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct usb_ehci_pdata *pdata = dev->platform_data; struct platform_device *pdev = container_of(dev, struct platform_device, dev); if (pdata->power_on) { int err = pdata->power_on(pdev); if (err < 0) return err; } ehci_resume(hcd, false); return 0; }
static int ehci_platform_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct usb_ehci_pdata *pdata = dev_get_platdata(dev); struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); if (pdata->power_on) { int err = pdata->power_on(pdev); if (err < 0) return err; } ehci_resume(hcd, priv->reset_on_resume); return 0; }
static int st_ehci_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct usb_ehci_pdata *pdata = dev_get_platdata(dev); struct platform_device *pdev = to_platform_device(dev); int err; pinctrl_pm_select_default_state(dev); if (pdata->power_on) { err = pdata->power_on(pdev); if (err < 0) return err; } ehci_resume(hcd, false); return 0; }
static int exynos_ehci_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); clk_prepare_enable(exynos_ehci->clk); if (exynos_ehci->otg) exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self); if (exynos_ehci->phy) usb_phy_init(exynos_ehci->phy); /* DMA burst Enable */ writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs)); ehci_resume(hcd, false); return 0; }
static int s5p_ehci_runtime_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct s5p_ehci_platdata *pdata = pdev->dev.platform_data; struct usb_hcd *hcd = platform_get_drvdata(pdev); struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd); int rc = 0; if (dev->power.is_suspended) return 0; dev_dbg(dev, "%s\n", __func__); if (s5p_ehci->phy) { struct usb_phy *phy = s5p_ehci->phy; if (s5p_ehci->post_lpa_resume) usb_phy_init(phy); pm_runtime_get_sync(phy->dev); } else if (pdata && pdata->phy_resume) { rc = pdata->phy_resume(pdev, USB_PHY_TYPE_HOST); s5p_ehci->post_lpa_resume = !!rc; } if (s5p_ehci->post_lpa_resume) s5p_ehci_configurate(hcd); ehci_resume(hcd, false); /* * REVISIT: in case of LPA bus won't be resumed, so we do it here. * Alternatively, we can try to setup HC in such a way that it starts * to sense connections. In this case, root hub will be resumed from * interrupt (ehci_irq()). */ if (s5p_ehci->post_lpa_resume) usb_hcd_resume_root_hub(hcd); s5p_ehci->post_lpa_resume = 0; return 0; }
static int ehci_platform_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct usb_ehci_pdata *pdata = dev_get_platdata(dev); struct platform_device *pdev = to_platform_device(dev); struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd); struct device *companion_dev; if (pdata->power_on) { int err = pdata->power_on(pdev); if (err < 0) return err; } companion_dev = usb_of_get_companion_dev(hcd->self.controller); if (companion_dev) { device_pm_wait_for_dev(hcd->self.controller, companion_dev); put_device(companion_dev); } ehci_resume(hcd, priv->reset_on_resume); return 0; }
static int s5p_ehci_resume(struct device *dev) { struct usb_hcd *hcd = dev_get_drvdata(dev); struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd); struct platform_device *pdev = to_platform_device(dev); s5p_ehci_clk_prepare_enable(s5p_ehci); if (s5p_ehci->otg) s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self); if (s5p_ehci->phy) { usb_phy_init(s5p_ehci->phy); s5p_ehci->post_lpa_resume = 0; /* * We are going to change runtime status to active. * Make sure we get the phy only if we didn't get it before. */ if (pm_runtime_suspended(dev)) pm_runtime_get_sync(s5p_ehci->phy->dev); } else if (s5p_ehci->pdata->phy_init) { s5p_ehci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST); } /* DMA burst Enable */ writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs)); ehci_resume(hcd, false); /* Update runtime PM status and clear runtime_error */ pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); return 0; }