1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * xhci-plat.c - xHCI host controller driver platform Bus Glue.
  4 *
  5 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
  6 * Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
  7 *
  8 * A lot of code borrowed from the Linux xHCI driver.
  9 */
 10
 11#include <linux/clk.h>
 12#include <linux/dma-mapping.h>
 13#include <linux/module.h>
 14#include <linux/pci.h>
 15#include <linux/of.h>
 16#include <linux/of_device.h>
 17#include <linux/platform_device.h>
 18#include <linux/usb/phy.h>
 19#include <linux/slab.h>
 20#include <linux/acpi.h>
 21
 22#include "xhci.h"
 23#include "xhci-plat.h"
 24#include "xhci-mvebu.h"
 25#include "xhci-rcar.h"
 26
 27static struct hc_driver __read_mostly xhci_plat_hc_driver;
 28
 29static int xhci_plat_setup(struct usb_hcd *hcd);
 30static int xhci_plat_start(struct usb_hcd *hcd);
 31
 32static const struct xhci_driver_overrides xhci_plat_overrides __initconst = {
 33	.extra_priv_size = sizeof(struct xhci_plat_priv),
 34	.reset = xhci_plat_setup,
 35	.start = xhci_plat_start,
 36};
 37
 38static void xhci_priv_plat_start(struct usb_hcd *hcd)
 39{
 40	struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 41
 42	if (priv->plat_start)
 43		priv->plat_start(hcd);
 44}
 45
 46static int xhci_priv_init_quirk(struct usb_hcd *hcd)
 47{
 48	struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 49
 50	if (!priv->init_quirk)
 51		return 0;
 52
 53	return priv->init_quirk(hcd);
 54}
 55
 56static int xhci_priv_resume_quirk(struct usb_hcd *hcd)
 57{
 58	struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 59
 60	if (!priv->resume_quirk)
 61		return 0;
 62
 63	return priv->resume_quirk(hcd);
 64}
 65
 66static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
 67{
 68	/*
 69	 * As of now platform drivers don't provide MSI support so we ensure
 70	 * here that the generic code does not try to make a pci_dev from our
 71	 * dev struct in order to setup MSI
 72	 */
 73	xhci->quirks |= XHCI_PLAT;
 74}
 75
 76/* called during probe() after chip reset completes */
 77static int xhci_plat_setup(struct usb_hcd *hcd)
 78{
 79	int ret;
 80
 81
 82	ret = xhci_priv_init_quirk(hcd);
 83	if (ret)
 84		return ret;
 85
 86	return xhci_gen_setup(hcd, xhci_plat_quirks);
 87}
 88
 89static int xhci_plat_start(struct usb_hcd *hcd)
 90{
 91	xhci_priv_plat_start(hcd);
 92	return xhci_run(hcd);
 93}
 94
 95#ifdef CONFIG_OF
 96static const struct xhci_plat_priv xhci_plat_marvell_armada = {
 97	.init_quirk = xhci_mvebu_mbus_init_quirk,
 98};
 99
