[linux-2.6-block.git] / drivers / phy / phy-omap-usb2.c

/*
 * omap-usb2.c - USB PHY, talking to musb controller in OMAP.
 *
 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Author: Kishon Vijay Abraham I <kishon@ti.com>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/io.h>
#include <linux/phy/omap_usb.h>
#include <linux/usb/phy_companion.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/pm_runtime.h>
#include <linux/delay.h>
#include <linux/phy/omap_control_phy.h>
#include <linux/phy/phy.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>
#include <linux/of_platform.h>

#define USB2PHY_DISCON_BYP_LATCH (1 << 31)
#define USB2PHY_ANA_CONFIG1 0x4c

/**
 * omap_usb2_set_comparator - links the comparator present in the sytem with
 *	this phy
 * @comparator - the companion phy(comparator) for this phy
 *
 * The phy companion driver should call this API passing the phy_companion
 * filled with set_vbus and start_srp to be used by usb phy.
 *
 * For use by phy companion driver
 */
int omap_usb2_set_comparator(struct phy_companion *comparator)
{
	struct omap_usb	*phy;
	struct usb_phy	*x = usb_get_phy(USB_PHY_TYPE_USB2);

	if (IS_ERR(x))
		return -ENODEV;

	phy = phy_to_omapusb(x);
	phy->comparator = comparator;
	return 0;
}
EXPORT_SYMBOL_GPL(omap_usb2_set_comparator);

static int omap_usb_set_vbus(struct usb_otg *otg, bool enabled)
{
	struct omap_usb *phy = phy_to_omapusb(otg->usb_phy);

	if (!phy->comparator)
		return -ENODEV;

	return phy->comparator->set_vbus(phy->comparator, enabled);
}

static int omap_usb_start_srp(struct usb_otg *otg)
{
	struct omap_usb *phy = phy_to_omapusb(otg->usb_phy);

	if (!phy->comparator)
		return -ENODEV;

	return phy->comparator->start_srp(phy->comparator);
}

static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
{
	otg->host = host;
	if (!host)
		otg->state = OTG_STATE_UNDEFINED;

	return 0;
}

static int omap_usb_set_peripheral(struct usb_otg *otg,
		struct usb_gadget *gadget)
{
	otg->gadget = gadget;
	if (!gadget)
		otg->state = OTG_STATE_UNDEFINED;

	return 0;
}

static int omap_usb_phy_power(struct omap_usb *phy, int on)
{
	u32 val;
	int ret;

	if (!phy->syscon_phy_power) {
		omap_control_phy_power(phy->control_dev, on);
		return 0;
	}

	if (on)
		val = phy->power_on;
	else
		val = phy->power_off;

	ret = regmap_update_bits(phy->syscon_phy_power, phy->power_reg,
				 phy->mask, val);
	return ret;
}

static int omap_usb_power_off(struct phy *x)
{
	struct omap_usb *phy = phy_get_drvdata(x);

	return omap_usb_phy_power(phy, false);
}

static int omap_usb_power_on(struct phy *x)
{
	struct omap_usb *phy = phy_get_drvdata(x);

	return omap_usb_phy_power(phy, true);
}

static int omap_usb_init(struct phy *x)
{
	struct omap_usb *phy = phy_get_drvdata(x);
	u32 val;

	if (phy->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
		/*
		 *
		 * Reduce the sensitivity of internal PHY by enabling the
		 * DISCON_BYP_LATCH of the USB2PHY_ANA_CONFIG1 register. This
		 * resolves issues with certain devices which can otherwise
		 * be prone to false disconnects.
		 *
		 */
		val = omap_usb_readl(phy->phy_base, USB2PHY_ANA_CONFIG1);
		val |= USB2PHY_DISCON_BYP_LATCH;
		omap_usb_writel(phy->phy_base, USB2PHY_ANA_CONFIG1, val);
	}

	return 0;
}

static const struct phy_ops ops = {
	.init		= omap_usb_init,
	.power_on	= omap_usb_power_on,
	.power_off	= omap_usb_power_off,
	.owner		= THIS_MODULE,
};

