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

static int dwc3_suspend(struct device *dev){	struct dwc3	*dwc = dev_get_drvdata(dev);	unsigned long	flags;	/* Check if platform glue driver handling PM, if not then handle here */	if(!dwc3_notify_event(dwc, DWC3_CORE_PM_SUSPEND_EVENT))		return 0;	spin_lock_irqsave(&dwc->lock, flags);	switch (dwc->mode) {	case DWC3_MODE_DEVICE:	case DWC3_MODE_DRD:		dwc3_gadget_suspend(dwc);		/* FALLTHROUGH */	case DWC3_MODE_HOST:	default:		/* do nothing */		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);	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);}

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);	pinctrl_pm_select_sleep_state(dev);	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->mode) {	case DWC3_MODE_DEVICE:	case DWC3_MODE_DRD:		dwc3_gadget_suspend(dwc);		/* FALLTHROUGH */	case DWC3_MODE_HOST:	default:		/* do nothing */		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);	return 0;}

static void dwc3_core_exit(struct dwc3 *dwc){	dwc3_free_scratch_buffers(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);}

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 dsps_musb_reset(struct musb *musb){	struct device *dev = musb->controller;	struct dsps_glue *glue = dev_get_drvdata(dev->parent);	const struct dsps_musb_wrapper *wrp = glue->wrp;	int session_restart = 0;	if (glue->sw_babble_enabled)		session_restart = sw_babble_control(musb);	/*	 * In case of new silicon version babble condition can be recovered	 * without resetting the MUSB. But for older silicon versions, MUSB	 * reset is needed	 */	if (session_restart || !glue->sw_babble_enabled) {		dev_info(musb->controller, "Restarting MUSB to recover from Babble/n");		dsps_writel(musb->ctrl_base, wrp->control, (1 << wrp->reset));		usleep_range(100, 200);		usb_phy_shutdown(musb->xceiv);		usleep_range(100, 200);		usb_phy_init(musb->xceiv);		session_restart = 1;	}	return !session_restart;}

static int exynos_ohci_lpa_event(struct notifier_block *nb,				 unsigned long event,				 void *data){	struct exynos_ohci_hcd *exynos_ohci = container_of(nb,					struct exynos_ohci_hcd, lpa_nb);	int ret = NOTIFY_OK;	switch (event) {	case LPA_ENTER:		/*		 * For the purpose of reducing of power consumption in LPA mode		 * the PHY should be completely shutdown and reinitialized after		 * exit from LPA.		 */		if (exynos_ohci->phy)			usb_phy_shutdown(exynos_ohci->phy);		exynos_ohci->post_lpa_resume = 1;		break;	default:		ret = NOTIFY_DONE;	}	return ret;}

static int __exit ehci_mxc_drv_remove(struct platform_device *pdev){	struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data;	struct ehci_mxc_priv *priv = platform_get_drvdata(pdev);	struct usb_hcd *hcd = priv->hcd;	if (pdata && pdata->exit)		pdata->exit(pdev);	if (pdata->otg)		usb_phy_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(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);	}	kfree(priv);	return 0;}

static int tegra_ehci_remove(struct platform_device *pdev){	struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);	struct usb_hcd *hcd = NULL;	if (tegra == NULL)		return -EINVAL;	hcd = ehci_to_hcd(tegra->ehci);	if (hcd == NULL)		return -EINVAL;#ifdef CONFIG_USB_OTG_UTILS	if (tegra->transceiver) {		otg_set_host(tegra->transceiver->otg, NULL);		usb_put_transceiver(tegra->transceiver);	}#endif	if (tegra->irq)		disable_irq_wake(tegra->irq);	/* Make sure phy is powered ON to access USB register */	if(!tegra_usb_phy_hw_accessible(tegra->phy))		tegra_usb_phy_power_on(tegra->phy);	usb_remove_hcd(hcd);	tegra_usb_phy_power_off(tegra->phy);	usb_phy_shutdown(get_usb_phy(tegra->phy));	iounmap(hcd->regs);	usb_put_hcd(hcd);	return 0;}

