phy: rename struct omap_control_usb to struct omap_control_phy (14da699b) · Commits · 戴 / test

drivers/phy/Kconfig

+12 −2

Original line number	Original line	Diff line number	Diff line
	@@ -31,12 +31,22 @@ config PHY_MVEBU_SATA
	depends on OF		depends on OF
	select GENERIC_PHY		select GENERIC_PHY

			config OMAP_CONTROL_PHY
			tristate "OMAP CONTROL PHY Driver"
			help
			Enable this to add support for the PHY part present in the control
			module. This driver has API to power on the USB2 PHY and to write to
			the mailbox. The mailbox is present only in omap4 and the register to
			power on the USB2 PHY is present in OMAP4 and OMAP5. OMAP5 has an
			additional register to power on USB3 PHY/SATA PHY/PCIE PHY
			(PIPE3 PHY).

	config OMAP_USB2		config OMAP_USB2
	tristate "OMAP USB2 PHY Driver"		tristate "OMAP USB2 PHY Driver"
	depends on ARCH_OMAP2PLUS		depends on ARCH_OMAP2PLUS
	depends on USB_PHY		depends on USB_PHY
	select GENERIC_PHY		select GENERIC_PHY
	select OMAP_CONTROL_USB		select OMAP_CONTROL_PHY
	help		help
	Enable this to support the transceiver that is part of SOC. This		Enable this to support the transceiver that is part of SOC. This
	driver takes care of all the PHY functionality apart from comparator.		driver takes care of all the PHY functionality apart from comparator.
	@@ -47,7 +57,7 @@ config TI_PIPE3
	tristate "TI PIPE3 PHY Driver"		tristate "TI PIPE3 PHY Driver"
	depends on ARCH_OMAP2PLUS \|\| COMPILE_TEST		depends on ARCH_OMAP2PLUS \|\| COMPILE_TEST
	select GENERIC_PHY		select GENERIC_PHY
	select OMAP_CONTROL_USB		select OMAP_CONTROL_PHY
	help		help
	Enable this to support the PIPE3 PHY that is part of TI SOCs. This		Enable this to support the PIPE3 PHY that is part of TI SOCs. This
	driver takes care of all the PHY functionality apart from comparator.		driver takes care of all the PHY functionality apart from comparator.

drivers/phy/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -7,6 +7,7 @@ obj-$(CONFIG_BCM_KONA_USB2_PHY) += phy-bcm-kona-usb2.o
	obj-$(CONFIG_PHY_EXYNOS_DP_VIDEO) += phy-exynos-dp-video.o		obj-$(CONFIG_PHY_EXYNOS_DP_VIDEO) += phy-exynos-dp-video.o
	obj-$(CONFIG_PHY_EXYNOS_MIPI_VIDEO) += phy-exynos-mipi-video.o		obj-$(CONFIG_PHY_EXYNOS_MIPI_VIDEO) += phy-exynos-mipi-video.o
	obj-$(CONFIG_PHY_MVEBU_SATA) += phy-mvebu-sata.o		obj-$(CONFIG_PHY_MVEBU_SATA) += phy-mvebu-sata.o
			obj-$(CONFIG_OMAP_CONTROL_PHY) += phy-omap-control.o
	obj-$(CONFIG_OMAP_USB2) += phy-omap-usb2.o		obj-$(CONFIG_OMAP_USB2) += phy-omap-usb2.o
	obj-$(CONFIG_TI_PIPE3) += phy-ti-pipe3.o		obj-$(CONFIG_TI_PIPE3) += phy-ti-pipe3.o
	obj-$(CONFIG_TWL4030_USB) += phy-twl4030-usb.o		obj-$(CONFIG_TWL4030_USB) += phy-twl4030-usb.o

drivers/usb/phy/phy-omap-control.c→drivers/phy/phy-omap-control.c

+83 −82

