1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * xHCI host controller driver for HiSilicon STB SoCs |
4 | * |
5 | * Copyright (C) 2017-2018 HiSilicon Co., Ltd. http://www.hisilicon.com |
6 | * |
7 | * Authors: Jianguo Sun <sunjianguo1@huawei.com> |
8 | */ |
9 | |
10 | #include <linux/clk.h> |
11 | #include <linux/dma-mapping.h> |
12 | #include <linux/kernel.h> |
13 | #include <linux/module.h> |
14 | #include <linux/of.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/pm_runtime.h> |
17 | #include <linux/reset.h> |
18 | |
19 | #include "xhci.h" |
20 | |
21 | #define GTXTHRCFG 0xc108 |
22 | #define GRXTHRCFG 0xc10c |
23 | #define REG_GUSB2PHYCFG0 0xc200 |
24 | #define BIT_UTMI_8_16 BIT(3) |
25 | #define BIT_UTMI_ULPI BIT(4) |
26 | #define BIT_FREECLK_EXIST BIT(30) |
27 | |
28 | #define REG_GUSB3PIPECTL0 0xc2c0 |
29 | #define USB3_DEEMPHASIS_MASK GENMASK(2, 1) |
30 | #define USB3_DEEMPHASIS0 BIT(1) |
31 | #define USB3_TX_MARGIN1 BIT(4) |
32 | |
33 | struct xhci_hcd_histb { |
34 | struct device *dev; |
35 | struct usb_hcd *hcd; |
36 | void __iomem *ctrl; |
37 | struct clk *bus_clk; |
38 | struct clk *utmi_clk; |
39 | struct clk *pipe_clk; |
40 | struct clk *suspend_clk; |
41 | struct reset_control *soft_reset; |
42 | }; |
43 | |
44 | static inline struct xhci_hcd_histb *hcd_to_histb(struct usb_hcd *hcd) |
45 | { |
46 | return dev_get_drvdata(dev: hcd->self.controller); |
47 | } |
48 | |
49 | static int xhci_histb_config(struct xhci_hcd_histb *histb) |
50 | { |
51 | struct device_node *np = histb->dev->of_node; |
52 | u32 regval; |
53 | |
54 | if (of_property_match_string(np, propname: "phys-names" , string: "inno" ) >= 0) { |
55 | /* USB2 PHY chose ulpi 8bit interface */ |
56 | regval = readl(addr: histb->ctrl + REG_GUSB2PHYCFG0); |
57 | regval &= ~BIT_UTMI_ULPI; |
58 | regval &= ~(BIT_UTMI_8_16); |
59 | regval &= ~BIT_FREECLK_EXIST; |
60 | writel(val: regval, addr: histb->ctrl + REG_GUSB2PHYCFG0); |
61 | } |
62 | |
63 | if (of_property_match_string(np, propname: "phys-names" , string: "combo" ) >= 0) { |
64 | /* |
65 | * write 0x010c0012 to GUSB3PIPECTL0 |
66 | * GUSB3PIPECTL0[5:3] = 010 : Tx Margin = 900mV , |
67 | * decrease TX voltage |
68 | * GUSB3PIPECTL0[2:1] = 01 : Tx Deemphasis = -3.5dB, |
69 | * refer to xHCI spec |
70 | */ |
71 | regval = readl(addr: histb->ctrl + REG_GUSB3PIPECTL0); |
72 | regval &= ~USB3_DEEMPHASIS_MASK; |
73 | regval |= USB3_DEEMPHASIS0; |
74 | regval |= USB3_TX_MARGIN1; |
75 | writel(val: regval, addr: histb->ctrl + REG_GUSB3PIPECTL0); |
76 | } |
77 | |
78 | writel(val: 0x23100000, addr: histb->ctrl + GTXTHRCFG); |
79 | writel(val: 0x23100000, addr: histb->ctrl + GRXTHRCFG); |
80 | |
81 | return 0; |
82 | } |
83 | |
84 | static int xhci_histb_clks_get(struct xhci_hcd_histb *histb) |
85 | { |
86 | struct device *dev = histb->dev; |
87 | |
88 | histb->bus_clk = devm_clk_get(dev, id: "bus" ); |
89 | if (IS_ERR(ptr: histb->bus_clk)) { |
90 | dev_err(dev, "fail to get bus clk\n" ); |
91 | return PTR_ERR(ptr: histb->bus_clk); |
92 | } |
93 | |
94 | histb->utmi_clk = devm_clk_get(dev, id: "utmi" ); |
95 | if (IS_ERR(ptr: histb->utmi_clk)) { |
96 | dev_err(dev, "fail to get utmi clk\n" ); |
97 | return PTR_ERR(ptr: histb->utmi_clk); |
98 | } |
99 | |
100 | histb->pipe_clk = devm_clk_get(dev, id: "pipe" ); |
101 | if (IS_ERR(ptr: histb->pipe_clk)) { |
102 | dev_err(dev, "fail to get pipe clk\n" ); |
103 | return PTR_ERR(ptr: histb->pipe_clk); |
104 | } |
105 | |
106 | histb->suspend_clk = devm_clk_get(dev, id: "suspend" ); |
107 | if (IS_ERR(ptr: histb->suspend_clk)) { |
108 | dev_err(dev, "fail to get suspend clk\n" ); |
109 | return PTR_ERR(ptr: histb->suspend_clk); |
110 | } |
111 | |
112 | return 0; |
113 | } |
114 | |
115 | static int xhci_histb_host_enable(struct xhci_hcd_histb *histb) |
116 | { |
117 | int ret; |
118 | |
119 | ret = clk_prepare_enable(clk: histb->bus_clk); |
120 | if (ret) { |
121 | dev_err(histb->dev, "failed to enable bus clk\n" ); |
122 | return ret; |
123 | } |
124 | |
125 | ret = clk_prepare_enable(clk: histb->utmi_clk); |
126 | if (ret) { |
127 | dev_err(histb->dev, "failed to enable utmi clk\n" ); |
128 | goto err_utmi_clk; |
129 | } |
130 | |
131 | ret = clk_prepare_enable(clk: histb->pipe_clk); |
132 | if (ret) { |
133 | dev_err(histb->dev, "failed to enable pipe clk\n" ); |
134 | goto err_pipe_clk; |
135 | } |
136 | |
137 | ret = clk_prepare_enable(clk: histb->suspend_clk); |
138 | if (ret) { |
139 | dev_err(histb->dev, "failed to enable suspend clk\n" ); |
140 | goto err_suspend_clk; |
141 | } |
142 | |
143 | reset_control_deassert(rstc: histb->soft_reset); |
144 | |
145 | return 0; |
146 | |
147 | err_suspend_clk: |
148 | clk_disable_unprepare(clk: histb->pipe_clk); |
149 | err_pipe_clk: |
150 | clk_disable_unprepare(clk: histb->utmi_clk); |
151 | err_utmi_clk: |
152 | clk_disable_unprepare(clk: histb->bus_clk); |
153 | |
154 | return ret; |
155 | } |
156 | |
157 | static void xhci_histb_host_disable(struct xhci_hcd_histb *histb) |
158 | { |
159 | reset_control_assert(rstc: histb->soft_reset); |
160 | |
161 | clk_disable_unprepare(clk: histb->suspend_clk); |
162 | clk_disable_unprepare(clk: histb->pipe_clk); |
163 | clk_disable_unprepare(clk: histb->utmi_clk); |
164 | clk_disable_unprepare(clk: histb->bus_clk); |
165 | } |
166 | |
167 | /* called during probe() after chip reset completes */ |
168 | static int xhci_histb_setup(struct usb_hcd *hcd) |
169 | { |
170 | struct xhci_hcd_histb *histb = hcd_to_histb(hcd); |
171 | int ret; |
172 | |
173 | if (usb_hcd_is_primary_hcd(hcd)) { |
174 | ret = xhci_histb_config(histb); |
175 | if (ret) |
176 | return ret; |
177 | } |
178 | |
179 | return xhci_gen_setup(hcd, NULL); |
180 | } |
181 | |
182 | static const struct xhci_driver_overrides xhci_histb_overrides __initconst = { |
183 | .reset = xhci_histb_setup, |
184 | }; |
185 | |
186 | static struct hc_driver __read_mostly xhci_histb_hc_driver; |
187 | static int xhci_histb_probe(struct platform_device *pdev) |
188 | { |
189 | struct device *dev = &pdev->dev; |
190 | struct xhci_hcd_histb *histb; |
191 | const struct hc_driver *driver; |
192 | struct usb_hcd *hcd; |
193 | struct xhci_hcd *xhci; |
194 | struct resource *res; |
195 | int irq; |
196 | int ret = -ENODEV; |
197 | |
198 | if (usb_disabled()) |
199 | return -ENODEV; |
200 | |
201 | driver = &xhci_histb_hc_driver; |
202 | histb = devm_kzalloc(dev, size: sizeof(*histb), GFP_KERNEL); |
203 | if (!histb) |
204 | return -ENOMEM; |
205 | |
206 | histb->dev = dev; |
207 | |
208 | irq = platform_get_irq(pdev, 0); |
209 | if (irq < 0) |
210 | return irq; |
211 | |
212 | histb->ctrl = devm_platform_get_and_ioremap_resource(pdev, index: 0, res: &res); |
213 | if (IS_ERR(ptr: histb->ctrl)) |
214 | return PTR_ERR(ptr: histb->ctrl); |
215 | |
216 | ret = xhci_histb_clks_get(histb); |
217 | if (ret) |
218 | return ret; |
219 | |
220 | histb->soft_reset = devm_reset_control_get(dev, id: "soft" ); |
221 | if (IS_ERR(ptr: histb->soft_reset)) { |
222 | dev_err(dev, "failed to get soft reset\n" ); |
223 | return PTR_ERR(ptr: histb->soft_reset); |
224 | } |
225 | |
226 | pm_runtime_enable(dev); |
227 | pm_runtime_get_sync(dev); |
228 | device_enable_async_suspend(dev); |
229 | |
230 | /* Initialize dma_mask and coherent_dma_mask to 32-bits */ |
231 | ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); |
232 | if (ret) |
233 | goto disable_pm; |
234 | |
235 | hcd = usb_create_hcd(driver, dev, bus_name: dev_name(dev)); |
236 | if (!hcd) { |
237 | ret = -ENOMEM; |
238 | goto disable_pm; |
239 | } |
240 | |
241 | hcd->regs = histb->ctrl; |
242 | hcd->rsrc_start = res->start; |
243 | hcd->rsrc_len = resource_size(res); |
244 | |
245 | histb->hcd = hcd; |
246 | dev_set_drvdata(dev: hcd->self.controller, data: histb); |
247 | |
248 | ret = xhci_histb_host_enable(histb); |
249 | if (ret) |
250 | goto put_hcd; |
251 | |
252 | xhci = hcd_to_xhci(hcd); |
253 | |
254 | device_wakeup_enable(dev: hcd->self.controller); |
255 | |
256 | xhci->main_hcd = hcd; |
257 | xhci->shared_hcd = usb_create_shared_hcd(driver, dev, bus_name: dev_name(dev), |
258 | shared_hcd: hcd); |
259 | if (!xhci->shared_hcd) { |
260 | ret = -ENOMEM; |
261 | goto disable_host; |
262 | } |
263 | |
264 | if (device_property_read_bool(dev, propname: "usb2-lpm-disable" )) |
265 | xhci->quirks |= XHCI_HW_LPM_DISABLE; |
266 | |
267 | if (device_property_read_bool(dev, propname: "usb3-lpm-capable" )) |
268 | xhci->quirks |= XHCI_LPM_SUPPORT; |
269 | |
270 | /* imod_interval is the interrupt moderation value in nanoseconds. */ |
271 | xhci->imod_interval = 40000; |
272 | device_property_read_u32(dev, propname: "imod-interval-ns" , |
273 | val: &xhci->imod_interval); |
274 | |
275 | ret = usb_add_hcd(hcd, irqnum: irq, IRQF_SHARED); |
276 | if (ret) |
277 | goto put_usb3_hcd; |
278 | |
279 | if (HCC_MAX_PSA(xhci->hcc_params) >= 4) |
280 | xhci->shared_hcd->can_do_streams = 1; |
281 | |
282 | ret = usb_add_hcd(hcd: xhci->shared_hcd, irqnum: irq, IRQF_SHARED); |
283 | if (ret) |
284 | goto dealloc_usb2_hcd; |
285 | |
286 | device_enable_async_suspend(dev); |
287 | pm_runtime_put_noidle(dev); |
288 | |
289 | /* |
290 | * Prevent runtime pm from being on as default, users should enable |
291 | * runtime pm using power/control in sysfs. |
292 | */ |
293 | pm_runtime_forbid(dev); |
294 | |
295 | return 0; |
296 | |
297 | dealloc_usb2_hcd: |
298 | usb_remove_hcd(hcd); |
299 | put_usb3_hcd: |
300 | usb_put_hcd(hcd: xhci->shared_hcd); |
301 | disable_host: |
302 | xhci_histb_host_disable(histb); |
303 | put_hcd: |
304 | usb_put_hcd(hcd); |
305 | disable_pm: |
306 | pm_runtime_put_sync(dev); |
307 | pm_runtime_disable(dev); |
308 | |
309 | return ret; |
310 | } |
311 | |
312 | static void xhci_histb_remove(struct platform_device *dev) |
313 | { |
314 | struct xhci_hcd_histb *histb = platform_get_drvdata(pdev: dev); |
315 | struct usb_hcd *hcd = histb->hcd; |
316 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); |
317 | struct usb_hcd *shared_hcd = xhci->shared_hcd; |
318 | |
319 | xhci->xhc_state |= XHCI_STATE_REMOVING; |
320 | |
321 | usb_remove_hcd(hcd: shared_hcd); |
322 | xhci->shared_hcd = NULL; |
323 | device_wakeup_disable(dev: &dev->dev); |
324 | |
325 | usb_remove_hcd(hcd); |
326 | usb_put_hcd(hcd: shared_hcd); |
327 | |
328 | xhci_histb_host_disable(histb); |
329 | usb_put_hcd(hcd); |
330 | pm_runtime_put_sync(dev: &dev->dev); |
331 | pm_runtime_disable(dev: &dev->dev); |
332 | } |
333 | |
334 | static int __maybe_unused xhci_histb_suspend(struct device *dev) |
335 | { |
336 | struct xhci_hcd_histb *histb = dev_get_drvdata(dev); |
337 | struct usb_hcd *hcd = histb->hcd; |
338 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); |
339 | int ret; |
340 | |
341 | ret = xhci_suspend(xhci, do_wakeup: device_may_wakeup(dev)); |
342 | |
343 | if (!device_may_wakeup(dev)) |
344 | xhci_histb_host_disable(histb); |
345 | |
346 | return ret; |
347 | } |
348 | |
349 | static int __maybe_unused xhci_histb_resume(struct device *dev) |
350 | { |
351 | struct xhci_hcd_histb *histb = dev_get_drvdata(dev); |
352 | struct usb_hcd *hcd = histb->hcd; |
353 | struct xhci_hcd *xhci = hcd_to_xhci(hcd); |
354 | |
355 | if (!device_may_wakeup(dev)) |
356 | xhci_histb_host_enable(histb); |
357 | |
358 | return xhci_resume(xhci, PMSG_RESUME); |
359 | } |
360 | |
361 | static const struct dev_pm_ops xhci_histb_pm_ops = { |
362 | SET_SYSTEM_SLEEP_PM_OPS(xhci_histb_suspend, xhci_histb_resume) |
363 | }; |
364 | #define DEV_PM_OPS (IS_ENABLED(CONFIG_PM) ? &xhci_histb_pm_ops : NULL) |
365 | |
366 | #ifdef CONFIG_OF |
367 | static const struct of_device_id histb_xhci_of_match[] = { |
368 | { .compatible = "hisilicon,hi3798cv200-xhci" }, |
369 | { }, |
370 | }; |
371 | MODULE_DEVICE_TABLE(of, histb_xhci_of_match); |
372 | #endif |
373 | |
374 | static struct platform_driver histb_xhci_driver = { |
375 | .probe = xhci_histb_probe, |
376 | .remove_new = xhci_histb_remove, |
377 | .driver = { |
378 | .name = "xhci-histb" , |
379 | .pm = DEV_PM_OPS, |
380 | .of_match_table = of_match_ptr(histb_xhci_of_match), |
381 | }, |
382 | }; |
383 | MODULE_ALIAS("platform:xhci-histb" ); |
384 | |
385 | static int __init xhci_histb_init(void) |
386 | { |
387 | xhci_init_driver(drv: &xhci_histb_hc_driver, over: &xhci_histb_overrides); |
388 | return platform_driver_register(&histb_xhci_driver); |
389 | } |
390 | module_init(xhci_histb_init); |
391 | |
392 | static void __exit xhci_histb_exit(void) |
393 | { |
394 | platform_driver_unregister(&histb_xhci_driver); |
395 | } |
396 | module_exit(xhci_histb_exit); |
397 | |
398 | MODULE_DESCRIPTION("HiSilicon STB xHCI Host Controller Driver" ); |
399 | MODULE_LICENSE("GPL v2" ); |
400 | |