1/**
2 * dwc3-exynos.c - Samsung EXYNOS DWC3 Specific Glue layer
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 *		http://www.samsung.com
6 *
7 * Author: Anton Tikhomirov <av.tikhomirov@samsung.com>
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2  of
11 * the License as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 */
18
19#include <linux/module.h>
20#include <linux/kernel.h>
21#include <linux/slab.h>
22#include <linux/platform_device.h>
23#include <linux/platform_data/dwc3-exynos.h>
24#include <linux/dma-mapping.h>
25#include <linux/clk.h>
26#include <linux/usb/otg.h>
27#include <linux/usb/usb_phy_generic.h>
28#include <linux/of.h>
29#include <linux/of_platform.h>
30#include <linux/regulator/consumer.h>
31
32struct dwc3_exynos {
33	struct platform_device	*usb2_phy;
34	struct platform_device	*usb3_phy;
35	struct device		*dev;
36
37	struct clk		*clk;
38	struct regulator	*vdd33;
39	struct regulator	*vdd10;
40};
41
42static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
43{
44	struct usb_phy_generic_platform_data pdata;
45	struct platform_device	*pdev;
46	int			ret;
47
48	memset(&pdata, 0x00, sizeof(pdata));
49
50	pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
51	if (!pdev)
52		return -ENOMEM;
53
54	exynos->usb2_phy = pdev;
55	pdata.type = USB_PHY_TYPE_USB2;
56	pdata.gpio_reset = -1;
57
58	ret = platform_device_add_data(exynos->usb2_phy, &pdata, sizeof(pdata));
59	if (ret)
60		goto err1;
61
62	pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
63	if (!pdev) {
64		ret = -ENOMEM;
65		goto err1;
66	}
67
68	exynos->usb3_phy = pdev;
69	pdata.type = USB_PHY_TYPE_USB3;
70
71	ret = platform_device_add_data(exynos->usb3_phy, &pdata, sizeof(pdata));
72	if (ret)
73		goto err2;
74
75	ret = platform_device_add(exynos->usb2_phy);
76	if (ret)
77		goto err2;
78
79	ret = platform_device_add(exynos->usb3_phy);
80	if (ret)
81		goto err3;
82
83	return 0;
84
85err3:
86	platform_device_del(exynos->usb2_phy);
87
88err2:
89	platform_device_put(exynos->usb3_phy);
90
91err1:
92	platform_device_put(exynos->usb2_phy);
93
94	return ret;
95}
96
97static int dwc3_exynos_remove_child(struct device *dev, void *unused)
98{
99	struct platform_device *pdev = to_platform_device(dev);
100
101	platform_device_unregister(pdev);
102
103	return 0;
104}
105
106static int dwc3_exynos_probe(struct platform_device *pdev)
107{
108	struct dwc3_exynos	*exynos;
109	struct clk		*clk;
110	struct device		*dev = &pdev->dev;
111	struct device_node	*node = dev->of_node;
112
113	int			ret;
114
115	exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL);
116	if (!exynos)
117		return -ENOMEM;
118
119	/*
120	 * Right now device-tree probed devices don't get dma_mask set.
121	 * Since shared usb code relies on it, set it here for now.
122	 * Once we move to full device tree support this will vanish off.
123	 */
124	ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
125	if (ret)
126		return ret;
127
128	platform_set_drvdata(pdev, exynos);
129
130	ret = dwc3_exynos_register_phys(exynos);
131	if (ret) {
132		dev_err(dev, "couldn't register PHYs\n");
133		return ret;
134	}
135
136	clk = devm_clk_get(dev, "usbdrd30");
137	if (IS_ERR(clk)) {
138		dev_err(dev, "couldn't get clock\n");
139		return -EINVAL;
140	}
141
142	exynos->dev	= dev;
143	exynos->clk	= clk;
144
145	clk_prepare_enable(exynos->clk);
146
147	exynos->vdd33 = devm_regulator_get(dev, "vdd33");
148	if (IS_ERR(exynos->vdd33)) {
149		ret = PTR_ERR(exynos->vdd33);
150		goto err2;
151	}
152	ret = regulator_enable(exynos->vdd33);
153	if (ret) {
154		dev_err(dev, "Failed to enable VDD33 supply\n");
155		goto err2;
156	}
157
158	exynos->vdd10 = devm_regulator_get(dev, "vdd10");
159	if (IS_ERR(exynos->vdd10)) {
160		ret = PTR_ERR(exynos->vdd10);
161		goto err3;
162	}
163	ret = regulator_enable(exynos->vdd10);
164	if (ret) {
165		dev_err(dev, "Failed to enable VDD10 supply\n");
166		goto err3;
167	}
168
169	if (node) {
170		ret = of_platform_populate(node, NULL, NULL, dev);
171		if (ret) {
172			dev_err(dev, "failed to add dwc3 core\n");
173			goto err4;
174		}
175	} else {
176		dev_err(dev, "no device node, failed to add dwc3 core\n");
177		ret = -ENODEV;
178		goto err4;
179	}
180
181	return 0;
182
183err4:
184	regulator_disable(exynos->vdd10);
185err3:
186	regulator_disable(exynos->vdd33);
187err2:
188	clk_disable_unprepare(clk);
189	return ret;
190}
191
192static int dwc3_exynos_remove(struct platform_device *pdev)
193{
194	struct dwc3_exynos	*exynos = platform_get_drvdata(pdev);
195
196	device_for_each_child(&pdev->dev, NULL, dwc3_exynos_remove_child);
197	platform_device_unregister(exynos->usb2_phy);
198	platform_device_unregister(exynos->usb3_phy);
199
200	clk_disable_unprepare(exynos->clk);
201
202	regulator_disable(exynos->vdd33);
203	regulator_disable(exynos->vdd10);
204
205	return 0;
206}
207
208#ifdef CONFIG_OF
209static const struct of_device_id exynos_dwc3_match[] = {
210	{ .compatible = "samsung,exynos5250-dwusb3" },
211	{},
212};
213MODULE_DEVICE_TABLE(of, exynos_dwc3_match);
214#endif
215
216#ifdef CONFIG_PM_SLEEP
217static int dwc3_exynos_suspend(struct device *dev)
218{
219	struct dwc3_exynos *exynos = dev_get_drvdata(dev);
220
221	clk_disable(exynos->clk);
222
223	regulator_disable(exynos->vdd33);
224	regulator_disable(exynos->vdd10);
225
226	return 0;
227}
228
229static int dwc3_exynos_resume(struct device *dev)
230{
231	struct dwc3_exynos *exynos = dev_get_drvdata(dev);
232	int ret;
233
234	ret = regulator_enable(exynos->vdd33);
235	if (ret) {
236		dev_err(dev, "Failed to enable VDD33 supply\n");
237		return ret;
238	}
239	ret = regulator_enable(exynos->vdd10);
240	if (ret) {
241		dev_err(dev, "Failed to enable VDD10 supply\n");
242		return ret;
243	}
244
245	clk_enable(exynos->clk);
246
247	/* runtime set active to reflect active state. */
248	pm_runtime_disable(dev);
249	pm_runtime_set_active(dev);
250	pm_runtime_enable(dev);
251
252	return 0;
253}
254
255static const struct dev_pm_ops dwc3_exynos_dev_pm_ops = {
256	SET_SYSTEM_SLEEP_PM_OPS(dwc3_exynos_suspend, dwc3_exynos_resume)
257};
258
259#define DEV_PM_OPS	(&dwc3_exynos_dev_pm_ops)
260#else
261#define DEV_PM_OPS	NULL
262#endif /* CONFIG_PM_SLEEP */
263
264static struct platform_driver dwc3_exynos_driver = {
265	.probe		= dwc3_exynos_probe,
266	.remove		= dwc3_exynos_remove,
267	.driver		= {
268		.name	= "exynos-dwc3",
269		.of_match_table = of_match_ptr(exynos_dwc3_match),
270		.pm	= DEV_PM_OPS,
271	},
272};
273
274module_platform_driver(dwc3_exynos_driver);
275
276MODULE_ALIAS("platform:exynos-dwc3");
277MODULE_AUTHOR("Anton Tikhomirov <av.tikhomirov@samsung.com>");
278MODULE_LICENSE("GPL v2");
279MODULE_DESCRIPTION("DesignWare USB3 EXYNOS Glue Layer");
280