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>
 24#include <linux/phy/omap_usb.h>
 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>
 30#include <linux/phy/omap_control_phy.h>
 31#include <linux/phy/phy.h>
 32#include <linux/of_platform.h>
 33
 34#define USB2PHY_DISCON_BYP_LATCH (1 << 31)
 35#define USB2PHY_ANA_CONFIG1 0x4c
 36
 37/**
 38 * omap_usb2_set_comparator - links the comparator present in the sytem with
 39 *	this phy
 40 * @comparator - the companion phy(comparator) for this phy
 41 *
 42 * The phy companion driver should call this API passing the phy_companion
 43 * filled with set_vbus and start_srp to be used by usb phy.
 44 *
 45 * For use by phy companion driver
 46 */
 47int omap_usb2_set_comparator(struct phy_companion *comparator)
 48{
 49	struct omap_usb	*phy;
 50	struct usb_phy	*x = usb_get_phy(USB_PHY_TYPE_USB2);
 51
 52	if (IS_ERR(x))
 53		return -ENODEV;
 54
 55	phy = phy_to_omapusb(x);
 56	phy->comparator = comparator;
 57	return 0;
 58}
 59EXPORT_SYMBOL_GPL(omap_usb2_set_comparator);
 60
 61static int omap_usb_set_vbus(struct usb_otg *otg, bool enabled)
 62{
 63	struct omap_usb *phy = phy_to_omapusb(otg->phy);
 64
 65	if (!phy->comparator)
 66		return -ENODEV;
 67
 68	return phy->comparator->set_vbus(phy->comparator, enabled);
 69}
 70
 71static int omap_usb_start_srp(struct usb_otg *otg)
 72{
 73	struct omap_usb *phy = phy_to_omapusb(otg->phy);
 74
 75	if (!phy->comparator)
 76		return -ENODEV;
 77
 78	return phy->comparator->start_srp(phy->comparator);
 79}
 80
 81static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
 82{
 83	struct usb_phy	*phy = otg->phy;
 84
 85	otg->host = host;
 86	if (!host)
 87		phy->state = OTG_STATE_UNDEFINED;
 88
 89	return 0;
 90}
 91
 92static int omap_usb_set_peripheral(struct usb_otg *otg,
 93		struct usb_gadget *gadget)
 94{
 95	struct usb_phy	*phy = otg->phy;
 96
 97	otg->gadget = gadget;
 98	if (!gadget)
 99		phy->state = OTG_STATE_UNDEFINED;
100
101	return 0;
102}
103
104static int omap_usb_power_off(struct phy *x)
105{
106	struct omap_usb *phy = phy_get_drvdata(x);
107
108	omap_control_phy_power(phy->control_dev, 0);
109
110	return 0;
111}
112
113static int omap_usb_power_on(struct phy *x)
114{
115	struct omap_usb *phy = phy_get_drvdata(x);
116
117	omap_control_phy_power(phy->control_dev, 1);
118
119	return 0;
120}
121
122static int omap_usb_init(struct phy *x)
123{
124	struct omap_usb *phy = phy_get_drvdata(x);
125	u32 val;
126
127	if (phy->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
128		/*
129		 *
130		 * Reduce the sensitivity of internal PHY by enabling the
131		 * DISCON_BYP_LATCH of the USB2PHY_ANA_CONFIG1 register. This
132		 * resolves issues with certain devices which can otherwise
133		 * be prone to false disconnects.
134		 *
135		 */
136		val = omap_usb_readl(phy->phy_base, USB2PHY_ANA_CONFIG1);
137		val |= USB2PHY_DISCON_BYP_LATCH;
138		omap_usb_writel(phy->phy_base, USB2PHY_ANA_CONFIG1, val);
139	}
140
141	return 0;
142}
143
144static struct phy_ops ops = {
145	.init		= omap_usb_init,
146	.power_on	= omap_usb_power_on,
147	.power_off	= omap_usb_power_off,
148	.owner		= THIS_MODULE,
149};
150
151#ifdef CONFIG_OF
152static const struct usb_phy_data omap_usb2_data = {
153	.label = "omap_usb2",
154	.flags = OMAP_USB2_HAS_START_SRP | OMAP_USB2_HAS_SET_VBUS,
155};
156
157static const struct usb_phy_data omap5_usb2_data = {
158	.label = "omap5_usb2",
159	.flags = 0,
160};
161
162static const struct usb_phy_data dra7x_usb2_data = {
163	.label = "dra7x_usb2",
164	.flags = OMAP_USB2_CALIBRATE_FALSE_DISCONNECT,
165};
166
167static const struct usb_phy_data am437x_usb2_data = {
168	.label = "am437x_usb2",
169	.flags =  0,
170};
171
172static const struct of_device_id omap_usb2_id_table[] = {
173	{
174		.compatible = "ti,omap-usb2",
175		.data = &omap_usb2_data,
176	},
177	{
178		.compatible = "ti,omap5-usb2",
179		.data = &omap5_usb2_data,
180	},
181	{
182		.compatible = "ti,dra7x-usb2",
183		.data = &dra7x_usb2_data,
184	},
185	{
186		.compatible = "ti,am437x-usb2",
187		.data = &am437x_usb2_data,
188	},
189	{},
190};
191MODULE_DEVICE_TABLE(of, omap_usb2_id_table);
192#endif
193
194static int omap_usb2_probe(struct platform_device *pdev)
195{
196	struct omap_usb	*phy;
197	struct phy *generic_phy;
198	struct resource *res;
199	struct phy_provider *phy_provider;
200	struct usb_otg *otg;
201	struct device_node *node = pdev->dev.of_node;
202	struct device_node *control_node;
203	struct platform_device *control_pdev;
204	const struct of_device_id *of_id;
205	struct usb_phy_data *phy_data;
206
207	of_id = of_match_device(of_match_ptr(omap_usb2_id_table), &pdev->dev);
208
209	if (!of_id)
210		return -EINVAL;
211
212	phy_data = (struct usb_phy_data *)of_id->data;
213
214	phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
215	if (!phy) {
216		dev_err(&pdev->dev, "unable to allocate memory for USB2 PHY\n");
217		return -ENOMEM;
218	}
219
220	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
221	if (!otg) {
222		dev_err(&pdev->dev, "unable to allocate memory for USB OTG\n");
223		return -ENOMEM;
224	}
225
226	phy->dev		= &pdev->dev;
227
228	phy->phy.dev		= phy->dev;
229	phy->phy.label		= phy_data->label;
230	phy->phy.otg		= otg;
231	phy->phy.type		= USB_PHY_TYPE_USB2;
232
233	if (phy_data->flags & OMAP_USB2_CALIBRATE_FALSE_DISCONNECT) {
234		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
235		phy->phy_base = devm_ioremap_resource(&pdev->dev, res);
236		if (!phy->phy_base)
237			return -ENOMEM;
238		phy->flags |= OMAP_USB2_CALIBRATE_FALSE_DISCONNECT;
239	}
240
241	control_node = of_parse_phandle(node, "ctrl-module", 0);
242	if (!control_node) {
243		dev_err(&pdev->dev, "Failed to get control device phandle\n");
244		return -EINVAL;
245	}
246
247	control_pdev = of_find_device_by_node(control_node);
248	if (!control_pdev) {
249		dev_err(&pdev->dev, "Failed to get control device\n");
250		return -EINVAL;
251	}
252
253	phy->control_dev = &control_pdev->dev;
254	omap_control_phy_power(phy->control_dev, 0);
255
256	otg->set_host		= omap_usb_set_host;
257	otg->set_peripheral	= omap_usb_set_peripheral;
258	if (phy_data->flags & OMAP_USB2_HAS_SET_VBUS)
259		otg->set_vbus		= omap_usb_set_vbus;
260	if (phy_data->flags & OMAP_USB2_HAS_START_SRP)
261		otg->start_srp		= omap_usb_start_srp;
262	otg->phy		= &phy->phy;
263
264	platform_set_drvdata(pdev, phy);
265	pm_runtime_enable(phy->dev);
266
267	generic_phy = devm_phy_create(phy->dev, &ops, NULL);
268	if (IS_ERR(generic_phy))
269		return PTR_ERR(generic_phy);
270
271	phy_set_drvdata(generic_phy, phy);
272
273	phy_provider = devm_of_phy_provider_register(phy->dev,
274			of_phy_simple_xlate);
275	if (IS_ERR(phy_provider))
276		return PTR_ERR(phy_provider);
277
278	phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
279	if (IS_ERR(phy->wkupclk)) {
280		dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
281		return PTR_ERR(phy->wkupclk);
282	}
283	clk_prepare(phy->wkupclk);
284
285	phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
286	if (IS_ERR(phy->optclk))
287		dev_vdbg(&pdev->dev, "unable to get refclk960m\n");
288	else
289		clk_prepare(phy->optclk);
290
291	usb_add_phy_dev(&phy->phy);
292
293	return 0;
294}
295
296static int omap_usb2_remove(struct platform_device *pdev)
297{
298	struct omap_usb	*phy = platform_get_drvdata(pdev);
299
300	clk_unprepare(phy->wkupclk);
301	if (!IS_ERR(phy->optclk))
302		clk_unprepare(phy->optclk);
303	usb_remove_phy(&phy->phy);
304
305	return 0;
306}
307
308#ifdef CONFIG_PM_RUNTIME
309
310static int omap_usb2_runtime_suspend(struct device *dev)
311{
312	struct platform_device	*pdev = to_platform_device(dev);
313	struct omap_usb	*phy = platform_get_drvdata(pdev);
314
315	clk_disable(phy->wkupclk);
316	if (!IS_ERR(phy->optclk))
317		clk_disable(phy->optclk);
318
319	return 0;
320}
321
322static int omap_usb2_runtime_resume(struct device *dev)
323{
324	struct platform_device	*pdev = to_platform_device(dev);
325	struct omap_usb	*phy = platform_get_drvdata(pdev);
326	int ret;
327
328	ret = clk_enable(phy->wkupclk);
329	if (ret < 0) {
330		dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
331		goto err0;
332	}
333
334	if (!IS_ERR(phy->optclk)) {
335		ret = clk_enable(phy->optclk);
336		if (ret < 0) {
337			dev_err(phy->dev, "Failed to enable optclk %d\n", ret);
338			goto err1;
339		}
340	}
341
342	return 0;
343
344err1:
345	clk_disable(phy->wkupclk);
346
347err0:
348	return ret;
349}
350
351static const struct dev_pm_ops omap_usb2_pm_ops = {
352	SET_RUNTIME_PM_OPS(omap_usb2_runtime_suspend, omap_usb2_runtime_resume,
353		NULL)
354};
355
356#define DEV_PM_OPS     (&omap_usb2_pm_ops)
357#else
358#define DEV_PM_OPS     NULL
359#endif
360
361static struct platform_driver omap_usb2_driver = {
362	.probe		= omap_usb2_probe,
363	.remove		= omap_usb2_remove,
364	.driver		= {
365		.name	= "omap-usb2",
366		.owner	= THIS_MODULE,
367		.pm	= DEV_PM_OPS,
368		.of_match_table = of_match_ptr(omap_usb2_id_table),
369	},
370};
371
372module_platform_driver(omap_usb2_driver);
373
374MODULE_ALIAS("platform: omap_usb2");
375MODULE_AUTHOR("Texas Instruments Inc.");
376MODULE_DESCRIPTION("OMAP USB2 phy driver");
377MODULE_LICENSE("GPL v2");