1// SPDX-License-Identifier: GPL-2.0
2/*
3 * dwc3-rtk.c - Realtek DWC3 Specific Glue layer
4 *
5 * Copyright (C) 2023 Realtek Semiconductor Corporation
6 *
7 */
8
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/platform_device.h>
12#include <linux/of.h>
13#include <linux/of_platform.h>
14#include <linux/suspend.h>
15#include <linux/sys_soc.h>
16#include <linux/usb/otg.h>
17#include <linux/usb/of.h>
18#include <linux/usb/role.h>
19
20#include "core.h"
21
22#define WRAP_CTR_REG  0x0
23#define DISABLE_MULTI_REQ BIT(1)
24#define DESC_R2W_MULTI_DISABLE BIT(9)
25#define FORCE_PIPE3_PHY_STATUS_TO_0 BIT(13)
26
27#define WRAP_USB2_PHY_UTMI_REG 0x8
28#define TXHSVM_EN BIT(3)
29
30#define WRAP_PHY_PIPE_REG 0xC
31#define RESET_DISABLE_PIPE3_P0 BIT(0)
32#define CLOCK_ENABLE_FOR_PIPE3_PCLK BIT(1)
33
34#define WRAP_USB_HMAC_CTR0_REG 0x60
35#define U3PORT_DIS BIT(8)
36
37#define WRAP_USB2_PHY_REG  0x70
38#define USB2_PHY_EN_PHY_PLL_PORT0 BIT(12)
39#define USB2_PHY_EN_PHY_PLL_PORT1 BIT(13)
40#define USB2_PHY_SWITCH_MASK 0x707
41#define USB2_PHY_SWITCH_DEVICE 0x0
42#define USB2_PHY_SWITCH_HOST 0x606
43
44#define WRAP_APHY_REG 0x128
45#define USB3_MBIAS_ENABLE BIT(1)
46
47/* pm control */
48#define WRAP_USB_DBUS_PWR_CTRL_REG 0x160
49#define USB_DBUS_PWR_CTRL_REG 0x0
50#define DBUS_PWR_CTRL_EN BIT(0)
51
52struct dwc3_rtk {
53	struct device *dev;
54	void __iomem *regs;
55	size_t regs_size;
56	void __iomem *pm_base;
57
58	struct dwc3 *dwc;
59
60	enum usb_role cur_role;
61	struct usb_role_switch *role_switch;
62};
63
64static void switch_usb2_role(struct dwc3_rtk *rtk, enum usb_role role)
65{
66	void __iomem *reg;
67	int val;
68
69	reg = rtk->regs + WRAP_USB2_PHY_REG;
70	val = ~USB2_PHY_SWITCH_MASK & readl(reg);
71
72	switch (role) {
73	case USB_ROLE_DEVICE:
74		writel(USB2_PHY_SWITCH_DEVICE | val, reg);
75		break;
76	case USB_ROLE_HOST:
77		writel(USB2_PHY_SWITCH_HOST | val, reg);
78		break;
79	default:
80		dev_dbg(rtk->dev, "%s: role=%d\n", __func__, role);
81		break;
82	}
83}
84
85static void switch_dwc3_role(struct dwc3_rtk *rtk, enum usb_role role)
86{
87	if (!rtk->dwc->role_sw)
88		return;
89
90	usb_role_switch_set_role(rtk->dwc->role_sw, role);
91}
92
93static enum usb_role dwc3_rtk_get_role(struct dwc3_rtk *rtk)
94{
95	enum usb_role role;
96
97	role = rtk->cur_role;
98
99	if (rtk->dwc && rtk->dwc->role_sw)
100		role = usb_role_switch_get_role(rtk->dwc->role_sw);
101	else
102		dev_dbg(rtk->dev, "%s not usb_role_switch role=%d\n", __func__, role);
103
104	return role;
105}
106
107static void dwc3_rtk_set_role(struct dwc3_rtk *rtk, enum usb_role role)
108{
109	rtk->cur_role = role;
110
111	switch_dwc3_role(rtk, role);
112	mdelay(10);
113	switch_usb2_role(rtk, role);
114}
115
116#if IS_ENABLED(CONFIG_USB_ROLE_SWITCH)
117static int dwc3_usb_role_switch_set(struct usb_role_switch *sw, enum usb_role role)
118{
119	struct dwc3_rtk *rtk = usb_role_switch_get_drvdata(sw);
120
121	dwc3_rtk_set_role(rtk, role);
122
123	return 0;
124}
125
126static enum usb_role dwc3_usb_role_switch_get(struct usb_role_switch *sw)
127{
128	struct dwc3_rtk *rtk = usb_role_switch_get_drvdata(sw);
129
130	return dwc3_rtk_get_role(rtk);
131}
132
133static int dwc3_rtk_setup_role_switch(struct dwc3_rtk *rtk)
134{
135	struct usb_role_switch_desc dwc3_role_switch = {NULL};
136
137	dwc3_role_switch.name = dev_name(rtk->dev);
138	dwc3_role_switch.driver_data = rtk;
139	dwc3_role_switch.allow_userspace_control = true;
140	dwc3_role_switch.fwnode = dev_fwnode(rtk->dev);
141	dwc3_role_switch.set = dwc3_usb_role_switch_set;
142	dwc3_role_switch.get = dwc3_usb_role_switch_get;
143	rtk->role_switch = usb_role_switch_register(rtk->dev, &dwc3_role_switch);
144	if (IS_ERR(rtk->role_switch))
145		return PTR_ERR(rtk->role_switch);
146
147	return 0;
148}
149
150static int dwc3_rtk_remove_role_switch(struct dwc3_rtk *rtk)
151{
152	if (rtk->role_switch)
153		usb_role_switch_unregister(rtk->role_switch);
154
155	rtk->role_switch = NULL;
156
157	return 0;
158}
159#else
160#define dwc3_rtk_setup_role_switch(x) 0
161#define dwc3_rtk_remove_role_switch(x) 0
162#endif
163
164static const char *const speed_names[] = {
165	[USB_SPEED_UNKNOWN] = "UNKNOWN",
166	[USB_SPEED_LOW] = "low-speed",
167	[USB_SPEED_FULL] = "full-speed",
168	[USB_SPEED_HIGH] = "high-speed",
169	[USB_SPEED_WIRELESS] = "wireless",
170	[USB_SPEED_SUPER] = "super-speed",
171	[USB_SPEED_SUPER_PLUS] = "super-speed-plus",
172};
173
174static enum usb_device_speed __get_dwc3_maximum_speed(struct device_node *np)
175{
176	struct device_node *dwc3_np;
177	const char *maximum_speed;
178	int ret;
179
180	dwc3_np = of_get_compatible_child(np, "snps,dwc3");
181	if (!dwc3_np)
182		return USB_SPEED_UNKNOWN;
183
184	ret = of_property_read_string(dwc3_np, "maximum-speed", &maximum_speed);
185	if (ret < 0)
186		goto out;
187
188	ret = match_string(speed_names, ARRAY_SIZE(speed_names), maximum_speed);
189
190out:
191	of_node_put(dwc3_np);
192
193	return (ret < 0) ? USB_SPEED_UNKNOWN : ret;
194}
195
196static int dwc3_rtk_init(struct dwc3_rtk *rtk)
197{
198	struct device *dev = rtk->dev;
199	void __iomem *reg;
200	int val;
201	enum usb_device_speed maximum_speed;
202	const struct soc_device_attribute rtk_soc_kylin_a00[] = {
203		{ .family = "Realtek Kylin", .revision = "A00", },
204		{ /* empty */ } };
205	const struct soc_device_attribute rtk_soc_hercules[] = {
206		{ .family = "Realtek Hercules", }, { /* empty */ } };
207	const struct soc_device_attribute rtk_soc_thor[] = {
208		{ .family = "Realtek Thor", }, { /* empty */ } };
209
210	if (soc_device_match(rtk_soc_kylin_a00)) {
211		reg = rtk->regs + WRAP_CTR_REG;
212		val = readl(reg);
213		writel(DISABLE_MULTI_REQ | val, reg);
214		dev_info(dev, "[bug fixed] 1295/1296 A00: add workaround to disable multiple request for D-Bus");
215	}
216
217	if (soc_device_match(rtk_soc_hercules)) {
218		reg = rtk->regs + WRAP_USB2_PHY_REG;
219		val = readl(reg);
220		writel(USB2_PHY_EN_PHY_PLL_PORT1 | val, reg);
221		dev_info(dev, "[bug fixed] 1395 add workaround to disable usb2 port 2 suspend!");
222	}
223
224	reg = rtk->regs + WRAP_USB2_PHY_UTMI_REG;
225	val = readl(reg);
226	writel(TXHSVM_EN | val, reg);
227
228	maximum_speed = __get_dwc3_maximum_speed(dev->of_node);
229	if (maximum_speed != USB_SPEED_UNKNOWN && maximum_speed <= USB_SPEED_HIGH) {
230		if (soc_device_match(rtk_soc_thor)) {
231			reg = rtk->regs + WRAP_USB_HMAC_CTR0_REG;
232			val = readl(reg);
233			writel(U3PORT_DIS | val, reg);
234		} else {
235			reg = rtk->regs + WRAP_CTR_REG;
236			val = readl(reg);
237			writel(FORCE_PIPE3_PHY_STATUS_TO_0 | val, reg);
238
239			reg = rtk->regs + WRAP_PHY_PIPE_REG;
240			val = ~CLOCK_ENABLE_FOR_PIPE3_PCLK & readl(reg);
241			writel(RESET_DISABLE_PIPE3_P0 | val, reg);
242
243			reg =  rtk->regs + WRAP_USB_HMAC_CTR0_REG;
244			val = readl(reg);
245			writel(U3PORT_DIS | val, reg);
246
247			reg = rtk->regs + WRAP_APHY_REG;
248			val = readl(reg);
249			writel(~USB3_MBIAS_ENABLE & val, reg);
250
251			dev_dbg(rtk->dev, "%s: disable usb 3.0 phy\n", __func__);
252		}
253	}
254
255	reg = rtk->regs + WRAP_CTR_REG;
256	val = readl(reg);
257	writel(DESC_R2W_MULTI_DISABLE | val, reg);
258
259	/* Set phy Dp/Dm initial state to host mode to avoid the Dp glitch */
260	reg = rtk->regs + WRAP_USB2_PHY_REG;
261	val = ~USB2_PHY_SWITCH_MASK & readl(reg);
262	writel(USB2_PHY_SWITCH_HOST | val, reg);
263
264	if (rtk->pm_base) {
265		reg = rtk->pm_base + USB_DBUS_PWR_CTRL_REG;
266		val = DBUS_PWR_CTRL_EN | readl(reg);
267		writel(val, reg);
268	}
269
270	return 0;
271}
272
273static int dwc3_rtk_probe_dwc3_core(struct dwc3_rtk *rtk)
274{
275	struct device *dev = rtk->dev;
276	struct device_node *node = dev->of_node;
277	struct platform_device *dwc3_pdev;
278	struct device *dwc3_dev;
279	struct device_node *dwc3_node;
280	enum usb_dr_mode dr_mode;
281	int ret = 0;
282
283	ret = dwc3_rtk_init(rtk);
284	if (ret)
285		return -EINVAL;
286
287	ret = of_platform_populate(node, NULL, NULL, dev);
288	if (ret) {
289		dev_err(dev, "failed to add dwc3 core\n");
290		return ret;
291	}
292
293	dwc3_node = of_get_compatible_child(node, "snps,dwc3");
294	if (!dwc3_node) {
295		dev_err(dev, "failed to find dwc3 core node\n");
296		ret = -ENODEV;
297		goto depopulate;
298	}
299
300	dwc3_pdev = of_find_device_by_node(dwc3_node);
301	if (!dwc3_pdev) {
302		dev_err(dev, "failed to find dwc3 core platform_device\n");
303		ret = -ENODEV;
304		goto err_node_put;
305	}
306
307	dwc3_dev = &dwc3_pdev->dev;
308	rtk->dwc = platform_get_drvdata(dwc3_pdev);
309	if (!rtk->dwc) {
310		dev_err(dev, "failed to find dwc3 core\n");
311		ret = -ENODEV;
312		goto err_pdev_put;
313	}
314
315	dr_mode = usb_get_dr_mode(dwc3_dev);
316	if (dr_mode != rtk->dwc->dr_mode) {
317		dev_info(dev, "dts set dr_mode=%d, but dwc3 set dr_mode=%d\n",
318			 dr_mode, rtk->dwc->dr_mode);
319		dr_mode = rtk->dwc->dr_mode;
320	}
321
322	switch (dr_mode) {
323	case USB_DR_MODE_PERIPHERAL:
324		rtk->cur_role = USB_ROLE_DEVICE;
325		break;
326	case USB_DR_MODE_HOST:
327		rtk->cur_role = USB_ROLE_HOST;
328		break;
329	default:
330		dev_dbg(rtk->dev, "%s: dr_mode=%d\n", __func__, dr_mode);
331		break;
332	}
333
334	if (device_property_read_bool(dwc3_dev, "usb-role-switch")) {
335		ret = dwc3_rtk_setup_role_switch(rtk);
336		if (ret) {
337			dev_err(dev, "dwc3_rtk_setup_role_switch fail=%d\n", ret);
338			goto err_pdev_put;
339		}
340		rtk->cur_role = dwc3_rtk_get_role(rtk);
341	}
342
343	switch_usb2_role(rtk, rtk->cur_role);
344
345	platform_device_put(dwc3_pdev);
346	of_node_put(dwc3_node);
347
348	return 0;
349
350err_pdev_put:
351	platform_device_put(dwc3_pdev);
352err_node_put:
353	of_node_put(dwc3_node);
354depopulate:
355	of_platform_depopulate(dev);
356
357	return ret;
358}
359
360static int dwc3_rtk_probe(struct platform_device *pdev)
361{
362	struct dwc3_rtk *rtk;
363	struct device *dev = &pdev->dev;
364	struct resource *res;
365	void __iomem *regs;
366	int ret = 0;
367
368	rtk = devm_kzalloc(dev, sizeof(*rtk), GFP_KERNEL);
369	if (!rtk) {
370		ret = -ENOMEM;
371		goto out;
372	}
373
374	platform_set_drvdata(pdev, rtk);
375
376	rtk->dev = dev;
377
378	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
379	if (!res) {
380		dev_err(dev, "missing memory resource\n");
381		ret = -ENODEV;
382		goto out;
383	}
384
385	regs = devm_ioremap_resource(dev, res);
386	if (IS_ERR(regs)) {
387		ret = PTR_ERR(regs);
388		goto out;
389	}
390
391	rtk->regs = regs;
392	rtk->regs_size = resource_size(res);
393
394	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
395	if (res) {
396		rtk->pm_base = devm_ioremap_resource(dev, res);
397		if (IS_ERR(rtk->pm_base)) {
398			ret = PTR_ERR(rtk->pm_base);
399			goto out;
400		}
401	}
402
403	ret = dwc3_rtk_probe_dwc3_core(rtk);
404
405out:
406	return ret;
407}
408
409static void dwc3_rtk_remove(struct platform_device *pdev)
410{
411	struct dwc3_rtk *rtk = platform_get_drvdata(pdev);
412
413	rtk->dwc = NULL;
414
415	dwc3_rtk_remove_role_switch(rtk);
416
417	of_platform_depopulate(rtk->dev);
418}
419
420static void dwc3_rtk_shutdown(struct platform_device *pdev)
421{
422	struct dwc3_rtk *rtk = platform_get_drvdata(pdev);
423
424	of_platform_depopulate(rtk->dev);
425}
426
427static const struct of_device_id rtk_dwc3_match[] = {
428	{ .compatible = "realtek,rtd-dwc3" },
429	{},
430};
431MODULE_DEVICE_TABLE(of, rtk_dwc3_match);
432
433#ifdef CONFIG_PM_SLEEP
434static int dwc3_rtk_suspend(struct device *dev)
435{
436	return 0;
437}
438
439static int dwc3_rtk_resume(struct device *dev)
440{
441	struct dwc3_rtk *rtk = dev_get_drvdata(dev);
442
443	dwc3_rtk_init(rtk);
444
445	switch_usb2_role(rtk, rtk->cur_role);
446
447	/* runtime set active to reflect active state. */
448	pm_runtime_disable(dev);
449	pm_runtime_set_active(dev);
450	pm_runtime_enable(dev);
451
452	return 0;
453}
454
455static const struct dev_pm_ops dwc3_rtk_dev_pm_ops = {
456	SET_SYSTEM_SLEEP_PM_OPS(dwc3_rtk_suspend, dwc3_rtk_resume)
457};
458
459#define DEV_PM_OPS	(&dwc3_rtk_dev_pm_ops)
460#else
461#define DEV_PM_OPS	NULL
462#endif /* CONFIG_PM_SLEEP */
463
464static struct platform_driver dwc3_rtk_driver = {
465	.probe		= dwc3_rtk_probe,
466	.remove_new	= dwc3_rtk_remove,
467	.driver		= {
468		.name	= "rtk-dwc3",
469		.of_match_table = rtk_dwc3_match,
470		.pm	= DEV_PM_OPS,
471	},
472	.shutdown	= dwc3_rtk_shutdown,
473};
474
475module_platform_driver(dwc3_rtk_driver);
476
477MODULE_AUTHOR("Stanley Chang <stanley_chang@realtek.com>");
478MODULE_DESCRIPTION("DesignWare USB3 Realtek Glue Layer");
479MODULE_ALIAS("platform:rtk-dwc3");
480MODULE_LICENSE("GPL");
481MODULE_SOFTDEP("pre: phy_rtk_usb2 phy_rtk_usb3");
482