Original line number	Original line	Diff line number	Diff line
	/*		/*
	* omap-control-usb.c - The USB part of control module.		* omap-control-phy.c - The PHY part of control module.
	*		*
	* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com		* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
	* This program is free software; you can redistribute it and/or modify		* This program is free software; you can redistribute it and/or modify
	@@ -24,36 +24,36 @@
	#include <linux/err.h>		#include <linux/err.h>
	#include <linux/io.h>		#include <linux/io.h>
	#include <linux/clk.h>		#include <linux/clk.h>
	#include <linux/usb/omap_control_usb.h>		#include <linux/phy/omap_control_phy.h>

	/**		/**
	* omap_control_usb_phy_power - power on/off the phy using control module reg		* omap_control_phy_power - power on/off the phy using control module reg
	* @dev: the control module device		* @dev: the control module device
	* @on: 0 or 1, based on powering on or off the PHY		* @on: 0 or 1, based on powering on or off the PHY
	*/		*/
	void omap_control_usb_phy_power(struct device *dev, int on)		void omap_control_phy_power(struct device *dev, int on)
	{		{
	u32 val;		u32 val;
	unsigned long rate;		unsigned long rate;
	struct omap_control_usb *control_usb;		struct omap_control_phy *control_phy;

	if (IS_ERR(dev) \|\| !dev) {		if (IS_ERR(dev) \|\| !dev) {
	pr_err("%s: invalid device\n", __func__);		pr_err("%s: invalid device\n", __func__);
	return;		return;
	}		}

	control_usb = dev_get_drvdata(dev);		control_phy = dev_get_drvdata(dev);
	if (!control_usb) {		if (!control_phy) {
	dev_err(dev, "%s: invalid control usb device\n", __func__);		dev_err(dev, "%s: invalid control phy device\n", __func__);
	return;		return;
	}		}

	if (control_usb->type == OMAP_CTRL_TYPE_OTGHS)		if (control_phy->type == OMAP_CTRL_TYPE_OTGHS)
	return;		return;

	val = readl(control_usb->power);		val = readl(control_phy->power);

	switch (control_usb->type) {		switch (control_phy->type) {
	case OMAP_CTRL_TYPE_USB2:		case OMAP_CTRL_TYPE_USB2:
	if (on)		if (on)
	val &= ~OMAP_CTRL_DEV_PHY_PD;		val &= ~OMAP_CTRL_DEV_PHY_PD;
	@@ -62,19 +62,20 @@ void omap_control_usb_phy_power(struct device *dev, int on)
	break;		break;

	case OMAP_CTRL_TYPE_PIPE3:		case OMAP_CTRL_TYPE_PIPE3:
	rate = clk_get_rate(control_usb->sys_clk);		rate = clk_get_rate(control_phy->sys_clk);
	rate = rate/1000000;		rate = rate/1000000;

	if (on) {		if (on) {
	val &= ~(OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK \|		val &= ~(OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_MASK \|
	OMAP_CTRL_USB_PWRCTL_CLK_FREQ_MASK);		OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_MASK);
	val \|= OMAP_CTRL_USB3_PHY_TX_RX_POWERON <<		val \|= OMAP_CTRL_PIPE3_PHY_TX_RX_POWERON <<
	OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;		OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT;
	val \|= rate << OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT;		val \|= rate <<
			OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_SHIFT;
	} else {		} else {
	val &= ~OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK;		val &= ~OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_MASK;
	val \|= OMAP_CTRL_USB3_PHY_TX_RX_POWEROFF <<		val \|= OMAP_CTRL_PIPE3_PHY_TX_RX_POWEROFF <<
	OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;		OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT;
	}		}
	break;		break;

	@@ -100,66 +101,66 @@ void omap_control_usb_phy_power(struct device *dev, int on)
	break;		break;
	default:		default:
	dev_err(dev, "%s: type %d not recognized\n",		dev_err(dev, "%s: type %d not recognized\n",
	__func__, control_usb->type);		__func__, control_phy->type);
	break;		break;
	}		}

	writel(val, control_usb->power);		writel(val, control_phy->power);
	}		}
	EXPORT_SYMBOL_GPL(omap_control_usb_phy_power);		EXPORT_SYMBOL_GPL(omap_control_phy_power);

	/**		/**
	* omap_control_usb_host_mode - set AVALID, VBUSVALID and ID pin in grounded		* omap_control_usb_host_mode - set AVALID, VBUSVALID and ID pin in grounded
	* @ctrl_usb: struct omap_control_usb *		* @ctrl_phy: struct omap_control_phy *
	*		*
	* Writes to the mailbox register to notify the usb core that a usb		* Writes to the mailbox register to notify the usb core that a usb
	* device has been connected.		* device has been connected.
	*/		*/
	static void omap_control_usb_host_mode(struct omap_control_usb *ctrl_usb)		static void omap_control_usb_host_mode(struct omap_control_phy *ctrl_phy)
	{		{
	u32 val;		u32 val;

	val = readl(ctrl_usb->otghs_control);		val = readl(ctrl_phy->otghs_control);
	val &= ~(OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_SESSEND);		val &= ~(OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_SESSEND);
	val \|= OMAP_CTRL_DEV_AVALID \| OMAP_CTRL_DEV_VBUSVALID;		val \|= OMAP_CTRL_DEV_AVALID \| OMAP_CTRL_DEV_VBUSVALID;
	writel(val, ctrl_usb->otghs_control);		writel(val, ctrl_phy->otghs_control);
	}		}

	/**		/**
	* omap_control_usb_device_mode - set AVALID, VBUSVALID and ID pin in high		* omap_control_usb_device_mode - set AVALID, VBUSVALID and ID pin in high
	* impedance		* impedance
	* @ctrl_usb: struct omap_control_usb *		* @ctrl_phy: struct omap_control_phy *
	*		*
	* Writes to the mailbox register to notify the usb core that it has been		* Writes to the mailbox register to notify the usb core that it has been
	* connected to a usb host.		* connected to a usb host.
	*/		*/
	static void omap_control_usb_device_mode(struct omap_control_usb *ctrl_usb)		static void omap_control_usb_device_mode(struct omap_control_phy *ctrl_phy)
	{		{
	u32 val;		u32 val;

	val = readl(ctrl_usb->otghs_control);		val = readl(ctrl_phy->otghs_control);
	val &= ~OMAP_CTRL_DEV_SESSEND;		val &= ~OMAP_CTRL_DEV_SESSEND;
	val \|= OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_AVALID \|		val \|= OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_AVALID \|
	OMAP_CTRL_DEV_VBUSVALID;		OMAP_CTRL_DEV_VBUSVALID;
	writel(val, ctrl_usb->otghs_control);		writel(val, ctrl_phy->otghs_control);
	}		}

	/**		/**
	* omap_control_usb_set_sessionend - Enable SESSIONEND and IDIG to high		* omap_control_usb_set_sessionend - Enable SESSIONEND and IDIG to high
	* impedance		* impedance
	* @ctrl_usb: struct omap_control_usb *		* @ctrl_phy: struct omap_control_phy *
	*		*
	* Writes to the mailbox register to notify the usb core it's now in		* Writes to the mailbox register to notify the usb core it's now in
	* disconnected state.		* disconnected state.
	*/		*/
	static void omap_control_usb_set_sessionend(struct omap_control_usb *ctrl_usb)		static void omap_control_usb_set_sessionend(struct omap_control_phy *ctrl_phy)
	{		{
	u32 val;		u32 val;

	val = readl(ctrl_usb->otghs_control);		val = readl(ctrl_phy->otghs_control);
	val &= ~(OMAP_CTRL_DEV_AVALID \| OMAP_CTRL_DEV_VBUSVALID);		val &= ~(OMAP_CTRL_DEV_AVALID \| OMAP_CTRL_DEV_VBUSVALID);
	val \|= OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_SESSEND;		val \|= OMAP_CTRL_DEV_IDDIG \| OMAP_CTRL_DEV_SESSEND;
	writel(val, ctrl_usb->otghs_control);		writel(val, ctrl_phy->otghs_control);
	}		}

	/**		/**
	@@ -174,30 +175,30 @@ static void omap_control_usb_set_sessionend(struct omap_control_usb *ctrl_usb)
	void omap_control_usb_set_mode(struct device *dev,		void omap_control_usb_set_mode(struct device *dev,
	enum omap_control_usb_mode mode)		enum omap_control_usb_mode mode)
	{		{
	struct omap_control_usb *ctrl_usb;		struct omap_control_phy *ctrl_phy;

	if (IS_ERR(dev) \|\| !dev)		if (IS_ERR(dev) \|\| !dev)
	return;		return;

	ctrl_usb = dev_get_drvdata(dev);		ctrl_phy = dev_get_drvdata(dev);

	if (!ctrl_usb) {		if (!ctrl_phy) {
	dev_err(dev, "Invalid control usb device\n");		dev_err(dev, "Invalid control phy device\n");
	return;		return;
	}		}

	if (ctrl_usb->type != OMAP_CTRL_TYPE_OTGHS)		if (ctrl_phy->type != OMAP_CTRL_TYPE_OTGHS)
	return;		return;

	switch (mode) {		switch (mode) {
	case USB_MODE_HOST:		case USB_MODE_HOST:
	omap_control_usb_host_mode(ctrl_usb);		omap_control_usb_host_mode(ctrl_phy);
	break;		break;
	case USB_MODE_DEVICE:		case USB_MODE_DEVICE:
	omap_control_usb_device_mode(ctrl_usb);		omap_control_usb_device_mode(ctrl_phy);
	break;		break;
	case USB_MODE_DISCONNECT:		case USB_MODE_DISCONNECT:
	omap_control_usb_set_sessionend(ctrl_usb);		omap_control_usb_set_sessionend(ctrl_phy);
	break;		break;
	default:		default:
	dev_vdbg(dev, "invalid omap control usb mode\n");		dev_vdbg(dev, "invalid omap control usb mode\n");
	@@ -207,13 +208,13 @@ EXPORT_SYMBOL_GPL(omap_control_usb_set_mode);

	#ifdef CONFIG_OF		#ifdef CONFIG_OF

	static const enum omap_control_usb_type otghs_data = OMAP_CTRL_TYPE_OTGHS;		static const enum omap_control_phy_type otghs_data = OMAP_CTRL_TYPE_OTGHS;
	static const enum omap_control_usb_type usb2_data = OMAP_CTRL_TYPE_USB2;		static const enum omap_control_phy_type usb2_data = OMAP_CTRL_TYPE_USB2;
	static const enum omap_control_usb_type pipe3_data = OMAP_CTRL_TYPE_PIPE3;		static const enum omap_control_phy_type pipe3_data = OMAP_CTRL_TYPE_PIPE3;
	static const enum omap_control_usb_type dra7usb2_data = OMAP_CTRL_TYPE_DRA7USB2;		static const enum omap_control_phy_type dra7usb2_data = OMAP_CTRL_TYPE_DRA7USB2;
	static const enum omap_control_usb_type am437usb2_data = OMAP_CTRL_TYPE_AM437USB2;		static const enum omap_control_phy_type am437usb2_data = OMAP_CTRL_TYPE_AM437USB2;

	static const struct of_device_id omap_control_usb_id_table[] = {		static const struct of_device_id omap_control_phy_id_table[] = {
	{		{
	.compatible = "ti,control-phy-otghs",		.compatible = "ti,control-phy-otghs",
	.data = &otghs_data,		.data = &otghs_data,
	@@ -236,84 +237,84 @@ static const struct of_device_id omap_control_usb_id_table[] = {
	},		},
	{},		{},
	};		};
	MODULE_DEVICE_TABLE(of, omap_control_usb_id_table);		MODULE_DEVICE_TABLE(of, omap_control_phy_id_table);
	#endif		#endif


	static int omap_control_usb_probe(struct platform_device *pdev)		static int omap_control_phy_probe(struct platform_device *pdev)
	{		{
	struct resource *res;		struct resource *res;
	const struct of_device_id *of_id;		const struct of_device_id *of_id;
	struct omap_control_usb *control_usb;		struct omap_control_phy *control_phy;

	of_id = of_match_device(of_match_ptr(omap_control_usb_id_table),		of_id = of_match_device(of_match_ptr(omap_control_phy_id_table),
	&pdev->dev);		&pdev->dev);
	if (!of_id)		if (!of_id)
	return -EINVAL;		return -EINVAL;

	control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb),		control_phy = devm_kzalloc(&pdev->dev, sizeof(*control_phy),
	GFP_KERNEL);		GFP_KERNEL);
	if (!control_usb) {		if (!control_phy) {
	dev_err(&pdev->dev, "unable to alloc memory for control usb\n");		dev_err(&pdev->dev, "unable to alloc memory for control phy\n");
	return -ENOMEM;		return -ENOMEM;
	}		}

	control_usb->dev = &pdev->dev;		control_phy->dev = &pdev->dev;
	control_usb->type = (enum omap_control_usb_type )of_id->data;		control_phy->type = (enum omap_control_phy_type )of_id->data;

	if (control_usb->type == OMAP_CTRL_TYPE_OTGHS) {		if (control_phy->type == OMAP_CTRL_TYPE_OTGHS) {
	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
	"otghs_control");		"otghs_control");
	control_usb->otghs_control = devm_ioremap_resource(		control_phy->otghs_control = devm_ioremap_resource(
	&pdev->dev, res);		&pdev->dev, res);
	if (IS_ERR(control_usb->otghs_control))		if (IS_ERR(control_phy->otghs_control))
	return PTR_ERR(control_usb->otghs_control);		return PTR_ERR(control_phy->otghs_control);
	} else {		} else {
	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,		res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
	"power");		"power");
	control_usb->power = devm_ioremap_resource(&pdev->dev, res);		control_phy->power = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(control_usb->power)) {		if (IS_ERR(control_phy->power)) {
	dev_err(&pdev->dev, "Couldn't get power register\n");		dev_err(&pdev->dev, "Couldn't get power register\n");
	return PTR_ERR(control_usb->power);		return PTR_ERR(control_phy->power);
	}		}
	}		}

	if (control_usb->type == OMAP_CTRL_TYPE_PIPE3) {		if (control_phy->type == OMAP_CTRL_TYPE_PIPE3) {
	control_usb->sys_clk = devm_clk_get(control_usb->dev,		control_phy->sys_clk = devm_clk_get(control_phy->dev,
	"sys_clkin");		"sys_clkin");
	if (IS_ERR(control_usb->sys_clk)) {		if (IS_ERR(control_phy->sys_clk)) {
	pr_err("%s: unable to get sys_clkin\n", __func__);		pr_err("%s: unable to get sys_clkin\n", __func__);
	return -EINVAL;		return -EINVAL;
	}		}
	}		}

	dev_set_drvdata(control_usb->dev, control_usb);		dev_set_drvdata(control_phy->dev, control_phy);

	return 0;		return 0;
	}		}

	static struct platform_driver omap_control_usb_driver = {		static struct platform_driver omap_control_phy_driver = {
	.probe = omap_control_usb_probe,		.probe = omap_control_phy_probe,
	.driver = {		.driver = {
	.name = "omap-control-usb",		.name = "omap-control-phy",
	.owner = THIS_MODULE,		.owner = THIS_MODULE,
	.of_match_table = of_match_ptr(omap_control_usb_id_table),		.of_match_table = of_match_ptr(omap_control_phy_id_table),
	},		},
	};		};

	static int __init omap_control_usb_init(void)		static int __init omap_control_phy_init(void)
	{		{
	return platform_driver_register(&omap_control_usb_driver);		return platform_driver_register(&omap_control_phy_driver);
	}		}
	subsys_initcall(omap_control_usb_init);		subsys_initcall(omap_control_phy_init);

	static void __exit omap_control_usb_exit(void)		static void __exit omap_control_phy_exit(void)
	{		{
	platform_driver_unregister(&omap_control_usb_driver);		platform_driver_unregister(&omap_control_phy_driver);
	}		}
	module_exit(omap_control_usb_exit);		module_exit(omap_control_phy_exit);

	MODULE_ALIAS("platform: omap_control_usb");		MODULE_ALIAS("platform: omap_control_phy");
	MODULE_AUTHOR("Texas Instruments Inc.");		MODULE_AUTHOR("Texas Instruments Inc.");
	MODULE_DESCRIPTION("OMAP Control Module USB Driver");		MODULE_DESCRIPTION("OMAP Control Module PHY Driver");
	MODULE_LICENSE("GPL v2");		MODULE_LICENSE("GPL v2");

drivers/phy/phy-omap-usb2.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,7 @@
	#include <linux/err.h>		#include <linux/err.h>
	#include <linux/pm_runtime.h>		#include <linux/pm_runtime.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/usb/omap_control_usb.h>		#include <linux/phy/omap_control_phy.h>
	#include <linux/phy/phy.h>		#include <linux/phy/phy.h>
	#include <linux/of_platform.h>		#include <linux/of_platform.h>

	@@ -105,7 +105,7 @@ static int omap_usb_power_off(struct phy *x)
	{		{
	struct omap_usb *phy = phy_get_drvdata(x);		struct omap_usb *phy = phy_get_drvdata(x);

	omap_control_usb_phy_power(phy->control_dev, 0);		omap_control_phy_power(phy->control_dev, 0);

	return 0;		return 0;
	}		}
	@@ -114,7 +114,7 @@ static int omap_usb_power_on(struct phy *x)
	{		{
	struct omap_usb *phy = phy_get_drvdata(x);		struct omap_usb *phy = phy_get_drvdata(x);

	omap_control_usb_phy_power(phy->control_dev, 1);		omap_control_phy_power(phy->control_dev, 1);

	return 0;		return 0;
	}		}
	@@ -251,7 +251,7 @@ static int omap_usb2_probe(struct platform_device *pdev)
	}		}

	phy->control_dev = &control_pdev->dev;		phy->control_dev = &control_pdev->dev;
	omap_control_usb_phy_power(phy->control_dev, 0);		omap_control_phy_power(phy->control_dev, 0);

	otg->set_host = omap_usb_set_host;		otg->set_host = omap_usb_set_host;
	otg->set_peripheral = omap_usb_set_peripheral;		otg->set_peripheral = omap_usb_set_peripheral;

drivers/phy/phy-ti-pipe3.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -26,7 +26,7 @@
	#include <linux/io.h>		#include <linux/io.h>
	#include <linux/pm_runtime.h>		#include <linux/pm_runtime.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/usb/omap_control_usb.h>		#include <linux/phy/omap_control_phy.h>
	#include <linux/of_platform.h>		#include <linux/of_platform.h>

	#define PLL_STATUS 0x00000004		#define PLL_STATUS 0x00000004
	@@ -134,7 +134,7 @@ static int ti_pipe3_power_off(struct phy *x)
	return -EBUSY;		return -EBUSY;
	}		}

	omap_control_usb_phy_power(phy->control_dev, 0);		omap_control_phy_power(phy->control_dev, 0);

	return 0;		return 0;
	}		}
	@@ -232,7 +232,7 @@ static int ti_pipe3_init(struct phy *x)
	if (ret)		if (ret)
	return ret;		return ret;

	omap_control_usb_phy_power(phy->control_dev, 1);		omap_control_phy_power(phy->control_dev, 1);

	return 0;		return 0;
	}		}
	@@ -304,7 +304,7 @@ static int ti_pipe3_probe(struct platform_device *pdev)

	phy->control_dev = &control_pdev->dev;		phy->control_dev = &control_pdev->dev;

	omap_control_usb_phy_power(phy->control_dev, 0);		omap_control_phy_power(phy->control_dev, 0);

	platform_set_drvdata(pdev, phy);		platform_set_drvdata(pdev, phy);
	pm_runtime_enable(phy->dev);		pm_runtime_enable(phy->dev);

Admin message