自学教程：C++ usb_phy_set_suspend函数代码示例

static int dwc3_remove(struct platform_device *pdev){	struct dwc3	*dwc = platform_get_drvdata(pdev);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	pm_runtime_disable(&pdev->dev);	dwc3_debugfs_exit(dwc);	switch (dwc->mode) {	case DWC3_MODE_DEVICE:		dwc3_gadget_exit(dwc);		break;	case DWC3_MODE_HOST:		dwc3_host_exit(dwc);		break;	case DWC3_MODE_DRD:		dwc3_gadget_exit(dwc);		dwc3_host_exit(dwc);		dwc3_otg_exit(dwc);		break;	default:		/* do nothing */		break;	}	dwc3_event_buffers_cleanup(dwc);	dwc3_free_event_buffers(dwc);	dwc3_core_exit(dwc);	return 0;}

static int dwc3_suspend(struct device *dev){	struct dwc3	*dwc = dev_get_drvdata(dev);	unsigned long	flags;	spin_lock_irqsave(&dwc->lock, flags);	switch (dwc->dr_mode) {	case USB_DR_MODE_PERIPHERAL:	case USB_DR_MODE_OTG:		dwc3_gadget_suspend(dwc);		/* FALLTHROUGH */	case USB_DR_MODE_HOST:	default:		dwc3_event_buffers_cleanup(dwc);		break;	}	dwc->gctl = dwc3_readl(dwc->regs, DWC3_GCTL);	spin_unlock_irqrestore(&dwc->lock, flags);	usb_phy_shutdown(dwc->usb3_phy);	usb_phy_shutdown(dwc->usb2_phy);	phy_exit(dwc->usb2_generic_phy);	phy_exit(dwc->usb3_generic_phy);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	WARN_ON(phy_power_off(dwc->usb2_generic_phy) < 0);	WARN_ON(phy_power_off(dwc->usb3_generic_phy) < 0);	pinctrl_pm_select_sleep_state(dev);	return 0;}

static int dwc3_remove(struct platform_device *pdev){	struct dwc3	*dwc = platform_get_drvdata(pdev);	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);	/*	 * restore res->start back to its original value so that, in case the	 * probe is deferred, we don't end up getting error in request the	 * memory region the next time probe is called.	 */	res->start -= DWC3_GLOBALS_REGS_START;	dwc3_debugfs_exit(dwc);	dwc3_core_exit_mode(dwc);	dwc3_event_buffers_cleanup(dwc);	dwc3_free_event_buffers(dwc);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	phy_power_off(dwc->usb2_generic_phy);	phy_power_off(dwc->usb3_generic_phy);	dwc3_core_exit(dwc);	dwc3_ulpi_exit(dwc);	pm_runtime_put_sync(&pdev->dev);	pm_runtime_disable(&pdev->dev);	return 0;}

static void dwc3_core_exit(struct dwc3 *dwc){	dwc3_event_buffers_cleanup(dwc);	usb_phy_shutdown(dwc->usb2_phy);	usb_phy_shutdown(dwc->usb3_phy);	phy_exit(dwc->usb2_generic_phy);	phy_exit(dwc->usb3_generic_phy);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	phy_power_off(dwc->usb2_generic_phy);	phy_power_off(dwc->usb3_generic_phy);}

static void dwc3_core_exit(struct dwc3 *dwc){	usb_phy_shutdown(dwc->usb2_phy);	usb_phy_shutdown(dwc->usb3_phy);	phy_exit(dwc->usb2_generic_phy);	phy_exit(dwc->usb3_generic_phy);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	phy_power_off(dwc->usb2_generic_phy);	phy_power_off(dwc->usb3_generic_phy);	clk_bulk_disable(dwc->num_clks, dwc->clks);	clk_bulk_unprepare(dwc->num_clks, dwc->clks);	reset_control_assert(dwc->reset);}

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_msm_pm_suspend(struct device *dev){    struct usb_hcd *hcd = dev_get_drvdata(dev);    bool wakeup = device_may_wakeup(dev);    dev_dbg(dev, "ehci-msm PM suspend/n");    if (!hcd->rh_registered)        return 0;    /*     * EHCI helper function has also the same check before manipulating     * port wakeup flags.  We do check here the same condition before     * calling the same helper function to avoid bringing hardware     * from Low power mode when there is no need for adjusting port     * wakeup flags.     */    if (hcd->self.root_hub->do_remote_wakeup && !wakeup) {        pm_runtime_resume(dev);        ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),                wakeup);    }    return usb_phy_set_suspend(phy, 1);}