static const struct usb_phy_data omap_usb2_data = {
	.label = "omap_usb2",
	.flags = OMAP_USB2_HAS_START_SRP | OMAP_USB2_HAS_SET_VBUS,
	.mask = OMAP_DEV_PHY_PD,
	.power_off = OMAP_DEV_PHY_PD,
};

static const struct usb_phy_data omap5_usb2_data = {
	.label = "omap5_usb2",
	.flags = 0,
	.mask = OMAP_DEV_PHY_PD,
	.power_off = OMAP_DEV_PHY_PD,
};

static const struct usb_phy_data dra7x_usb2_data = {
	.label = "dra7x_usb2",
	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	.mask = OMAP_DEV_PHY_PD,
	.power_off = OMAP_DEV_PHY_PD,
};

static const struct usb_phy_data dra7x_usb2_phy2_data = {
	.label = "dra7x_usb2_phy2",
	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	.mask = OMAP_USB2_PHY_PD,
	.power_off = OMAP_USB2_PHY_PD,
};

static const struct usb_phy_data am437x_usb2_data = {
	.label = "am437x_usb2",
	.flags =  0,
	.mask = AM437X_USB2_PHY_PD | AM437X_USB2_OTG_PD |
		AM437X_USB2_OTGVDET_EN | AM437X_USB2_OTGSESSEND_EN,
	.power_on = AM437X_USB2_OTGVDET_EN | AM437X_USB2_OTGSESSEND_EN,
	.power_off = AM437X_USB2_PHY_PD | AM437X_USB2_OTG_PD,
};

static const struct of_device_id omap_usb2_id_table[] = {
	{
		.compatible = "ti,omap-usb2",
		.data = &omap_usb2_data,
	},
	{
		.compatible = "ti,omap5-usb2",
		.data = &omap5_usb2_data,
	},
	{
		.compatible = "ti,dra7x-usb2",
		.data = &dra7x_usb2_data,
	},
	{
		.compatible = "ti,dra7x-usb2-phy2",
		.data = &dra7x_usb2_phy2_data,
	},
	{
		.compatible = "ti,am437x-usb2",
		.data = &am437x_usb2_data,
	},
	{},
};
MODULE_DEVICE_TABLE(of, omap_usb2_id_table);

