1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Samsung Exynos USB HOST EHCI Controller |
4 | * |
5 | * Copyright (C) 2011 Samsung Electronics Co.Ltd |
6 | * Author: Jingoo Han <jg1.han@samsung.com> |
7 | * Author: Joonyoung Shim <jy0922.shim@samsung.com> |
8 | */ |
9 | |
10 | #include <linux/clk.h> |
11 | #include <linux/dma-mapping.h> |
12 | #include <linux/io.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/of.h> |
16 | #include <linux/gpio/consumer.h> |
17 | #include <linux/phy/phy.h> |
18 | #include <linux/platform_device.h> |
19 | #include <linux/usb.h> |
20 | #include <linux/usb/hcd.h> |
21 | |
22 | #include "ehci.h" |
23 | |
24 | #define DRIVER_DESC "EHCI Exynos driver" |
25 | |
26 | #define EHCI_INSNREG00(base) (base + 0x90) |
27 | #define EHCI_INSNREG00_ENA_INCR16 (0x1 << 25) |
28 | #define EHCI_INSNREG00_ENA_INCR8 (0x1 << 24) |
29 | #define EHCI_INSNREG00_ENA_INCR4 (0x1 << 23) |
30 | #define EHCI_INSNREG00_ENA_INCRX_ALIGN (0x1 << 22) |
31 | #define EHCI_INSNREG00_ENABLE_DMA_BURST \ |
32 | (EHCI_INSNREG00_ENA_INCR16 | EHCI_INSNREG00_ENA_INCR8 | \ |
33 | EHCI_INSNREG00_ENA_INCR4 | EHCI_INSNREG00_ENA_INCRX_ALIGN) |
34 | |
35 | static struct hc_driver __read_mostly exynos_ehci_hc_driver; |
36 | |
37 | #define PHY_NUMBER 3 |
38 | |
39 | struct exynos_ehci_hcd { |
40 | struct clk *clk; |
41 | struct device_node *of_node; |
42 | struct phy *phy[PHY_NUMBER]; |
43 | bool legacy_phy; |
44 | }; |
45 | |
46 | #define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv) |
47 | |
48 | static int exynos_ehci_get_phy(struct device *dev, |
49 | struct exynos_ehci_hcd *exynos_ehci) |
50 | { |
51 | struct device_node *child; |
52 | struct phy *phy; |
53 | int phy_number, num_phys; |
54 | int ret; |
55 | |
56 | /* Get PHYs for the controller */ |
57 | num_phys = of_count_phandle_with_args(np: dev->of_node, list_name: "phys" , |
58 | cells_name: "#phy-cells" ); |
59 | for (phy_number = 0; phy_number < num_phys; phy_number++) { |
60 | phy = devm_of_phy_get_by_index(dev, np: dev->of_node, index: phy_number); |
61 | if (IS_ERR(ptr: phy)) |
62 | return PTR_ERR(ptr: phy); |
63 | exynos_ehci->phy[phy_number] = phy; |
64 | } |
65 | if (num_phys > 0) |
66 | return 0; |
67 | |
68 | /* Get PHYs using legacy bindings */ |
69 | for_each_available_child_of_node(dev->of_node, child) { |
70 | ret = of_property_read_u32(np: child, propname: "reg" , out_value: &phy_number); |
71 | if (ret) { |
72 | dev_err(dev, "Failed to parse device tree\n" ); |
73 | of_node_put(node: child); |
74 | return ret; |
75 | } |
76 | |
77 | if (phy_number >= PHY_NUMBER) { |
78 | dev_err(dev, "Invalid number of PHYs\n" ); |
79 | of_node_put(node: child); |
80 | return -EINVAL; |
81 | } |
82 | |
83 | phy = devm_of_phy_optional_get(dev, np: child, NULL); |
84 | exynos_ehci->phy[phy_number] = phy; |
85 | if (IS_ERR(ptr: phy)) { |
86 | of_node_put(node: child); |
87 | return PTR_ERR(ptr: phy); |
88 | } |
89 | } |
90 | |
91 | exynos_ehci->legacy_phy = true; |
92 | return 0; |
93 | } |
94 | |
95 | static int exynos_ehci_phy_enable(struct device *dev) |
96 | { |
97 | struct usb_hcd *hcd = dev_get_drvdata(dev); |
98 | struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); |
99 | int i; |
100 | int ret = 0; |
101 | |
102 | for (i = 0; ret == 0 && i < PHY_NUMBER; i++) |
103 | ret = phy_power_on(phy: exynos_ehci->phy[i]); |
104 | if (ret) |
105 | for (i--; i >= 0; i--) |
106 | phy_power_off(phy: exynos_ehci->phy[i]); |
107 | |
108 | return ret; |
109 | } |
110 | |
111 | static void exynos_ehci_phy_disable(struct device *dev) |
112 | { |
113 | struct usb_hcd *hcd = dev_get_drvdata(dev); |
114 | struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); |
115 | int i; |
116 | |
117 | for (i = 0; i < PHY_NUMBER; i++) |
118 | phy_power_off(phy: exynos_ehci->phy[i]); |
119 | } |
120 | |
121 | static void exynos_setup_vbus_gpio(struct device *dev) |
122 | { |
123 | struct gpio_desc *gpio; |
124 | int err; |
125 | |
126 | gpio = devm_gpiod_get_optional(dev, con_id: "samsung,vbus" , flags: GPIOD_OUT_HIGH); |
127 | err = PTR_ERR_OR_ZERO(ptr: gpio); |
128 | if (err) |
129 | dev_err(dev, "can't request ehci vbus gpio: %d\n" , err); |
130 | } |
131 | |
132 | static int exynos_ehci_probe(struct platform_device *pdev) |
133 | { |
134 | struct exynos_ehci_hcd *exynos_ehci; |
135 | struct usb_hcd *hcd; |
136 | struct ehci_hcd *ehci; |
137 | struct resource *res; |
138 | int irq; |
139 | int err; |
140 | |
141 | /* |
142 | * Right now device-tree probed devices don't get dma_mask set. |
143 | * Since shared usb code relies on it, set it here for now. |
144 | * Once we move to full device tree support this will vanish off. |
145 | */ |
146 | err = dma_coerce_mask_and_coherent(dev: &pdev->dev, DMA_BIT_MASK(32)); |
147 | if (err) |
148 | return err; |
149 | |
150 | exynos_setup_vbus_gpio(dev: &pdev->dev); |
151 | |
152 | hcd = usb_create_hcd(driver: &exynos_ehci_hc_driver, |
153 | dev: &pdev->dev, bus_name: dev_name(dev: &pdev->dev)); |
154 | if (!hcd) { |
155 | dev_err(&pdev->dev, "Unable to create HCD\n" ); |
156 | return -ENOMEM; |
157 | } |
158 | exynos_ehci = to_exynos_ehci(hcd); |
159 | |
160 | err = exynos_ehci_get_phy(dev: &pdev->dev, exynos_ehci); |
161 | if (err) |
162 | goto fail_clk; |
163 | |
164 | exynos_ehci->clk = devm_clk_get(dev: &pdev->dev, id: "usbhost" ); |
165 | |
166 | if (IS_ERR(ptr: exynos_ehci->clk)) { |
167 | dev_err(&pdev->dev, "Failed to get usbhost clock\n" ); |
168 | err = PTR_ERR(ptr: exynos_ehci->clk); |
169 | goto fail_clk; |
170 | } |
171 | |
172 | err = clk_prepare_enable(clk: exynos_ehci->clk); |
173 | if (err) |
174 | goto fail_clk; |
175 | |
176 | hcd->regs = devm_platform_get_and_ioremap_resource(pdev, index: 0, res: &res); |
177 | if (IS_ERR(ptr: hcd->regs)) { |
178 | err = PTR_ERR(ptr: hcd->regs); |
179 | goto fail_io; |
180 | } |
181 | |
182 | hcd->rsrc_start = res->start; |
183 | hcd->rsrc_len = resource_size(res); |
184 | |
185 | irq = platform_get_irq(pdev, 0); |
186 | if (irq < 0) { |
187 | err = irq; |
188 | goto fail_io; |
189 | } |
190 | |
191 | err = exynos_ehci_phy_enable(dev: &pdev->dev); |
192 | if (err) { |
193 | dev_err(&pdev->dev, "Failed to enable USB phy\n" ); |
194 | goto fail_io; |
195 | } |
196 | |
197 | ehci = hcd_to_ehci(hcd); |
198 | ehci->caps = hcd->regs; |
199 | |
200 | /* |
201 | * Workaround: reset of_node pointer to avoid conflict between legacy |
202 | * Exynos EHCI port subnodes and generic USB device bindings |
203 | */ |
204 | exynos_ehci->of_node = pdev->dev.of_node; |
205 | if (exynos_ehci->legacy_phy) |
206 | pdev->dev.of_node = NULL; |
207 | |
208 | /* DMA burst Enable */ |
209 | writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs)); |
210 | |
211 | err = usb_add_hcd(hcd, irqnum: irq, IRQF_SHARED); |
212 | if (err) { |
213 | dev_err(&pdev->dev, "Failed to add USB HCD\n" ); |
214 | goto fail_add_hcd; |
215 | } |
216 | device_wakeup_enable(dev: hcd->self.controller); |
217 | |
218 | platform_set_drvdata(pdev, data: hcd); |
219 | |
220 | return 0; |
221 | |
222 | fail_add_hcd: |
223 | exynos_ehci_phy_disable(dev: &pdev->dev); |
224 | pdev->dev.of_node = exynos_ehci->of_node; |
225 | fail_io: |
226 | clk_disable_unprepare(clk: exynos_ehci->clk); |
227 | fail_clk: |
228 | usb_put_hcd(hcd); |
229 | return err; |
230 | } |
231 | |
232 | static void exynos_ehci_remove(struct platform_device *pdev) |
233 | { |
234 | struct usb_hcd *hcd = platform_get_drvdata(pdev); |
235 | struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); |
236 | |
237 | pdev->dev.of_node = exynos_ehci->of_node; |
238 | |
239 | usb_remove_hcd(hcd); |
240 | |
241 | exynos_ehci_phy_disable(dev: &pdev->dev); |
242 | |
243 | clk_disable_unprepare(clk: exynos_ehci->clk); |
244 | |
245 | usb_put_hcd(hcd); |
246 | } |
247 | |
248 | #ifdef CONFIG_PM |
249 | static int exynos_ehci_suspend(struct device *dev) |
250 | { |
251 | struct usb_hcd *hcd = dev_get_drvdata(dev); |
252 | struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); |
253 | |
254 | bool do_wakeup = device_may_wakeup(dev); |
255 | int rc; |
256 | |
257 | rc = ehci_suspend(hcd, do_wakeup); |
258 | if (rc) |
259 | return rc; |
260 | |
261 | exynos_ehci_phy_disable(dev); |
262 | |
263 | clk_disable_unprepare(clk: exynos_ehci->clk); |
264 | |
265 | return rc; |
266 | } |
267 | |
268 | static int exynos_ehci_resume(struct device *dev) |
269 | { |
270 | struct usb_hcd *hcd = dev_get_drvdata(dev); |
271 | struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd); |
272 | int ret; |
273 | |
274 | ret = clk_prepare_enable(clk: exynos_ehci->clk); |
275 | if (ret) |
276 | return ret; |
277 | |
278 | ret = exynos_ehci_phy_enable(dev); |
279 | if (ret) { |
280 | dev_err(dev, "Failed to enable USB phy\n" ); |
281 | clk_disable_unprepare(clk: exynos_ehci->clk); |
282 | return ret; |
283 | } |
284 | |
285 | /* DMA burst Enable */ |
286 | writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs)); |
287 | |
288 | ehci_resume(hcd, force_reset: false); |
289 | return 0; |
290 | } |
291 | #else |
292 | #define exynos_ehci_suspend NULL |
293 | #define exynos_ehci_resume NULL |
294 | #endif |
295 | |
296 | static const struct dev_pm_ops exynos_ehci_pm_ops = { |
297 | .suspend = exynos_ehci_suspend, |
298 | .resume = exynos_ehci_resume, |
299 | }; |
300 | |
301 | #ifdef CONFIG_OF |
302 | static const struct of_device_id exynos_ehci_match[] = { |
303 | { .compatible = "samsung,exynos4210-ehci" }, |
304 | {}, |
305 | }; |
306 | MODULE_DEVICE_TABLE(of, exynos_ehci_match); |
307 | #endif |
308 | |
309 | static struct platform_driver exynos_ehci_driver = { |
310 | .probe = exynos_ehci_probe, |
311 | .remove_new = exynos_ehci_remove, |
312 | .shutdown = usb_hcd_platform_shutdown, |
313 | .driver = { |
314 | .name = "exynos-ehci" , |
315 | .pm = &exynos_ehci_pm_ops, |
316 | .of_match_table = of_match_ptr(exynos_ehci_match), |
317 | } |
318 | }; |
319 | static const struct ehci_driver_overrides exynos_overrides __initconst = { |
320 | .extra_priv_size = sizeof(struct exynos_ehci_hcd), |
321 | }; |
322 | |
323 | static int __init ehci_exynos_init(void) |
324 | { |
325 | if (usb_disabled()) |
326 | return -ENODEV; |
327 | |
328 | ehci_init_driver(drv: &exynos_ehci_hc_driver, over: &exynos_overrides); |
329 | return platform_driver_register(&exynos_ehci_driver); |
330 | } |
331 | module_init(ehci_exynos_init); |
332 | |
333 | static void __exit ehci_exynos_cleanup(void) |
334 | { |
335 | platform_driver_unregister(&exynos_ehci_driver); |
336 | } |
337 | module_exit(ehci_exynos_cleanup); |
338 | |
339 | MODULE_DESCRIPTION(DRIVER_DESC); |
340 | MODULE_ALIAS("platform:exynos-ehci" ); |
341 | MODULE_AUTHOR("Jingoo Han" ); |
342 | MODULE_AUTHOR("Joonyoung Shim" ); |
343 | MODULE_LICENSE("GPL v2" ); |
344 | |