static int tegra_ehci_remove(struct platform_device *pdev){	struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);	struct usb_hcd *hcd = NULL;	struct usb_device *rhdev = NULL;	struct tegra_usb_platform_data *pdata;	unsigned long timeout = 0;	if (tegra == NULL)		return -EINVAL;	hcd = ehci_to_hcd(tegra->ehci);	if (hcd == NULL)		return -EINVAL;#ifdef CONFIG_TEGRA_EHCI_BOOST_CPU_FREQ	cancel_delayed_work(&tegra->boost_cpu_freq_work);	pm_qos_update_request(&tegra->boost_cpu_freq_req,				PM_QOS_DEFAULT_VALUE);	tegra->cpu_boost_in_work = false;#endif	rhdev = hcd->self.root_hub;	pdata = dev_get_platdata(&pdev->dev);#ifdef CONFIG_USB_OTG_UTILS	if (tegra->transceiver) {		otg_set_host(tegra->transceiver->otg, NULL);		usb_put_transceiver(tegra->transceiver);	}#endif	if (tegra->irq)		disable_irq_wake(tegra->irq);	/* Make sure phy is powered ON to access USB register */	if(!tegra_usb_phy_hw_accessible(tegra->phy))		tegra_usb_phy_power_on(tegra->phy);	if (pdata->port_otg) {		timeout = jiffies + 5 * HZ;		/* wait for devices connected to root hub to disconnect*/		while (time_before(jiffies, timeout) &&			rhdev && rhdev->children[0])			;		/* wait for any control packets sent to root hub to complete */		mdelay(1000);	}	usb_remove_hcd(hcd);	tegra_usb_phy_power_off(tegra->phy);	usb_phy_shutdown(get_usb_phy(tegra->phy));	iounmap(hcd->regs);	usb_put_hcd(hcd);	return 0;}

static int s5p_ehci_suspend(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);	bool do_wakeup = device_may_wakeup(dev);	int rc;	rc = ehci_suspend(hcd, do_wakeup);	if (s5p_ehci->otg)		s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);	if (s5p_ehci->phy) {		/* Shutdown PHY only if it wasn't shutdown before */		if (!s5p_ehci->post_lpa_resume)			usb_phy_shutdown(s5p_ehci->phy);	} else if (s5p_ehci->pdata->phy_exit) {		s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);	}	s5p_ehci_clk_disable_unprepare(s5p_ehci);	return rc;}

static int s5p_ehci_remove(struct platform_device *pdev){	struct usb_hcd *hcd = platform_get_drvdata(pdev);	struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);	if (s5p_ehci->drvdata->rpm_enable)		pm_runtime_disable(&pdev->dev);	s5p_ehci->power_on = 0;	if (!s5p_ehci->retention)		exynos_pm_unregister_notifier(&s5p_ehci->lpa_nb);	remove_ehci_sys_file(hcd_to_ehci(hcd));	usb_remove_hcd(hcd);	if (s5p_ehci->otg)		s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);	if (s5p_ehci->phy) {		/* Shutdown PHY only if it wasn't shutdown before */		if (!s5p_ehci->post_lpa_resume)			usb_phy_shutdown(s5p_ehci->phy);	} else if (s5p_ehci->pdata->phy_exit) {		s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);	}	/* clear Host */	if (s5p_ehci->otg)		s5p_ehci->otg->host = NULL;	s5p_ehci_clk_disable_unprepare(s5p_ehci);	usb_put_hcd(hcd);	return 0;}

static int __dwc2_lowlevel_hw_disable(struct dwc2_hsotg *hsotg){	struct platform_device *pdev = to_platform_device(hsotg->dev);	int ret = 0;	if (hsotg->uphy) {		usb_phy_shutdown(hsotg->uphy);	} else if (hsotg->plat && hsotg->plat->phy_exit) {		ret = hsotg->plat->phy_exit(pdev, hsotg->plat->phy_type);	} else {		ret = phy_exit(hsotg->phy);		if (ret == 0)			ret = phy_power_off(hsotg->phy);	}	if (ret)		return ret;	if (hsotg->clk)		clk_disable_unprepare(hsotg->clk);	ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),				     hsotg->supplies);	return ret;}

static void exynos_ohci_phy_disable(struct platform_device *pdev){	struct usb_hcd *hcd = platform_get_drvdata(pdev);	struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);	if (exynos_ohci->phy)		usb_phy_shutdown(exynos_ohci->phy);}

static void pxa310_stop_otg_hc(void){	pxa310_otg_transceiver_rtsm();	otg_set_host(u2d->otg->otg, NULL);	otg_set_vbus(u2d->otg->otg, 0);	usb_phy_shutdown(u2d->otg);}

