xref: /linux/drivers/usb/dwc3/dwc3-exynos.c (revision 04eeb606a8383b306f4bc6991da8231b5f3924b0)
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 
32 struct 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 
42 static 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 
85 err3:
86 	platform_device_del(exynos->usb2_phy);
87 
88 err2:
89 	platform_device_put(exynos->usb3_phy);
90 
91 err1:
92 	platform_device_put(exynos->usb2_phy);
93 
94 	return ret;
95 }
96 
97 static 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 
106 static 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 
183 err4:
184 	regulator_disable(exynos->vdd10);
185 err3:
186 	regulator_disable(exynos->vdd33);
187 err2:
188 	clk_disable_unprepare(clk);
189 	return ret;
190 }
191 
192 static 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
209 static const struct of_device_id exynos_dwc3_match[] = {
210 	{ .compatible = "samsung,exynos5250-dwusb3" },
211 	{},
212 };
213 MODULE_DEVICE_TABLE(of, exynos_dwc3_match);
214 #endif
215 
216 #ifdef CONFIG_PM_SLEEP
217 static 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 
229 static 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 
255 static 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 
264 static 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 
274 module_platform_driver(dwc3_exynos_driver);
275 
276 MODULE_ALIAS("platform:exynos-dwc3");
277 MODULE_AUTHOR("Anton Tikhomirov <av.tikhomirov@samsung.com>");
278 MODULE_LICENSE("GPL v2");
279 MODULE_DESCRIPTION("DesignWare USB3 EXYNOS Glue Layer");
280