100static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen2 = {
101	.firmware_name = XHCI_RCAR_FIRMWARE_NAME_V1,
102	.init_quirk = xhci_rcar_init_quirk,
103	.plat_start = xhci_rcar_start,
104	.resume_quirk = xhci_rcar_resume_quirk,
105};
106
107static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen3 = {
108	.init_quirk = xhci_rcar_init_quirk,
109	.plat_start = xhci_rcar_start,
110	.resume_quirk = xhci_rcar_resume_quirk,
111};
112
113static const struct of_device_id usb_xhci_of_match[] = {
114	{
115		.compatible = "generic-xhci",
116	}, {
117		.compatible = "xhci-platform",
118	}, {
119		.compatible = "marvell,armada-375-xhci",
120		.data = &xhci_plat_marvell_armada,
121	}, {
122		.compatible = "marvell,armada-380-xhci",
123		.data = &xhci_plat_marvell_armada,
124	}, {
125		.compatible = "renesas,xhci-r8a7790",
126		.data = &xhci_plat_renesas_rcar_gen2,
127	}, {
128		.compatible = "renesas,xhci-r8a7791",
129		.data = &xhci_plat_renesas_rcar_gen2,
130	}, {
131		.compatible = "renesas,xhci-r8a7793",
132		.data = &xhci_plat_renesas_rcar_gen2,
133	}, {
134		.compatible = "renesas,xhci-r8a7795",
135		.data = &xhci_plat_renesas_rcar_gen3,
136	}, {
137		.compatible = "renesas,xhci-r8a7796",
138		.data = &xhci_plat_renesas_rcar_gen3,
139	}, {
140		.compatible = "renesas,rcar-gen2-xhci",
141		.data = &xhci_plat_renesas_rcar_gen2,
142	}, {
143		.compatible = "renesas,rcar-gen3-xhci",
144		.data = &xhci_plat_renesas_rcar_gen3,
145	},
146	{},
147};
148MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
149#endif
150
151static int xhci_plat_probe(struct platform_device *pdev)
152{
153	const struct xhci_plat_priv *priv_match;
154	const struct hc_driver	*driver;
155	struct device		*sysdev;
156	struct xhci_hcd		*xhci;
157	struct resource         *res;
158	struct usb_hcd		*hcd;
159	struct clk              *clk;
160	struct clk              *reg_clk;
161	int			ret;
162	int			irq;
163
164	if (usb_disabled())
165		return -ENODEV;
166
167	driver = &xhci_plat_hc_driver;
168
169	irq = platform_get_irq(pdev, 0);
170	if (irq < 0)
171		return irq;
172
173	/*
174	 * sysdev must point to a device that is known to the system firmware
175	 * or PCI hardware. We handle these three cases here:
176	 * 1. xhci_plat comes from firmware
177	 * 2. xhci_plat is child of a device from firmware (dwc3-plat)
178	 * 3. xhci_plat is grandchild of a pci device (dwc3-pci)
179	 */
180	for (sysdev = &pdev->dev; sysdev; sysdev = sysdev->parent) {
181		if (is_of_node(sysdev->fwnode) ||
182			is_acpi_device_node(sysdev->fwnode))
183			break;
184#ifdef CONFIG_PCI
185		else if (sysdev->bus == &pci_bus_type)
186			break;
187#endif
188	}
189
190	if (!sysdev)
191		sysdev = &pdev->dev;
192
193	/* Try to set 64-bit DMA first */
194	if (WARN_ON(!sysdev->dma_mask))
195		/* Platform did not initialize dma_mask */
196		ret = dma_coerce_mask_and_coherent(sysdev,
197						   DMA_BIT_MASK(64));
198	else
199		ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64));
200
201	/* If seting 64-bit DMA mask fails, fall back to 32-bit DMA mask */
202	if (ret) {
203		ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32));
204		if (ret)
205			return ret;
206	}
207
208	pm_runtime_set_active(&pdev->dev);
209	pm_runtime_enable(&pdev->dev);
210	pm_runtime_get_noresume(&pdev->dev);
211
212	hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
213			       dev_name(&pdev->dev), NULL);
214	if (!hcd) {
215		ret = -ENOMEM;
216		goto disable_runtime;
217	}
218
219	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
220	hcd->regs = devm_ioremap_resource(&pdev->dev, res);
221	if (IS_ERR(hcd->regs)) {
222		ret = PTR_ERR(hcd->regs);
223		goto put_hcd;
224	}
225
226	hcd->rsrc_start = res->start;
227	hcd->rsrc_len = resource_size(res);
228
229	/*
230	 * Not all platforms have clks so it is not an error if the
231	 * clock do not exist.
232	 */
233	reg_clk = devm_clk_get(&pdev->dev, "reg");
234	if (!IS_ERR(reg_clk)) {
235		ret = clk_prepare_enable(reg_clk);
236		if (ret)
237			goto put_hcd;
238	} else if (PTR_ERR(reg_clk) == -EPROBE_DEFER) {
239		ret = -EPROBE_DEFER;
240		goto put_hcd;
241	}
242
243	clk = devm_clk_get(&pdev->dev, NULL);
244	if (!IS_ERR(clk)) {
245		ret = clk_prepare_enable(clk);
246		if (ret)
247			goto disable_reg_clk;
248	} else if (PTR_ERR(clk) == -EPROBE_DEFER) {
249		ret = -EPROBE_DEFER;
250		goto disable_reg_clk;
251	}
252
253	xhci = hcd_to_xhci(hcd);
254	priv_match = of_device_get_match_data(&pdev->dev);
255	if (priv_match) {
256		struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
257
258		/* Just copy data for now */
259		if (priv_match)
260			*priv = *priv_match;
261	}
262
263	device_wakeup_enable(hcd->self.controller);
264
265	xhci->clk = clk;
266	xhci->reg_clk = reg_clk;
267	xhci->main_hcd = hcd;
268	xhci->shared_hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
269			dev_name(&pdev->dev), hcd);
270	if (!xhci->shared_hcd) {
271		ret = -ENOMEM;
272		goto disable_clk;
273	}
274
275	if (device_property_read_bool(sysdev, "usb2-lpm-disable"))
276		xhci->quirks |= XHCI_HW_LPM_DISABLE;
277
278	if (device_property_read_bool(sysdev, "usb3-lpm-capable"))
279		xhci->quirks |= XHCI_LPM_SUPPORT;
280
281	if (device_property_read_bool(&pdev->dev, "quirk-broken-port-ped"))
282		xhci->quirks |= XHCI_BROKEN_PORT_PED;
283
284	/* imod_interval is the interrupt moderation value in nanoseconds. */
285	xhci->imod_interval = 40000;
286	device_property_read_u32(sysdev, "imod-interval-ns",
287				 &xhci->imod_interval);
288
289	hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0);
290	if (IS_ERR(hcd->usb_phy)) {
291		ret = PTR_ERR(hcd->usb_phy);
292		if (ret == -EPROBE_DEFER)
293			goto put_usb3_hcd;
294		hcd->usb_phy = NULL;
295	} else {
296		ret = usb_phy_init(hcd->usb_phy);
297		if (ret)
298			goto put_usb3_hcd;
299		hcd->skip_phy_initialization = 1;
300	}
301
302	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
303	if (ret)
304		goto disable_usb_phy;
305
306	if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
307		xhci->shared_hcd->can_do_streams = 1;
308
309	ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
310	if (ret)
311		goto dealloc_usb2_hcd;
312
313	device_enable_async_suspend(&pdev->dev);
314	pm_runtime_put_noidle(&pdev->dev);
315
316	/*
317	 * Prevent runtime pm from being on as default, users should enable
318	 * runtime pm using power/control in sysfs.
319	 */
320	pm_runtime_forbid(&pdev->dev);
321
322	return 0;
323
324
325dealloc_usb2_hcd:
326	usb_remove_hcd(hcd);
327
328disable_usb_phy:
329	usb_phy_shutdown(hcd->usb_phy);
330
331put_usb3_hcd:
332	usb_put_hcd(xhci->shared_hcd);
333
334disable_clk:
335	clk_disable_unprepare(clk);
336
337disable_reg_clk:
338	clk_disable_unprepare(reg_clk);
339
340put_hcd:
341	usb_put_hcd(hcd);
342
343disable_runtime:
344	pm_runtime_put_noidle(&pdev->dev);
345	pm_runtime_disable(&pdev->dev);
346
347	return ret;
348}
349
350static int xhci_plat_remove(struct platform_device *dev)
351{
352	struct usb_hcd	*hcd = platform_get_drvdata(dev);
353	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
354	struct clk *clk = xhci->clk;
355	struct clk *reg_clk = xhci->reg_clk;
356
357	xhci->xhc_state |= XHCI_STATE_REMOVING;
358
359	usb_remove_hcd(xhci->shared_hcd);
360	usb_phy_shutdown(hcd->usb_phy);
361
362	usb_remove_hcd(hcd);
363	usb_put_hcd(xhci->shared_hcd);
364
365	clk_disable_unprepare(clk);
366	clk_disable_unprepare(reg_clk);
367	usb_put_hcd(hcd);
368
369	pm_runtime_set_suspended(&dev->dev);
370	pm_runtime_disable(&dev->dev);
371
372	return 0;
373}
374
375static int __maybe_unused xhci_plat_suspend(struct device *dev)
376{
377	struct usb_hcd	*hcd = dev_get_drvdata(dev);
378	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
379
380	/*
381	 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
382	 * to do wakeup during suspend. Since xhci_plat_suspend is currently
383	 * only designed for system suspend, device_may_wakeup() is enough
384	 * to dertermine whether host is allowed to do wakeup. Need to
385	 * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
386	 * also applies to runtime suspend.
387	 */
388	return xhci_suspend(xhci, device_may_wakeup(dev));
389}
390
391static int __maybe_unused xhci_plat_resume(struct device *dev)
392{
393	struct usb_hcd	*hcd = dev_get_drvdata(dev);
394	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
395	int ret;
396
397	ret = xhci_priv_resume_quirk(hcd);
398	if (ret)
399		return ret;
400
401	return xhci_resume(xhci, 0);
402}
403
404static int __maybe_unused xhci_plat_runtime_suspend(struct device *dev)
405{
406	struct usb_hcd  *hcd = dev_get_drvdata(dev);
407	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
408
409	return xhci_suspend(xhci, true);
410}
411
412static int __maybe_unused xhci_plat_runtime_resume(struct device *dev)
413{
414	struct usb_hcd  *hcd = dev_get_drvdata(dev);
415	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
416
417	return xhci_resume(xhci, 0);
418}
419
420static const struct dev_pm_ops xhci_plat_pm_ops = {
421	SET_SYSTEM_SLEEP_PM_OPS(xhci_plat_suspend, xhci_plat_resume)
422
423	SET_RUNTIME_PM_OPS(xhci_plat_runtime_suspend,
424			   xhci_plat_runtime_resume,
425			   NULL)
426};
427
428static const struct acpi_device_id usb_xhci_acpi_match[] = {
429	/* XHCI-compliant USB Controller */
430	{ "PNP0D10", },
431	{ }
432};
433MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match);
434
435static struct platform_driver usb_xhci_driver = {
436	.probe	= xhci_plat_probe,
437	.remove	= xhci_plat_remove,
438	.driver	= {
439		.name = "xhci-hcd",
440		.pm = &xhci_plat_pm_ops,
441		.of_match_table = of_match_ptr(usb_xhci_of_match),
442		.acpi_match_table = ACPI_PTR(usb_xhci_acpi_match),
443	},
444};
445MODULE_ALIAS("platform:xhci-hcd");
446
447static int __init xhci_plat_init(void)
448{
449	xhci_init_driver(&xhci_plat_hc_driver, &xhci_plat_overrides);
450	return platform_driver_register(&usb_xhci_driver);
451}
452module_init(xhci_plat_init);
453
454static void __exit xhci_plat_exit(void)
455{
456	platform_driver_unregister(&usb_xhci_driver);
457}
458module_exit(xhci_plat_exit);
459
460MODULE_DESCRIPTION("xHCI Platform Host Controller Driver");
461MODULE_LICENSE("GPL");