static ssize_t store_ehci_power(struct device *dev,				struct device_attribute *attr,				const char *buf, size_t count){	struct platform_device *pdev = to_platform_device(dev);	struct usb_hcd *hcd = dev_get_drvdata(dev);	struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);	int power_on;	int irq;	int retval;	if (sscanf(buf, "%d", &power_on) != 1)		return -EINVAL;	device_lock(dev);	if (!power_on && s5p_ehci->power_on) {		dev_info(dev, "EHCI turn off/n");		pm_runtime_forbid(dev);		s5p_ehci->power_on = 0;		usb_remove_hcd(hcd);		if (s5p_ehci->phy) {			/* Shutdown PHY only if it wasn't shutdown before */			if (!s5p_ehci->post_lpa_resume)				usb_phy_shutdown(s5p_ehci->phy);		} else if (s5p_ehci->pdata->phy_exit) {			s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);		}	} else if (power_on) {		dev_info(dev, "EHCI turn on/n");		if (s5p_ehci->power_on) {			pm_runtime_forbid(dev);			usb_remove_hcd(hcd);		} else {			s5p_ehci_phy_init(pdev);		}		irq = platform_get_irq(pdev, 0);		retval = usb_add_hcd(hcd, irq, IRQF_SHARED);		if (retval < 0) {			dev_err(dev, "Power On Fail/n");			goto exit;		}		/*		 * EHCI root hubs are expected to handle remote wakeup.		 * So, wakeup flag init defaults for root hubs.		 */		device_wakeup_enable(&hcd->self.root_hub->dev);		s5p_ehci->power_on = 1;		pm_runtime_allow(dev);	}exit:	device_unlock(dev);	return count;}

static void mv_otg_disable_internal(struct mv_otg *mvotg){	if (mvotg->active) {		dev_dbg(&mvotg->pdev->dev, "otg disabled/n");		usb_phy_shutdown(mvotg->outer_phy);		otg_clock_disable(mvotg);		mvotg->active = 0;	}}

static void exynos_ohci_phy_disable(struct exynos_ohci_hcd *exynos_ohci){	struct platform_device *pdev = to_platform_device(exynos_ohci->dev);	if (exynos_ohci->phy)		usb_phy_shutdown(exynos_ohci->phy);	else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_exit)		exynos_ohci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);}

static void usb_power_off(struct platform_device *pdev){	if (IS_ERR(phy))		return;	usb_phy_shutdown(phy);	pm_runtime_put_sync(&pdev->dev);	pm_runtime_disable(&pdev->dev);}

static int dsps_musb_exit(struct musb *musb){	struct device *dev = musb->controller;	struct dsps_glue *glue = dev_get_drvdata(dev->parent);	del_timer_sync(&glue->timer);	usb_phy_shutdown(musb->xceiv);	return 0;}

static void exynos_ohci_phy_disable(struct exynos_ohci_hcd *exynos_ohci){	struct platform_device *pdev = to_platform_device(exynos_ohci->dev);	if (exynos_ohci->phy) {		/* Shutdown PHY only if it wasn't shutdown before */		if (!exynos_ohci->post_lpa_resume)			usb_phy_shutdown(exynos_ohci->phy);	} else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_exit) {		exynos_ohci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);	}}

int usb_phy_reset(void  __iomem *regs){	printk("%s: %s/n", __FILE__, __func__);	usb_phy_shutdown();	gpio_set_value(HTCLEO_GPIO_USBPHY_3V3_ENABLE, 0); 	mdelay(3);	gpio_set_value(HTCLEO_GPIO_USBPHY_3V3_ENABLE, 1);	mdelay(3);	usb_config_gpio(1);	return 0;}

static int dsps_musb_exit(struct musb *musb){	struct device *dev = musb->controller;	struct dsps_glue *glue = dev_get_drvdata(dev->parent);	del_timer_sync(&musb->dev_timer);	usb_phy_shutdown(musb->xceiv);	phy_power_off(musb->phy);	phy_exit(musb->phy);	debugfs_remove_recursive(glue->dbgfs_root);	return 0;}

