xref: /openbmc/linux/drivers/usb/musb/mediatek.c (revision abed054f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2019 MediaTek Inc.
4  *
5  * Author:
6  *  Min Guo <min.guo@mediatek.com>
7  *  Yonglong Wu <yonglong.wu@mediatek.com>
8  */
9 
10 #include <linux/clk.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/module.h>
13 #include <linux/of_platform.h>
14 #include <linux/platform_device.h>
15 #include <linux/usb/role.h>
16 #include <linux/usb/usb_phy_generic.h>
17 #include "musb_core.h"
18 #include "musb_dma.h"
19 
20 #define USB_L1INTS		0x00a0
21 #define USB_L1INTM		0x00a4
22 #define MTK_MUSB_TXFUNCADDR	0x0480
23 
24 /* MediaTek controller toggle enable and status reg */
25 #define MUSB_RXTOG		0x80
26 #define MUSB_RXTOGEN		0x82
27 #define MUSB_TXTOG		0x84
28 #define MUSB_TXTOGEN		0x86
29 #define MTK_TOGGLE_EN		GENMASK(15, 0)
30 
31 #define TX_INT_STATUS		BIT(0)
32 #define RX_INT_STATUS		BIT(1)
33 #define USBCOM_INT_STATUS	BIT(2)
34 #define DMA_INT_STATUS		BIT(3)
35 
36 #define DMA_INTR_STATUS_MSK	GENMASK(7, 0)
37 #define DMA_INTR_UNMASK_SET_MSK	GENMASK(31, 24)
38 
39 struct mtk_glue {
40 	struct device *dev;
41 	struct musb *musb;
42 	struct platform_device *musb_pdev;
43 	struct platform_device *usb_phy;
44 	struct phy *phy;
45 	struct usb_phy *xceiv;
46 	enum phy_mode phy_mode;
47 	struct clk *main;
48 	struct clk *mcu;
49 	struct clk *univpll;
50 	enum usb_role role;
51 	struct usb_role_switch *role_sw;
52 };
53 
54 static int mtk_musb_clks_get(struct mtk_glue *glue)
55 {
56 	struct device *dev = glue->dev;
57 
58 	glue->main = devm_clk_get(dev, "main");
59 	if (IS_ERR(glue->main)) {
60 		dev_err(dev, "fail to get main clock\n");
61 		return PTR_ERR(glue->main);
62 	}
63 
64 	glue->mcu = devm_clk_get(dev, "mcu");
65 	if (IS_ERR(glue->mcu)) {
66 		dev_err(dev, "fail to get mcu clock\n");
67 		return PTR_ERR(glue->mcu);
68 	}
69 
70 	glue->univpll = devm_clk_get(dev, "univpll");
71 	if (IS_ERR(glue->univpll)) {
72 		dev_err(dev, "fail to get univpll clock\n");
73 		return PTR_ERR(glue->univpll);
74 	}
75 
76 	return 0;
77 }
78 
79 static int mtk_musb_clks_enable(struct mtk_glue *glue)
80 {
81 	int ret;
82 
83 	ret = clk_prepare_enable(glue->main);
84 	if (ret) {
85 		dev_err(glue->dev, "failed to enable main clock\n");
86 		goto err_main_clk;
87 	}
88 
89 	ret = clk_prepare_enable(glue->mcu);
90 	if (ret) {
91 		dev_err(glue->dev, "failed to enable mcu clock\n");
92 		goto err_mcu_clk;
93 	}
94 
95 	ret = clk_prepare_enable(glue->univpll);
96 	if (ret) {
97 		dev_err(glue->dev, "failed to enable univpll clock\n");
98 		goto err_univpll_clk;
99 	}
100 
101 	return 0;
102 
103 err_univpll_clk:
104 	clk_disable_unprepare(glue->mcu);
105 err_mcu_clk:
106 	clk_disable_unprepare(glue->main);
107 err_main_clk:
108 	return ret;
109 }
110 
111 static void mtk_musb_clks_disable(struct mtk_glue *glue)
112 {
113 	clk_disable_unprepare(glue->univpll);
114 	clk_disable_unprepare(glue->mcu);
115 	clk_disable_unprepare(glue->main);
116 }
117 
118 static int mtk_otg_switch_set(struct mtk_glue *glue, enum usb_role role)
119 {
120 	struct musb *musb = glue->musb;
121 	u8 devctl = readb(musb->mregs + MUSB_DEVCTL);
122 	enum usb_role new_role;
123 
124 	if (role == glue->role)
125 		return 0;
126 
127 	switch (role) {
128 	case USB_ROLE_HOST:
129 		musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
130 		glue->phy_mode = PHY_MODE_USB_HOST;
131 		new_role = USB_ROLE_HOST;
132 		if (glue->role == USB_ROLE_NONE)
133 			phy_power_on(glue->phy);
134 
135 		devctl |= MUSB_DEVCTL_SESSION;
136 		musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
137 		MUSB_HST_MODE(musb);
138 		break;
139 	case USB_ROLE_DEVICE:
140 		musb->xceiv->otg->state = OTG_STATE_B_IDLE;
141 		glue->phy_mode = PHY_MODE_USB_DEVICE;
142 		new_role = USB_ROLE_DEVICE;
143 		devctl &= ~MUSB_DEVCTL_SESSION;
144 		musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
145 		if (glue->role == USB_ROLE_NONE)
146 			phy_power_on(glue->phy);
147 
148 		MUSB_DEV_MODE(musb);
149 		break;
150 	case USB_ROLE_NONE:
151 		glue->phy_mode = PHY_MODE_USB_OTG;
152 		new_role = USB_ROLE_NONE;
153 		devctl &= ~MUSB_DEVCTL_SESSION;
154 		musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
155 		if (glue->role != USB_ROLE_NONE)
156 			phy_power_off(glue->phy);
157 
158 		break;
159 	default:
160 		dev_err(glue->dev, "Invalid State\n");
161 		return -EINVAL;
162 	}
163 
164 	glue->role = new_role;
165 	phy_set_mode(glue->phy, glue->phy_mode);
166 
167 	return 0;
168 }
169 
170 static int musb_usb_role_sx_set(struct usb_role_switch *sw, enum usb_role role)
171 {
172 	return mtk_otg_switch_set(usb_role_switch_get_drvdata(sw), role);
173 }
174 
175 static enum usb_role musb_usb_role_sx_get(struct usb_role_switch *sw)
176 {
177 	struct mtk_glue *glue = usb_role_switch_get_drvdata(sw);
178 
179 	return glue->role;
180 }
181 
182 static int mtk_otg_switch_init(struct mtk_glue *glue)
183 {
184 	struct usb_role_switch_desc role_sx_desc = { 0 };
185 
186 	role_sx_desc.set = musb_usb_role_sx_set;
187 	role_sx_desc.get = musb_usb_role_sx_get;
188 	role_sx_desc.fwnode = dev_fwnode(glue->dev);
189 	role_sx_desc.driver_data = glue;
190 	glue->role_sw = usb_role_switch_register(glue->dev, &role_sx_desc);
191 
192 	return PTR_ERR_OR_ZERO(glue->role_sw);
193 }
194 
195 static void mtk_otg_switch_exit(struct mtk_glue *glue)
196 {
197 	return usb_role_switch_unregister(glue->role_sw);
198 }
199 
200 static irqreturn_t generic_interrupt(int irq, void *__hci)
201 {
202 	unsigned long flags;
203 	irqreturn_t retval = IRQ_NONE;
204 	struct musb *musb = __hci;
205 
206 	spin_lock_irqsave(&musb->lock, flags);
207 	musb->int_usb = musb_clearb(musb->mregs, MUSB_INTRUSB);
208 	musb->int_rx = musb_clearw(musb->mregs, MUSB_INTRRX);
209 	musb->int_tx = musb_clearw(musb->mregs, MUSB_INTRTX);
210 
211 	if ((musb->int_usb & MUSB_INTR_RESET) && !is_host_active(musb)) {
212 		/* ep0 FADDR must be 0 when (re)entering peripheral mode */
213 		musb_ep_select(musb->mregs, 0);
214 		musb_writeb(musb->mregs, MUSB_FADDR, 0);
215 	}
216 
217 	if (musb->int_usb || musb->int_tx || musb->int_rx)
218 		retval = musb_interrupt(musb);
219 
220 	spin_unlock_irqrestore(&musb->lock, flags);
221 
222 	return retval;
223 }
224 
225 static irqreturn_t mtk_musb_interrupt(int irq, void *dev_id)
226 {
227 	irqreturn_t retval = IRQ_NONE;
228 	struct musb *musb = (struct musb *)dev_id;
229 	u32 l1_ints;
230 
231 	l1_ints = musb_readl(musb->mregs, USB_L1INTS) &
232 			musb_readl(musb->mregs, USB_L1INTM);
233 
234 	if (l1_ints & (TX_INT_STATUS | RX_INT_STATUS | USBCOM_INT_STATUS))
235 		retval = generic_interrupt(irq, musb);
236 
237 #if defined(CONFIG_USB_INVENTRA_DMA)
238 	if (l1_ints & DMA_INT_STATUS)
239 		retval = dma_controller_irq(irq, musb->dma_controller);
240 #endif
241 	return retval;
242 }
243 
244 static u32 mtk_musb_busctl_offset(u8 epnum, u16 offset)
245 {
246 	return MTK_MUSB_TXFUNCADDR + offset + 8 * epnum;
247 }
248 
249 static u8 mtk_musb_clearb(void __iomem *addr, unsigned int offset)
250 {
251 	u8 data;
252 
253 	/* W1C */
254 	data = musb_readb(addr, offset);
255 	musb_writeb(addr, offset, data);
256 	return data;
257 }
258 
259 static u16 mtk_musb_clearw(void __iomem *addr, unsigned int offset)
260 {
261 	u16 data;
262 
263 	/* W1C */
264 	data = musb_readw(addr, offset);
265 	musb_writew(addr, offset, data);
266 	return data;
267 }
268 
269 static int mtk_musb_set_mode(struct musb *musb, u8 mode)
270 {
271 	struct device *dev = musb->controller;
272 	struct mtk_glue *glue = dev_get_drvdata(dev->parent);
273 	enum phy_mode new_mode;
274 	enum usb_role new_role;
275 
276 	switch (mode) {
277 	case MUSB_HOST:
278 		new_mode = PHY_MODE_USB_HOST;
279 		new_role = USB_ROLE_HOST;
280 		break;
281 	case MUSB_PERIPHERAL:
282 		new_mode = PHY_MODE_USB_DEVICE;
283 		new_role = USB_ROLE_DEVICE;
284 		break;
285 	case MUSB_OTG:
286 		new_mode = PHY_MODE_USB_OTG;
287 		new_role = USB_ROLE_NONE;
288 		break;
289 	default:
290 		dev_err(glue->dev, "Invalid mode request\n");
291 		return -EINVAL;
292 	}
293 
294 	if (glue->phy_mode == new_mode)
295 		return 0;
296 
297 	if (musb->port_mode != MUSB_OTG) {
298 		dev_err(glue->dev, "Does not support changing modes\n");
299 		return -EINVAL;
300 	}
301 
302 	mtk_otg_switch_set(glue, new_role);
303 	return 0;
304 }
305 
306 static int mtk_musb_init(struct musb *musb)
307 {
308 	struct device *dev = musb->controller;
309 	struct mtk_glue *glue = dev_get_drvdata(dev->parent);
310 	int ret;
311 
312 	glue->musb = musb;
313 	musb->phy = glue->phy;
314 	musb->xceiv = glue->xceiv;
315 	musb->is_host = false;
316 	musb->isr = mtk_musb_interrupt;
317 
318 	/* Set TX/RX toggle enable */
319 	musb_writew(musb->mregs, MUSB_TXTOGEN, MTK_TOGGLE_EN);
320 	musb_writew(musb->mregs, MUSB_RXTOGEN, MTK_TOGGLE_EN);
321 
322 	if (musb->port_mode == MUSB_OTG) {
323 		ret = mtk_otg_switch_init(glue);
324 		if (ret)
325 			return ret;
326 	}
327 
328 	ret = phy_init(glue->phy);
329 	if (ret)
330 		goto err_phy_init;
331 
332 	ret = phy_power_on(glue->phy);
333 	if (ret)
334 		goto err_phy_power_on;
335 
336 	phy_set_mode(glue->phy, glue->phy_mode);
337 
338 #if defined(CONFIG_USB_INVENTRA_DMA)
339 	musb_writel(musb->mregs, MUSB_HSDMA_INTR,
340 		    DMA_INTR_STATUS_MSK | DMA_INTR_UNMASK_SET_MSK);
341 #endif
342 	musb_writel(musb->mregs, USB_L1INTM, TX_INT_STATUS | RX_INT_STATUS |
343 		    USBCOM_INT_STATUS | DMA_INT_STATUS);
344 	return 0;
345 
346 err_phy_power_on:
347 	phy_exit(glue->phy);
348 err_phy_init:
349 	mtk_otg_switch_exit(glue);
350 	return ret;
351 }
352 
353 static u16 mtk_musb_get_toggle(struct musb_qh *qh, int is_out)
354 {
355 	struct musb *musb = qh->hw_ep->musb;
356 	u8 epnum = qh->hw_ep->epnum;
357 	u16 toggle;
358 
359 	toggle = musb_readw(musb->mregs, is_out ? MUSB_TXTOG : MUSB_RXTOG);
360 	return toggle & (1 << epnum);
361 }
362 
363 static u16 mtk_musb_set_toggle(struct musb_qh *qh, int is_out, struct urb *urb)
364 {
365 	struct musb *musb = qh->hw_ep->musb;
366 	u8 epnum = qh->hw_ep->epnum;
367 	u16 value, toggle;
368 
369 	toggle = usb_gettoggle(urb->dev, qh->epnum, is_out);
370 
371 	if (is_out) {
372 		value = musb_readw(musb->mregs, MUSB_TXTOG);
373 		value |= toggle << epnum;
374 		musb_writew(musb->mregs, MUSB_TXTOG, value);
375 	} else {
376 		value = musb_readw(musb->mregs, MUSB_RXTOG);
377 		value |= toggle << epnum;
378 		musb_writew(musb->mregs, MUSB_RXTOG, value);
379 	}
380 
381 	return 0;
382 }
383 
384 static int mtk_musb_exit(struct musb *musb)
385 {
386 	struct device *dev = musb->controller;
387 	struct mtk_glue *glue = dev_get_drvdata(dev->parent);
388 
389 	mtk_otg_switch_exit(glue);
390 	phy_power_off(glue->phy);
391 	phy_exit(glue->phy);
392 	mtk_musb_clks_disable(glue);
393 
394 	pm_runtime_put_sync(dev);
395 	pm_runtime_disable(dev);
396 	return 0;
397 }
398 
399 static const struct musb_platform_ops mtk_musb_ops = {
400 	.quirks = MUSB_DMA_INVENTRA,
401 	.init = mtk_musb_init,
402 	.get_toggle = mtk_musb_get_toggle,
403 	.set_toggle = mtk_musb_set_toggle,
404 	.exit = mtk_musb_exit,
405 #ifdef CONFIG_USB_INVENTRA_DMA
406 	.dma_init = musbhs_dma_controller_create_noirq,
407 	.dma_exit = musbhs_dma_controller_destroy,
408 #endif
409 	.clearb = mtk_musb_clearb,
410 	.clearw = mtk_musb_clearw,
411 	.busctl_offset = mtk_musb_busctl_offset,
412 	.set_mode = mtk_musb_set_mode,
413 };
414 
415 #define MTK_MUSB_MAX_EP_NUM	8
416 #define MTK_MUSB_RAM_BITS	11
417 
418 static struct musb_fifo_cfg mtk_musb_mode_cfg[] = {
419 	{ .hw_ep_num = 1, .style = FIFO_TX, .maxpacket = 512, },
420 	{ .hw_ep_num = 1, .style = FIFO_RX, .maxpacket = 512, },
421 	{ .hw_ep_num = 2, .style = FIFO_TX, .maxpacket = 512, },
422 	{ .hw_ep_num = 2, .style = FIFO_RX, .maxpacket = 512, },
423 	{ .hw_ep_num = 3, .style = FIFO_TX, .maxpacket = 512, },
424 	{ .hw_ep_num = 3, .style = FIFO_RX, .maxpacket = 512, },
425 	{ .hw_ep_num = 4, .style = FIFO_TX, .maxpacket = 512, },
426 	{ .hw_ep_num = 4, .style = FIFO_RX, .maxpacket = 512, },
427 	{ .hw_ep_num = 5, .style = FIFO_TX, .maxpacket = 512, },
428 	{ .hw_ep_num = 5, .style = FIFO_RX, .maxpacket = 512, },
429 	{ .hw_ep_num = 6, .style = FIFO_TX, .maxpacket = 1024, },
430 	{ .hw_ep_num = 6, .style = FIFO_RX, .maxpacket = 1024, },
431 	{ .hw_ep_num = 7, .style = FIFO_TX, .maxpacket = 512, },
432 	{ .hw_ep_num = 7, .style = FIFO_RX, .maxpacket = 64, },
433 };
434 
435 static const struct musb_hdrc_config mtk_musb_hdrc_config = {
436 	.fifo_cfg = mtk_musb_mode_cfg,
437 	.fifo_cfg_size = ARRAY_SIZE(mtk_musb_mode_cfg),
438 	.multipoint = true,
439 	.dyn_fifo = true,
440 	.num_eps = MTK_MUSB_MAX_EP_NUM,
441 	.ram_bits = MTK_MUSB_RAM_BITS,
442 };
443 
444 static const struct platform_device_info mtk_dev_info = {
445 	.name = "musb-hdrc",
446 	.id = PLATFORM_DEVID_AUTO,
447 	.dma_mask = DMA_BIT_MASK(32),
448 };
449 
450 static int mtk_musb_probe(struct platform_device *pdev)
451 {
452 	struct musb_hdrc_platform_data *pdata;
453 	struct mtk_glue *glue;
454 	struct platform_device_info pinfo;
455 	struct device *dev = &pdev->dev;
456 	struct device_node *np = dev->of_node;
457 	int ret;
458 
459 	glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
460 	if (!glue)
461 		return -ENOMEM;
462 
463 	glue->dev = dev;
464 	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
465 	if (!pdata)
466 		return -ENOMEM;
467 
468 	ret = of_platform_populate(np, NULL, NULL, dev);
469 	if (ret) {
470 		dev_err(dev, "failed to create child devices at %p\n", np);
471 		return ret;
472 	}
473 
474 	ret = mtk_musb_clks_get(glue);
475 	if (ret)
476 		return ret;
477 
478 	pdata->config = &mtk_musb_hdrc_config;
479 	pdata->platform_ops = &mtk_musb_ops;
480 	pdata->mode = usb_get_dr_mode(dev);
481 
482 	if (IS_ENABLED(CONFIG_USB_MUSB_HOST))
483 		pdata->mode = USB_DR_MODE_HOST;
484 	else if (IS_ENABLED(CONFIG_USB_MUSB_GADGET))
485 		pdata->mode = USB_DR_MODE_PERIPHERAL;
486 
487 	switch (pdata->mode) {
488 	case USB_DR_MODE_HOST:
489 		glue->phy_mode = PHY_MODE_USB_HOST;
490 		glue->role = USB_ROLE_HOST;
491 		break;
492 	case USB_DR_MODE_PERIPHERAL:
493 		glue->phy_mode = PHY_MODE_USB_DEVICE;
494 		glue->role = USB_ROLE_DEVICE;
495 		break;
496 	case USB_DR_MODE_OTG:
497 		glue->phy_mode = PHY_MODE_USB_OTG;
498 		glue->role = USB_ROLE_NONE;
499 		break;
500 	default:
501 		dev_err(&pdev->dev, "Error 'dr_mode' property\n");
502 		return -EINVAL;
503 	}
504 
505 	glue->phy = devm_of_phy_get_by_index(dev, np, 0);
506 	if (IS_ERR(glue->phy)) {
507 		dev_err(dev, "fail to getting phy %ld\n",
508 			PTR_ERR(glue->phy));
509 		return PTR_ERR(glue->phy);
510 	}
511 
512 	glue->usb_phy = usb_phy_generic_register();
513 	if (IS_ERR(glue->usb_phy)) {
514 		dev_err(dev, "fail to registering usb-phy %ld\n",
515 			PTR_ERR(glue->usb_phy));
516 		return PTR_ERR(glue->usb_phy);
517 	}
518 
519 	glue->xceiv = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
520 	if (IS_ERR(glue->xceiv)) {
521 		ret = PTR_ERR(glue->xceiv);
522 		dev_err(dev, "fail to getting usb-phy %d\n", ret);
523 		goto err_unregister_usb_phy;
524 	}
525 
526 	platform_set_drvdata(pdev, glue);
527 	pm_runtime_enable(dev);
528 	pm_runtime_get_sync(dev);
529 
530 	ret = mtk_musb_clks_enable(glue);
531 	if (ret)
532 		goto err_enable_clk;
533 
534 	pinfo = mtk_dev_info;
535 	pinfo.parent = dev;
536 	pinfo.res = pdev->resource;
537 	pinfo.num_res = pdev->num_resources;
538 	pinfo.data = pdata;
539 	pinfo.size_data = sizeof(*pdata);
540 
541 	glue->musb_pdev = platform_device_register_full(&pinfo);
542 	if (IS_ERR(glue->musb_pdev)) {
543 		ret = PTR_ERR(glue->musb_pdev);
544 		dev_err(dev, "failed to register musb device: %d\n", ret);
545 		goto err_device_register;
546 	}
547 
548 	return 0;
549 
550 err_device_register:
551 	mtk_musb_clks_disable(glue);
552 err_enable_clk:
553 	pm_runtime_put_sync(dev);
554 	pm_runtime_disable(dev);
555 err_unregister_usb_phy:
556 	usb_phy_generic_unregister(glue->usb_phy);
557 	return ret;
558 }
559 
560 static int mtk_musb_remove(struct platform_device *pdev)
561 {
562 	struct mtk_glue *glue = platform_get_drvdata(pdev);
563 	struct platform_device *usb_phy = glue->usb_phy;
564 
565 	platform_device_unregister(glue->musb_pdev);
566 	usb_phy_generic_unregister(usb_phy);
567 
568 	return 0;
569 }
570 
571 #ifdef CONFIG_OF
572 static const struct of_device_id mtk_musb_match[] = {
573 	{.compatible = "mediatek,mtk-musb",},
574 	{},
575 };
576 MODULE_DEVICE_TABLE(of, mtk_musb_match);
577 #endif
578 
579 static struct platform_driver mtk_musb_driver = {
580 	.probe = mtk_musb_probe,
581 	.remove = mtk_musb_remove,
582 	.driver = {
583 		   .name = "musb-mtk",
584 		   .of_match_table = of_match_ptr(mtk_musb_match),
585 	},
586 };
587 
588 module_platform_driver(mtk_musb_driver);
589 
590 MODULE_DESCRIPTION("MediaTek MUSB Glue Layer");
591 MODULE_AUTHOR("Min Guo <min.guo@mediatek.com>");
592 MODULE_LICENSE("GPL v2");
593