static int tegra_ehci_bus_suspend(struct usb_hcd *hcd){	struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);	int err = 0;	EHCI_DBG("%s() BEGIN/n", __func__);#ifdef CONFIG_TEGRA_EHCI_BOOST_CPU_FREQ	tegra->boost_requested = false;	if (tegra->boost_enable	    && pm_qos_request_active(&tegra->boost_cpu_freq_req))		pm_qos_update_request(&tegra->boost_cpu_freq_req,			PM_QOS_DEFAULT_VALUE);	tegra->cpu_boost_in_work = false;#endif	mutex_lock(&tegra->sync_lock);	tegra->bus_suspended_fail = false;	err = ehci_bus_suspend(hcd);	if (err)		tegra->bus_suspended_fail = true;	else		usb_phy_set_suspend(get_usb_phy(tegra->phy), 1);	mutex_unlock(&tegra->sync_lock);	EHCI_DBG("%s() END/n", __func__);	return err;}

static int xhci_msm_runtime_suspend(struct device *dev){	dev_dbg(dev, "xhci msm runtime suspend/n");	if (phy)		return usb_phy_set_suspend(phy, 1);	return 0;}

static void tegra_ehci_power_up(struct usb_hcd *hcd){	struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);	clk_prepare_enable(tegra->emc_clk);	clk_prepare_enable(tegra->clk);	usb_phy_set_suspend(&tegra->phy->u_phy, 0);	tegra->host_resumed = 1;}

static void tegra_ehci_power_down(struct usb_hcd *hcd){	struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);	tegra->host_resumed = 0;	usb_phy_set_suspend(&tegra->phy->u_phy, 1);	clk_disable_unprepare(tegra->clk);	clk_disable_unprepare(tegra->emc_clk);}

static int ehci_msm_runtime_suspend(struct device *dev){	dev_dbg(dev, "ehci runtime suspend/n");	/*	 * Notify OTG about suspend.  It takes care of	 * putting the hardware in LPM.	 */	return usb_phy_set_suspend(phy, 1);}

static int ux500_suspend(struct device *dev){	struct ux500_glue	*glue = dev_get_drvdata(dev);	struct musb		*musb = glue_to_musb(glue);	usb_phy_set_suspend(musb->xceiv, 1);	clk_disable(glue->clk);	return 0;}

static irqreturn_t ci13xxx_msm_resume_irq(int irq, void *data){	struct ci13xxx *udc = _udc;	if (udc->transceiver && udc->vbus_active && udc->suspended)		usb_phy_set_suspend(udc->transceiver, 0);	else if (!udc->suspended)		ci13xxx_msm_resume();	return IRQ_HANDLED;}

static int usbhs_power_ctrl(struct platform_device *pdev,				void __iomem *base, int enable){	struct usbhs_private *priv = usbhs_get_priv(pdev);	if (!priv->phy)		return -ENODEV;	if (enable) {		int retval = usb_phy_init(priv->phy);		if (!retval)			retval = usb_phy_set_suspend(priv->phy, 0);		return retval;	}	usb_phy_set_suspend(priv->phy, 1);	usb_phy_shutdown(priv->phy);	return 0;}

static irqreturn_t ci13xxx_msm_resume_irq(int irq, void *data){	struct ci13xxx *ci = data;	if (ci->transceiver && ci->vbus_active && ci->suspended)		usb_phy_set_suspend(ci->transceiver, 0);	else if (!ci->suspended)		ci13xxx_msm_resume(ci);	return IRQ_HANDLED;}

static int ehci_msm_pm_suspend(struct device *dev){	struct usb_hcd *hcd = dev_get_drvdata(dev);	dev_dbg(dev, "ehci-msm PM suspend/n");	if (!hcd->rh_registered)		return 0;	return usb_phy_set_suspend(phy, 1);}

static int dwc3_remove(struct platform_device *pdev){	struct dwc3	*dwc = platform_get_drvdata(pdev);	dwc3_debugfs_exit(dwc);	dwc3_core_exit_mode(dwc);	dwc3_event_buffers_cleanup(dwc);	dwc3_free_event_buffers(dwc);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	phy_power_off(dwc->usb2_generic_phy);	phy_power_off(dwc->usb3_generic_phy);	dwc3_core_exit(dwc);	pm_runtime_put_sync(&pdev->dev);	pm_runtime_disable(&pdev->dev);	return 0;}

static int dwc3_remove(struct platform_device *pdev){	struct dwc3	*dwc = platform_get_drvdata(pdev);	dwc3_debugfs_exit(dwc);	switch (dwc->dr_mode) {	case USB_DR_MODE_PERIPHERAL:		dwc3_gadget_exit(dwc);		break;	case USB_DR_MODE_HOST:		dwc3_host_exit(dwc);		break;	case USB_DR_MODE_OTG:		dwc3_host_exit(dwc);		dwc3_gadget_exit(dwc);		break;	default:		/* do nothing */		break;	}	dwc3_event_buffers_cleanup(dwc);	dwc3_free_event_buffers(dwc);	usb_phy_set_suspend(dwc->usb2_phy, 1);	usb_phy_set_suspend(dwc->usb3_phy, 1);	phy_power_off(dwc->usb2_generic_phy);	phy_power_off(dwc->usb3_generic_phy);	dwc3_core_exit(dwc);	pm_runtime_put_sync(&pdev->dev);	pm_runtime_disable(&pdev->dev);	return 0;}