static int tegra_ehci_remove(struct platform_device *pdev){	struct tegra_ehci_hcd *tegra = platform_get_drvdata(pdev);	struct usb_hcd *hcd = ehci_to_hcd(tegra->ehci);	struct usb_device *rhdev = NULL;	struct tegra_usb_platform_data *pdata;	unsigned long timeout = 0;	wake_lock_destroy(&tegra->ehci_wake_lock);#ifdef CONFIG_TEGRA_EHCI_BOOST_CPU_FREQ	cancel_delayed_work_sync(&tegra->boost_cpu_freq_work);	tegra->cpu_boost_in_work = false;	pm_qos_remove_request(&tegra->boost_cpu_freq_req);#endif	rhdev = hcd->self.root_hub;	pdata = dev_get_platdata(&pdev->dev);	if (!IS_ERR_OR_NULL(tegra->transceiver))		otg_set_host(tegra->transceiver->otg, NULL);	/* Make sure phy is powered ON to access USB register */	if(!tegra_usb_phy_hw_accessible(tegra->phy))		tegra_usb_phy_power_on(tegra->phy);	if (pdata->port_otg) {		timeout = jiffies + 5 * HZ;		/* wait for devices connected to root hub to disconnect*/		while (rhdev && usb_hub_find_child(rhdev, 1)) {			/* wait for any control packets			sent to root hub to complete */			if (time_after(jiffies, timeout))				break;			msleep(20);			cpu_relax();		}	}#ifdef CONFIG_TEGRA_EHCI_BOOST_CPU_FREQ	device_remove_file(hcd->self.controller, &dev_attr_boost_enable);#endif	usb_remove_hcd(hcd);	usb_put_hcd(hcd);	tegra_usb_phy_power_off(tegra->phy);	usb_phy_shutdown(get_usb_phy(tegra->phy));	mutex_destroy(&tegra->sync_lock);	tegra_pd_remove_device(&pdev->dev);	return 0;}

static void musb_otg_notifier_work(struct work_struct *data_notifier_work){	struct musb *musb = container_of(data_notifier_work, struct musb, otg_notifier_work);	struct device *dev = musb->controller;	struct musb_hdrc_platform_data *pdata = dev->platform_data;	struct omap_musb_board_data *data = pdata->board_data;	switch (musb->xceiv_event) {	case USB_EVENT_ID:		dev_dbg(musb->controller, "ID GND/n");		if (!is_otg_enabled(musb) || musb->gadget_driver) {			pm_runtime_get_sync(musb->controller);			usb_phy_init(musb->xceiv);			omap2430_musb_set_vbus(musb, 1);		}		break;	case USB_EVENT_VBUS:		dev_dbg(musb->controller, "VBUS Connect/n");		if (musb->gadget_driver)			pm_runtime_get_sync(musb->controller);		usb_phy_init(musb->xceiv);		break;	case USB_EVENT_NONE:		dev_dbg(musb->controller, "VBUS Disconnect/n");		if (is_otg_enabled(musb) || is_peripheral_enabled(musb))			if (musb->gadget_driver) {				pm_runtime_mark_last_busy(musb->controller);				pm_runtime_put_autosuspend(musb->controller);			}		if (data->interface_type == MUSB_INTERFACE_UTMI) {			if (musb->xceiv->otg->set_vbus)				otg_set_vbus(musb->xceiv->otg, 0);		}		usb_phy_shutdown(musb->xceiv);		break;	default:		dev_dbg(musb->controller, "ID float/n");	}}

static int xhci_plat_remove(struct platform_device *dev){	struct usb_hcd	*hcd = platform_get_drvdata(dev);	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);	struct clk *clk = xhci->clk;	usb_remove_hcd(xhci->shared_hcd);	usb_phy_shutdown(hcd->usb_phy);	usb_remove_hcd(hcd);	usb_put_hcd(xhci->shared_hcd);	if (!IS_ERR(clk))		clk_disable_unprepare(clk);	usb_put_hcd(hcd);	return 0;}

static int exynos_ehci_remove(struct platform_device *pdev){	struct usb_hcd *hcd = platform_get_drvdata(pdev);	struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);	usb_remove_hcd(hcd);	if (exynos_ehci->otg)		exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);	if (exynos_ehci->phy)		usb_phy_shutdown(exynos_ehci->phy);	clk_disable_unprepare(exynos_ehci->clk);	usb_put_hcd(hcd);	return 0;}

int r8a7778_usb_phy_power(bool enable){	static struct usb_phy *phy = NULL;	int ret = 0;	if (!phy)		phy = usb_get_phy(USB_PHY_TYPE_USB2);	if (IS_ERR(phy)) {		pr_err("kernel doesn't have usb phy driver/n");		return PTR_ERR(phy);	}	if (enable)		ret = usb_phy_init(phy);	else		usb_phy_shutdown(phy);	return ret;}