static int omap_usb2_probe(struct platform_device *pdev)
{
	struct omap_usb	*phy;
	struct phy *generic_phy;
	struct resource *res;
	struct phy_provider *phy_provider;
	struct usb_otg *otg;
	struct device_node *node = pdev->dev.of_node;
	struct device_node *control_node;
	struct platform_device *control_pdev;
	const struct of_device_id *of_id;
	struct usb_phy_data *phy_data;

	of_id = of_match_device(omap_usb2_id_table, &pdev->dev);

	if (!of_id)
		return -EINVAL;

	phy_data = (struct usb_phy_data *)of_id->data;

	phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
	if (!phy)
		return -ENOMEM;

	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
	if (!otg)
		return -ENOMEM;

	phy->dev		= &pdev->dev;

	phy->phy.dev		= phy->dev;
	phy->phy.label		= phy_data->label;
	phy->phy.otg		= otg;
	phy->phy.type		= USB_PHY_TYPE_USB2;
	phy->mask		= phy_data->mask;
	phy->power_on		= phy_data->power_on;
	phy->power_off		= phy_data->power_off;

	if (phy_data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		phy->phy_base = devm_ioremap_resource(&pdev->dev, res);
		if (IS_ERR(phy->phy_base))
			return PTR_ERR(phy->phy_base);
		phy->flags |= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT;
	}

	phy->syscon_phy_power = syscon_regmap_lookup_by_phandle(node,
							"syscon-phy-power");
	if (IS_ERR(phy->syscon_phy_power)) {
		dev_dbg(&pdev->dev,
			"can't get syscon-phy-power, using control device\n");
		phy->syscon_phy_power = NULL;

		control_node = of_parse_phandle(node, "ctrl-module", 0);
		if (!control_node) {
			dev_err(&pdev->dev,
				"Failed to get control device phandle\n");
			return -EINVAL;
		}

		control_pdev = of_find_device_by_node(control_node);
		if (!control_pdev) {
			dev_err(&pdev->dev, "Failed to get control device\n");
			return -EINVAL;
		}
		phy->control_dev = &control_pdev->dev;
	} else {
		if (of_property_read_u32_index(node,
					       "syscon-phy-power", 1,
					       &phy->power_reg)) {
			dev_err(&pdev->dev,
				"couldn't get power reg. offset\n");
			return -EINVAL;
		}
	}

	otg->set_host		= omap_usb_set_host;
	otg->set_peripheral	= omap_usb_set_peripheral;
	if (phy_data->flags & OMAP_USB2_HAS_SET_VBUS)
		otg->set_vbus		= omap_usb_set_vbus;
	if (phy_data->flags & OMAP_USB2_HAS_START_SRP)
		otg->start_srp		= omap_usb_start_srp;
	otg->usb_phy		= &phy->phy;

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

	generic_phy = devm_phy_create(phy->dev, NULL, &ops);
	if (IS_ERR(generic_phy)) {
		pm_runtime_disable(phy->dev);
		return PTR_ERR(generic_phy);
	}

	phy_set_drvdata(generic_phy, phy);
	omap_usb_power_off(generic_phy);

	phy_provider = devm_of_phy_provider_register(phy->dev,
			of_phy_simple_xlate);
	if (IS_ERR(phy_provider)) {
		pm_runtime_disable(phy->dev);
		return PTR_ERR(phy_provider);
	}

	phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
	if (IS_ERR(phy->wkupclk)) {
		dev_warn(&pdev->dev, "unable to get wkupclk, trying old name\n");
		phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
		if (IS_ERR(phy->wkupclk)) {
			dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
			pm_runtime_disable(phy->dev);
			return PTR_ERR(phy->wkupclk);
		} else {
			dev_warn(&pdev->dev,
				 "found usb_phy_cm_clk32k, please fix DTS\n");
		}
	}
	clk_prepare(phy->wkupclk);

	phy->optclk = devm_clk_get(phy->dev, "refclk");
	if (IS_ERR(phy->optclk)) {
		dev_dbg(&pdev->dev, "unable to get refclk, trying old name\n");
		phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
		if (IS_ERR(phy->optclk)) {
			dev_dbg(&pdev->dev,
				"unable to get usb_otg_ss_refclk960m\n");
		} else {
			dev_warn(&pdev->dev,
				 "found usb_otg_ss_refclk960m, please fix DTS\n");
		}
	}

	if (!IS_ERR(phy->optclk))
		clk_prepare(phy->optclk);

	usb_add_phy_dev(&phy->phy);

	return 0;
}

static int omap_usb2_remove(struct platform_device *pdev)
{
	struct omap_usb	*phy = platform_get_drvdata(pdev);

	clk_unprepare(phy->wkupclk);
	if (!IS_ERR(phy->optclk))
		clk_unprepare(phy->optclk);
	usb_remove_phy(&phy->phy);
	pm_runtime_disable(phy->dev);

	return 0;
}

#ifdef CONFIG_PM

static int omap_usb2_runtime_suspend(struct device *dev)
{
	struct platform_device	*pdev = to_platform_device(dev);
	struct omap_usb	*phy = platform_get_drvdata(pdev);

	clk_disable(phy->wkupclk);
	if (!IS_ERR(phy->optclk))
		clk_disable(phy->optclk);

	return 0;
}

static int omap_usb2_runtime_resume(struct device *dev)
{
	struct platform_device	*pdev = to_platform_device(dev);
	struct omap_usb	*phy = platform_get_drvdata(pdev);
	int ret;

	ret = clk_enable(phy->wkupclk);
	if (ret < 0) {
		dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
		goto err0;
	}

	if (!IS_ERR(phy->optclk)) {
		ret = clk_enable(phy->optclk);
		if (ret < 0) {
			dev_err(phy->dev, "Failed to enable optclk %d\n", ret);
			goto err1;
		}
	}

	return 0;

err1:
	clk_disable(phy->wkupclk);

err0:
	return ret;
}