static int tegra_ehci_bus_resume(struct usb_hcd *hcd){	struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);	int err = 0;	EHCI_DBG("%s() BEGIN/n", __func__);	mutex_lock(&tegra->sync_lock);	usb_phy_set_suspend(get_usb_phy(tegra->phy), 0);	err = ehci_bus_resume(hcd);	mutex_unlock(&tegra->sync_lock);	EHCI_DBG("%s() END/n", __func__);	return err;}

static int omap2430_runtime_suspend(struct device *dev){	struct omap2430_glue		*glue = dev_get_drvdata(dev);	struct musb			*musb = glue_to_musb(glue);	if (musb) {		musb->context.otg_interfsel = musb_readl(musb->mregs,				OTG_INTERFSEL);		omap2430_low_level_exit(musb);		usb_phy_set_suspend(musb->xceiv, 1);	}	return 0;}

static int omap2430_runtime_resume(struct device *dev){	struct omap2430_glue		*glue = dev_get_drvdata(dev);	struct musb			*musb = glue_to_musb(glue);	if (musb) {		omap2430_low_level_init(musb);		musb_writel(musb->mregs, OTG_INTERFSEL,				musb->context.otg_interfsel);		usb_phy_set_suspend(musb->xceiv, 0);	}	return 0;}

static int ux500_resume(struct device *dev){	struct ux500_glue	*glue = dev_get_drvdata(dev);	struct musb		*musb = glue_to_musb(glue);	int			ret;	ret = clk_enable(glue->clk);	if (ret) {		dev_err(dev, "failed to enable clock/n");		return ret;	}	usb_phy_set_suspend(musb->xceiv, 0);	return 0;}

static int tegra_ehci_bus_suspend(struct usb_hcd *hcd){	struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);	int err = 0;	EHCI_DBG("%s() BEGIN/n", __func__);	mutex_lock(&tegra->sync_lock);	tegra->bus_suspended_fail = false;	err = ehci_bus_suspend(hcd);	if (err)		tegra->bus_suspended_fail = true;	else		usb_phy_set_suspend(get_usb_phy(tegra->phy), 1);	mutex_unlock(&tegra->sync_lock);	EHCI_DBG("%s() END/n", __func__);	return err;}

static int ehci_msm_runtime_resume(struct device *dev){	struct usb_hcd *hcd = dev_get_drvdata(dev);	int ret;	u32 portsc;	dev_dbg(dev, "ehci runtime resume/n");	ret = usb_phy_set_suspend(phy, 0);	if (ret)		return ret;	portsc = readl_relaxed(USB_PORTSC);	portsc &= ~PORT_RWC_BITS;	portsc |= PORT_RESUME;	writel_relaxed(portsc, USB_PORTSC);	return ret;}

static int ehci_msm_bus_resume(struct usb_hcd *hcd){    struct msmusb_hcd *mhcd = hcd_to_mhcd(hcd);    struct device *dev = hcd->self.controller;    wake_lock(&mhcd->wlock);    pm_runtime_get_noresume(dev);    pm_runtime_resume(dev);    if (PHY_TYPE(mhcd->pdata->phy_info) == USB_PHY_INTEGRATED) {        usb_phy_set_suspend(mhcd->xceiv, 0);    } else { /* PMIC serial phy */        usb_lpm_exit(hcd);        if (cancel_work_sync(&(mhcd->lpm_exit_work)))            usb_lpm_exit_w(&mhcd->lpm_exit_work);    }    return ehci_bus_resume(hcd);}

static int ehci_msm_pm_resume(struct device *dev){    struct usb_hcd *hcd = dev_get_drvdata(dev);    int ret;    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_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));    /* Resume root-hub to handle USB event if any else initiate LPM again */    usb_hcd_resume_root_hub(hcd);    return ret;}

static int ehci_msm_bus_suspend(struct usb_hcd *hcd){    int ret;    struct msmusb_hcd *mhcd = hcd_to_mhcd(hcd);    struct device *dev = hcd->self.controller;    ret = ehci_bus_suspend(hcd);    if (ret) {        pr_err("ehci_bus suspend faield/n");        return ret;    }    if (PHY_TYPE(mhcd->pdata->phy_info) == USB_PHY_INTEGRATED)        ret = usb_phy_set_suspend(mhcd->xceiv, 1);    else        ret = usb_lpm_enter(hcd);    pm_runtime_put_noidle(dev);    pm_runtime_suspend(dev);    wake_unlock(&mhcd->wlock);    return ret;}