static const struct dev_pm_ops omap_usb2_pm_ops = {
	SET_RUNTIME_PM_OPS(omap_usb2_runtime_suspend, omap_usb2_runtime_resume,
		NULL)
};

#define DEV_PM_OPS     (&omap_usb2_pm_ops)
#else
#define DEV_PM_OPS     NULL
#endif

static struct platform_driver omap_usb2_driver = {
	.probe		= omap_usb2_probe,
	.remove		= omap_usb2_remove,
	.driver		= {
		.name	= "omap-usb2",
		.pm	= DEV_PM_OPS,
		.of_match_table = omap_usb2_id_table,
	},
};

module_platform_driver(omap_usb2_driver);

MODULE_ALIAS("platform:omap_usb2");
MODULE_AUTHOR("Texas Instruments Inc.");
MODULE_DESCRIPTION("OMAP USB2 phy driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
657b306a KVA	1	/*
	2	* omap-usb2.c - USB PHY, talking to musb controller in OMAP.
	3	*
	4	* Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* Author: Kishon Vijay Abraham I <kishon@ti.com>
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	*/
	18
	19	#include <linux/module.h>
	20	#include <linux/platform_device.h>
	21	#include <linux/slab.h>
	22	#include <linux/of.h>
	23	#include <linux/io.h>
6284be23	24	#include <linux/phy/omap_usb.h>
657b306a KVA	25	#include <linux/usb/phy_companion.h>
	26	#include <linux/clk.h>
	27	#include <linux/err.h>
	28	#include <linux/pm_runtime.h>
	29	#include <linux/delay.h>
14da699b	30	#include <linux/phy/omap_control_phy.h>
5d93d1e7	31	#include <linux/phy/phy.h>
9955a783 KVA	32	#include <linux/mfd/syscon.h>
9955a783 KVA	33	#include <linux/regmap.h>
478b6c74	34	#include <linux/of_platform.h>
657b306a	35
7e472402 AB	36	#define USB2PHY_DISCON_BYP_LATCH (1 << 31)
	37	#define USB2PHY_ANA_CONFIG1 0x4c
	38
657b306a KVA	39	/**
	40	* omap_usb2_set_comparator - links the comparator present in the sytem with
	41	* this phy
	42	* @comparator - the companion phy(comparator) for this phy
	43	*
	44	* The phy companion driver should call this API passing the phy_companion
	45	* filled with set_vbus and start_srp to be used by usb phy.
	46	*
	47	* For use by phy companion driver
	48	*/
	49	int omap_usb2_set_comparator(struct phy_companion *comparator)
	50	{
	51	struct omap_usb *phy;
	52	struct usb_phy *x = usb_get_phy(USB_PHY_TYPE_USB2);
	53
	54	if (IS_ERR(x))
	55	return -ENODEV;
	56
	57	phy = phy_to_omapusb(x);
	58	phy->comparator = comparator;
	59	return 0;
	60	}
	61	EXPORT_SYMBOL_GPL(omap_usb2_set_comparator);
	62
657b306a KVA	63	static int omap_usb_set_vbus(struct usb_otg *otg, bool enabled)
657b306a KVA	64	{
19c1eac2	65	struct omap_usb *phy = phy_to_omapusb(otg->usb_phy);
657b306a KVA	66
	67	if (!phy->comparator)
	68	return -ENODEV;
	69
	70	return phy->comparator->set_vbus(phy->comparator, enabled);
	71	}
	72
	73	static int omap_usb_start_srp(struct usb_otg *otg)
	74	{
19c1eac2	75	struct omap_usb *phy = phy_to_omapusb(otg->usb_phy);
657b306a KVA	76
	77	if (!phy->comparator)
	78	return -ENODEV;
	79
	80	return phy->comparator->start_srp(phy->comparator);
	81	}
	82
	83	static int omap_usb_set_host(struct usb_otg otg, struct usb_bus host)
	84	{
657b306a KVA	85	otg->host = host;
657b306a KVA	86	if (!host)
e47d9254	87	otg->state = OTG_STATE_UNDEFINED;
657b306a KVA	88
	89	return 0;
	90	}
	91
	92	static int omap_usb_set_peripheral(struct usb_otg *otg,
	93	struct usb_gadget *gadget)
	94	{
657b306a KVA	95	otg->gadget = gadget;
657b306a KVA	96	if (!gadget)
e47d9254	97	otg->state = OTG_STATE_UNDEFINED;
657b306a KVA	98
	99	return 0;
	100	}
	101
9955a783 KVA	102	static int omap_usb_phy_power(struct omap_usb *phy, int on)
	103	{
	104	u32 val;
	105	int ret;
	106
	107	if (!phy->syscon_phy_power) {
	108	omap_control_phy_power(phy->control_dev, on);
	109	return 0;
	110	}
	111
	112	if (on)
	113	val = phy->power_on;
	114	else
	115	val = phy->power_off;
	116
	117	ret = regmap_update_bits(phy->syscon_phy_power, phy->power_reg,
	118	phy->mask, val);
	119	return ret;
	120	}
	121
5d93d1e7 KVA	122	static int omap_usb_power_off(struct phy *x)
	123	{
	124	struct omap_usb *phy = phy_get_drvdata(x);
	125
9955a783	126	return omap_usb_phy_power(phy, false);
5d93d1e7 KVA	127	}
	128
	129	static int omap_usb_power_on(struct phy *x)
	130	{
	131	struct omap_usb *phy = phy_get_drvdata(x);
	132
9955a783	133	return omap_usb_phy_power(phy, true);
5d93d1e7 KVA	134	}
5d93d1e7 KVA	135
7e472402 AB	136	static int omap_usb_init(struct phy *x)
	137	{
	138	struct omap_usb *phy = phy_get_drvdata(x);
	139	u32 val;
	140
	141	if (phy->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
	142	/*
	143	*
	144	* Reduce the sensitivity of internal PHY by enabling the
	145	* DISCON_BYP_LATCH of the USB2PHY_ANA_CONFIG1 register. This
	146	* resolves issues with certain devices which can otherwise
	147	* be prone to false disconnects.
	148	*
	149	*/
	150	val = omap_usb_readl(phy->phy_base, USB2PHY_ANA_CONFIG1);
	151	val \|= USB2PHY_DISCON_BYP_LATCH;
	152	omap_usb_writel(phy->phy_base, USB2PHY_ANA_CONFIG1, val);
	153	}
	154
	155	return 0;
	156	}
	157
4a9e5ca1	158	static const struct phy_ops ops = {
7e472402	159	.init = omap_usb_init,
5d93d1e7 KVA	160	.power_on = omap_usb_power_on,
	161	.power_off = omap_usb_power_off,
	162	.owner = THIS_MODULE,
	163	};
	164
09a0168d GC	165	static const struct usb_phy_data omap_usb2_data = {
	166	.label = "omap_usb2",
	167	.flags = OMAP_USB2_HAS_START_SRP \| OMAP_USB2_HAS_SET_VBUS,
9955a783 KVA	168	.mask = OMAP_DEV_PHY_PD,
9955a783 KVA	169	.power_off = OMAP_DEV_PHY_PD,
09a0168d GC	170	};
09a0168d GC	171
db68e80f GC	172	static const struct usb_phy_data omap5_usb2_data = {
	173	.label = "omap5_usb2",
	174	.flags = 0,
9955a783 KVA	175	.mask = OMAP_DEV_PHY_PD,
9955a783 KVA	176	.power_off = OMAP_DEV_PHY_PD,
db68e80f GC	177	};
db68e80f GC	178
7e472402 AB	179	static const struct usb_phy_data dra7x_usb2_data = {
	180	.label = "dra7x_usb2",
	181	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
9955a783 KVA	182	.mask = OMAP_DEV_PHY_PD,
	183	.power_off = OMAP_DEV_PHY_PD,
	184	};
	185
	186	static const struct usb_phy_data dra7x_usb2_phy2_data = {
	187	.label = "dra7x_usb2_phy2",
	188	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
	189	.mask = OMAP_USB2_PHY_PD,
	190	.power_off = OMAP_USB2_PHY_PD,
7e472402 AB	191	};
7e472402 AB	192
09a0168d GC	193	static const struct usb_phy_data am437x_usb2_data = {
	194	.label = "am437x_usb2",
	195	.flags = 0,
9955a783 KVA	196	.mask = AM437X_USB2_PHY_PD \| AM437X_USB2_OTG_PD \|
	197	AM437X_USB2_OTGVDET_EN \| AM437X_USB2_OTGSESSEND_EN,
	198	.power_on = AM437X_USB2_OTGVDET_EN \| AM437X_USB2_OTGSESSEND_EN,
	199	.power_off = AM437X_USB2_PHY_PD \| AM437X_USB2_OTG_PD,
09a0168d GC	200	};
	201
	202	static const struct of_device_id omap_usb2_id_table[] = {
	203	{
	204	.compatible = "ti,omap-usb2",
	205	.data = &omap_usb2_data,
	206	},
db68e80f GC	207	{
	208	.compatible = "ti,omap5-usb2",
	209	.data = &omap5_usb2_data,
	210	},
7e472402 AB	211	{
	212	.compatible = "ti,dra7x-usb2",
	213	.data = &dra7x_usb2_data,
	214	},
9955a783 KVA	215	{
	216	.compatible = "ti,dra7x-usb2-phy2",
	217	.data = &dra7x_usb2_phy2_data,
	218	},
09a0168d GC	219	{
	220	.compatible = "ti,am437x-usb2",
	221	.data = &am437x_usb2_data,
	222	},
	223	{},
	224	};
	225	MODULE_DEVICE_TABLE(of, omap_usb2_id_table);
09a0168d	226
41ac7b3a	227	static int omap_usb2_probe(struct platform_device *pdev)
657b306a	228	{
478b6c74 RQ	229	struct omap_usb *phy;
478b6c74 RQ	230	struct phy *generic_phy;
7e472402	231	struct resource *res;
478b6c74 RQ	232	struct phy_provider *phy_provider;
	233	struct usb_otg *otg;
	234	struct device_node *node = pdev->dev.of_node;
	235	struct device_node *control_node;
	236	struct platform_device *control_pdev;
09a0168d GC	237	const struct of_device_id *of_id;
	238	struct usb_phy_data *phy_data;
	239
52a4a72a	240	of_id = of_match_device(omap_usb2_id_table, &pdev->dev);
478b6c74	241
09a0168d	242	if (!of_id)
478b6c74	243	return -EINVAL;
657b306a	244
09a0168d GC	245	phy_data = (struct usb_phy_data *)of_id->data;
09a0168d GC	246
657b306a	247	phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
0b68253d	248	if (!phy)
657b306a	249	return -ENOMEM;
657b306a KVA	250
657b306a KVA	251	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
0b68253d	252	if (!otg)
657b306a	253	return -ENOMEM;
657b306a KVA	254
	255	phy->dev = &pdev->dev;
	256
	257	phy->phy.dev = phy->dev;
09a0168d	258	phy->phy.label = phy_data->label;
657b306a	259	phy->phy.otg = otg;
c11747f6	260	phy->phy.type = USB_PHY_TYPE_USB2;
9955a783 KVA	261	phy->mask = phy_data->mask;
	262	phy->power_on = phy_data->power_on;
	263	phy->power_off = phy_data->power_off;
657b306a	264
7e472402 AB	265	if (phy_data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
	266	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	267	phy->phy_base = devm_ioremap_resource(&pdev->dev, res);
3df9fcd5 HS	268	if (IS_ERR(phy->phy_base))
3df9fcd5 HS	269	return PTR_ERR(phy->phy_base);
7e472402 AB	270	phy->flags \|= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT;
	271	}
	272
9955a783 KVA	273	phy->syscon_phy_power = syscon_regmap_lookup_by_phandle(node,
	274	"syscon-phy-power");
	275	if (IS_ERR(phy->syscon_phy_power)) {
	276	dev_dbg(&pdev->dev,
	277	"can't get syscon-phy-power, using control device\n");
	278	phy->syscon_phy_power = NULL;
	279
	280	control_node = of_parse_phandle(node, "ctrl-module", 0);
	281	if (!control_node) {
	282	dev_err(&pdev->dev,
	283	"Failed to get control device phandle\n");
	284	return -EINVAL;
	285	}
	286
	287	control_pdev = of_find_device_by_node(control_node);
	288	if (!control_pdev) {
	289	dev_err(&pdev->dev, "Failed to get control device\n");
	290	return -EINVAL;
	291	}
	292	phy->control_dev = &control_pdev->dev;
	293	} else {
	294	if (of_property_read_u32_index(node,
	295	"syscon-phy-power", 1,
	296	&phy->power_reg)) {
	297	dev_err(&pdev->dev,
	298	"couldn't get power reg. offset\n");
	299	return -EINVAL;
	300	}
657b306a KVA	301	}
657b306a KVA	302
657b306a KVA	303	otg->set_host = omap_usb_set_host;
657b306a KVA	304	otg->set_peripheral = omap_usb_set_peripheral;
09a0168d GC	305	if (phy_data->flags & OMAP_USB2_HAS_SET_VBUS)
	306	otg->set_vbus = omap_usb_set_vbus;
	307	if (phy_data->flags & OMAP_USB2_HAS_START_SRP)
	308	otg->start_srp = omap_usb_start_srp;
19c1eac2	309	otg->usb_phy = &phy->phy;
657b306a	310
5d93d1e7	311	platform_set_drvdata(pdev, phy);
f20531a9	312	pm_runtime_enable(phy->dev);
5d93d1e7	313
dbc98635	314	generic_phy = devm_phy_create(phy->dev, NULL, &ops);
f20531a9 OG	315	if (IS_ERR(generic_phy)) {
f20531a9 OG	316	pm_runtime_disable(phy->dev);
5d93d1e7	317	return PTR_ERR(generic_phy);
f20531a9	318	}
5d93d1e7 KVA	319
5d93d1e7 KVA	320	phy_set_drvdata(generic_phy, phy);
86c574e4	321	omap_usb_power_off(generic_phy);
5d93d1e7	322
64fe1891 KVA	323	phy_provider = devm_of_phy_provider_register(phy->dev,
64fe1891 KVA	324	of_phy_simple_xlate);
eb82a3d8 RQ	325	if (IS_ERR(phy_provider)) {
eb82a3d8 RQ	326	pm_runtime_disable(phy->dev);
64fe1891	327	return PTR_ERR(phy_provider);
eb82a3d8	328	}
64fe1891	329
9f1d8ed2	330	phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
657b306a	331	if (IS_ERR(phy->wkupclk)) {
9f1d8ed2 RQ	332	dev_warn(&pdev->dev, "unable to get wkupclk, trying old name\n");
	333	phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
	334	if (IS_ERR(phy->wkupclk)) {
	335	dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
4581f798	336	pm_runtime_disable(phy->dev);
9f1d8ed2 RQ	337	return PTR_ERR(phy->wkupclk);
	338	} else {
	339	dev_warn(&pdev->dev,
	340	"found usb_phy_cm_clk32k, please fix DTS\n");
	341	}
657b306a KVA	342	}
	343	clk_prepare(phy->wkupclk);
	344
9f1d8ed2 RQ	345	phy->optclk = devm_clk_get(phy->dev, "refclk");
	346	if (IS_ERR(phy->optclk)) {
	347	dev_dbg(&pdev->dev, "unable to get refclk, trying old name\n");
	348	phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
	349	if (IS_ERR(phy->optclk)) {
	350	dev_dbg(&pdev->dev,
	351	"unable to get usb_otg_ss_refclk960m\n");
	352	} else {
	353	dev_warn(&pdev->dev,
	354	"found usb_otg_ss_refclk960m, please fix DTS\n");
	355	}
9f1d8ed2	356	}
0c4c8bbb	357
b1ff3231 AL	358	if (!IS_ERR(phy->optclk))
	359	clk_prepare(phy->optclk);
	360
c11747f6	361	usb_add_phy_dev(&phy->phy);
657b306a	362
657b306a KVA	363	return 0;
	364	}
	365
fb4e98ab	366	static int omap_usb2_remove(struct platform_device *pdev)
657b306a KVA	367	{
	368	struct omap_usb *phy = platform_get_drvdata(pdev);
	369
	370	clk_unprepare(phy->wkupclk);
0c4c8bbb KVA	371	if (!IS_ERR(phy->optclk))
0c4c8bbb KVA	372	clk_unprepare(phy->optclk);
657b306a	373	usb_remove_phy(&phy->phy);
eb82a3d8	374	pm_runtime_disable(phy->dev);
657b306a KVA	375
	376	return 0;
	377	}
	378
7ba37053	379	#ifdef CONFIG_PM
657b306a KVA	380
	381	static int omap_usb2_runtime_suspend(struct device *dev)
	382	{
	383	struct platform_device *pdev = to_platform_device(dev);
	384	struct omap_usb *phy = platform_get_drvdata(pdev);
	385
	386	clk_disable(phy->wkupclk);
0c4c8bbb KVA	387	if (!IS_ERR(phy->optclk))
0c4c8bbb KVA	388	clk_disable(phy->optclk);
657b306a KVA	389
	390	return 0;
	391	}
	392
	393	static int omap_usb2_runtime_resume(struct device *dev)
	394	{
657b306a KVA	395	struct platform_device *pdev = to_platform_device(dev);
657b306a KVA	396	struct omap_usb *phy = platform_get_drvdata(pdev);
0f827684	397	int ret;
657b306a KVA	398
657b306a KVA	399	ret = clk_enable(phy->wkupclk);
0c4c8bbb	400	if (ret < 0) {
657b306a	401	dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
0c4c8bbb KVA	402	goto err0;
	403	}
	404
	405	if (!IS_ERR(phy->optclk)) {
	406	ret = clk_enable(phy->optclk);
	407	if (ret < 0) {
	408	dev_err(phy->dev, "Failed to enable optclk %d\n", ret);
	409	goto err1;
	410	}
	411	}
	412
	413	return 0;
	414
	415	err1:
	416	clk_disable(phy->wkupclk);
657b306a	417
0c4c8bbb	418	err0:
657b306a KVA	419	return ret;
	420	}
	421
	422	static const struct dev_pm_ops omap_usb2_pm_ops = {
	423	SET_RUNTIME_PM_OPS(omap_usb2_runtime_suspend, omap_usb2_runtime_resume,
	424	NULL)
	425	};
	426
	427	#define DEV_PM_OPS (&omap_usb2_pm_ops)
	428	#else
	429	#define DEV_PM_OPS NULL
	430	#endif
	431
657b306a KVA	432	static struct platform_driver omap_usb2_driver = {
657b306a KVA	433	.probe = omap_usb2_probe,
7690417d	434	.remove = omap_usb2_remove,
657b306a KVA	435	.driver = {
657b306a KVA	436	.name = "omap-usb2",
657b306a	437	.pm = DEV_PM_OPS,
52a4a72a	438	.of_match_table = omap_usb2_id_table,
657b306a KVA	439	},
	440	};
	441
	442	module_platform_driver(omap_usb2_driver);
	443
dd64ad38	444	MODULE_ALIAS("platform:omap_usb2");
657b306a KVA	445	MODULE_AUTHOR("Texas Instruments Inc.");
	446	MODULE_DESCRIPTION("OMAP USB2 phy driver");
	447	MODULE_LICENSE("GPL v2");