mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 18:39:59 +00:00
![Tejas Joglekar](/assets/img/avatar_default.png)
This commit uses the private data passed by parent device to set the quirk for Synopsys xHC. This patch fixes the SNPS xHC hang issue when the data is scattered across small buffers which does not make atleast MPS size for given TRB cache size of SNPS xHC. Signed-off-by: Tejas Joglekar <joglekar@synopsys.com> Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com> Link: https://lore.kernel.org/r/20201208092912.1773650-2-mathias.nyman@linux.intel.com Cc: stable <stable@vger.kernel.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
518 lines
12 KiB
C
518 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* xhci-plat.c - xHCI host controller driver platform Bus Glue.
|
|
*
|
|
* Copyright (C) 2012 Texas Instruments Incorporated - https://www.ti.com
|
|
* Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
|
|
*
|
|
* A lot of code borrowed from the Linux xHCI driver.
|
|
*/
|
|
|
|
#include <linux/clk.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/usb/phy.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/usb/of.h>
|
|
|
|
#include "xhci.h"
|
|
#include "xhci-plat.h"
|
|
#include "xhci-mvebu.h"
|
|
#include "xhci-rcar.h"
|
|
|
|
static struct hc_driver __read_mostly xhci_plat_hc_driver;
|
|
|
|
static int xhci_plat_setup(struct usb_hcd *hcd);
|
|
static int xhci_plat_start(struct usb_hcd *hcd);
|
|
|
|
static const struct xhci_driver_overrides xhci_plat_overrides __initconst = {
|
|
.extra_priv_size = sizeof(struct xhci_plat_priv),
|
|
.reset = xhci_plat_setup,
|
|
.start = xhci_plat_start,
|
|
};
|
|
|
|
static void xhci_priv_plat_start(struct usb_hcd *hcd)
|
|
{
|
|
struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
|
|
|
|
if (priv->plat_start)
|
|
priv->plat_start(hcd);
|
|
}
|
|
|
|
static int xhci_priv_init_quirk(struct usb_hcd *hcd)
|
|
{
|
|
struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
|
|
|
|
if (!priv->init_quirk)
|
|
return 0;
|
|
|
|
return priv->init_quirk(hcd);
|
|
}
|
|
|
|
static int xhci_priv_suspend_quirk(struct usb_hcd *hcd)
|
|
{
|
|
struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
|
|
|
|
if (!priv->suspend_quirk)
|
|
return 0;
|
|
|
|
return priv->suspend_quirk(hcd);
|
|
}
|
|
|
|
static int xhci_priv_resume_quirk(struct usb_hcd *hcd)
|
|
{
|
|
struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
|
|
|
|
if (!priv->resume_quirk)
|
|
return 0;
|
|
|
|
return priv->resume_quirk(hcd);
|
|
}
|
|
|
|
static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
|
|
{
|
|
struct xhci_plat_priv *priv = xhci_to_priv(xhci);
|
|
|
|
/*
|
|
* As of now platform drivers don't provide MSI support so we ensure
|
|
* here that the generic code does not try to make a pci_dev from our
|
|
* dev struct in order to setup MSI
|
|
*/
|
|
xhci->quirks |= XHCI_PLAT | priv->quirks;
|
|
}
|
|
|
|
/* called during probe() after chip reset completes */
|
|
static int xhci_plat_setup(struct usb_hcd *hcd)
|
|
{
|
|
int ret;
|
|
|
|
|
|
ret = xhci_priv_init_quirk(hcd);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return xhci_gen_setup(hcd, xhci_plat_quirks);
|
|
}
|
|
|
|
static int xhci_plat_start(struct usb_hcd *hcd)
|
|
{
|
|
xhci_priv_plat_start(hcd);
|
|
return xhci_run(hcd);
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct xhci_plat_priv xhci_plat_marvell_armada = {
|
|
.init_quirk = xhci_mvebu_mbus_init_quirk,
|
|
};
|
|
|
|
static const struct xhci_plat_priv xhci_plat_marvell_armada3700 = {
|
|
.init_quirk = xhci_mvebu_a3700_init_quirk,
|
|
};
|
|
|
|
static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen2 = {
|
|
SET_XHCI_PLAT_PRIV_FOR_RCAR(XHCI_RCAR_FIRMWARE_NAME_V1)
|
|
};
|
|
|
|
static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen3 = {
|
|
SET_XHCI_PLAT_PRIV_FOR_RCAR(XHCI_RCAR_FIRMWARE_NAME_V3)
|
|
};
|
|
|
|
static const struct xhci_plat_priv xhci_plat_brcm = {
|
|
.quirks = XHCI_RESET_ON_RESUME,
|
|
};
|
|
|
|
static const struct of_device_id usb_xhci_of_match[] = {
|
|
{
|
|
.compatible = "generic-xhci",
|
|
}, {
|
|
.compatible = "xhci-platform",
|
|
}, {
|
|
.compatible = "marvell,armada-375-xhci",
|
|
.data = &xhci_plat_marvell_armada,
|
|
}, {
|
|
.compatible = "marvell,armada-380-xhci",
|
|
.data = &xhci_plat_marvell_armada,
|
|
}, {
|
|
.compatible = "marvell,armada3700-xhci",
|
|
.data = &xhci_plat_marvell_armada3700,
|
|
}, {
|
|
.compatible = "renesas,xhci-r8a7790",
|
|
.data = &xhci_plat_renesas_rcar_gen2,
|
|
}, {
|
|
.compatible = "renesas,xhci-r8a7791",
|
|
.data = &xhci_plat_renesas_rcar_gen2,
|
|
}, {
|
|
.compatible = "renesas,xhci-r8a7793",
|
|
.data = &xhci_plat_renesas_rcar_gen2,
|
|
}, {
|
|
.compatible = "renesas,xhci-r8a7795",
|
|
.data = &xhci_plat_renesas_rcar_gen3,
|
|
}, {
|
|
.compatible = "renesas,xhci-r8a7796",
|
|
.data = &xhci_plat_renesas_rcar_gen3,
|
|
}, {
|
|
.compatible = "renesas,rcar-gen2-xhci",
|
|
.data = &xhci_plat_renesas_rcar_gen2,
|
|
}, {
|
|
.compatible = "renesas,rcar-gen3-xhci",
|
|
.data = &xhci_plat_renesas_rcar_gen3,
|
|
}, {
|
|
.compatible = "brcm,xhci-brcm-v2",
|
|
.data = &xhci_plat_brcm,
|
|
}, {
|
|
.compatible = "brcm,bcm7445-xhci",
|
|
.data = &xhci_plat_brcm,
|
|
},
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
|
|
#endif
|
|
|
|
static int xhci_plat_probe(struct platform_device *pdev)
|
|
{
|
|
const struct xhci_plat_priv *priv_match;
|
|
const struct hc_driver *driver;
|
|
struct device *sysdev, *tmpdev;
|
|
struct xhci_hcd *xhci;
|
|
struct resource *res;
|
|
struct usb_hcd *hcd;
|
|
int ret;
|
|
int irq;
|
|
struct xhci_plat_priv *priv = NULL;
|
|
|
|
|
|
if (usb_disabled())
|
|
return -ENODEV;
|
|
|
|
driver = &xhci_plat_hc_driver;
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
if (irq < 0)
|
|
return irq;
|
|
|
|
/*
|
|
* sysdev must point to a device that is known to the system firmware
|
|
* or PCI hardware. We handle these three cases here:
|
|
* 1. xhci_plat comes from firmware
|
|
* 2. xhci_plat is child of a device from firmware (dwc3-plat)
|
|
* 3. xhci_plat is grandchild of a pci device (dwc3-pci)
|
|
*/
|
|
for (sysdev = &pdev->dev; sysdev; sysdev = sysdev->parent) {
|
|
if (is_of_node(sysdev->fwnode) ||
|
|
is_acpi_device_node(sysdev->fwnode))
|
|
break;
|
|
#ifdef CONFIG_PCI
|
|
else if (sysdev->bus == &pci_bus_type)
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
if (!sysdev)
|
|
sysdev = &pdev->dev;
|
|
|
|
/* Try to set 64-bit DMA first */
|
|
if (WARN_ON(!sysdev->dma_mask))
|
|
/* Platform did not initialize dma_mask */
|
|
ret = dma_coerce_mask_and_coherent(sysdev,
|
|
DMA_BIT_MASK(64));
|
|
else
|
|
ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64));
|
|
|
|
/* If seting 64-bit DMA mask fails, fall back to 32-bit DMA mask */
|
|
if (ret) {
|
|
ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
pm_runtime_set_active(&pdev->dev);
|
|
pm_runtime_enable(&pdev->dev);
|
|
pm_runtime_get_noresume(&pdev->dev);
|
|
|
|
hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
|
|
dev_name(&pdev->dev), NULL);
|
|
if (!hcd) {
|
|
ret = -ENOMEM;
|
|
goto disable_runtime;
|
|
}
|
|
|
|
hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
|
|
if (IS_ERR(hcd->regs)) {
|
|
ret = PTR_ERR(hcd->regs);
|
|
goto put_hcd;
|
|
}
|
|
|
|
hcd->rsrc_start = res->start;
|
|
hcd->rsrc_len = resource_size(res);
|
|
|
|
xhci = hcd_to_xhci(hcd);
|
|
|
|
/*
|
|
* Not all platforms have clks so it is not an error if the
|
|
* clock do not exist.
|
|
*/
|
|
xhci->reg_clk = devm_clk_get_optional(&pdev->dev, "reg");
|
|
if (IS_ERR(xhci->reg_clk)) {
|
|
ret = PTR_ERR(xhci->reg_clk);
|
|
goto put_hcd;
|
|
}
|
|
|
|
ret = clk_prepare_enable(xhci->reg_clk);
|
|
if (ret)
|
|
goto put_hcd;
|
|
|
|
xhci->clk = devm_clk_get_optional(&pdev->dev, NULL);
|
|
if (IS_ERR(xhci->clk)) {
|
|
ret = PTR_ERR(xhci->clk);
|
|
goto disable_reg_clk;
|
|
}
|
|
|
|
ret = clk_prepare_enable(xhci->clk);
|
|
if (ret)
|
|
goto disable_reg_clk;
|
|
|
|
if (pdev->dev.of_node)
|
|
priv_match = of_device_get_match_data(&pdev->dev);
|
|
else
|
|
priv_match = dev_get_platdata(&pdev->dev);
|
|
|
|
if (priv_match) {
|
|
priv = hcd_to_xhci_priv(hcd);
|
|
/* Just copy data for now */
|
|
*priv = *priv_match;
|
|
}
|
|
|
|
device_set_wakeup_capable(&pdev->dev, true);
|
|
|
|
xhci->main_hcd = hcd;
|
|
xhci->shared_hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
|
|
dev_name(&pdev->dev), hcd);
|
|
if (!xhci->shared_hcd) {
|
|
ret = -ENOMEM;
|
|
goto disable_clk;
|
|
}
|
|
|
|
/* imod_interval is the interrupt moderation value in nanoseconds. */
|
|
xhci->imod_interval = 40000;
|
|
|
|
/* Iterate over all parent nodes for finding quirks */
|
|
for (tmpdev = &pdev->dev; tmpdev; tmpdev = tmpdev->parent) {
|
|
|
|
if (device_property_read_bool(tmpdev, "usb2-lpm-disable"))
|
|
xhci->quirks |= XHCI_HW_LPM_DISABLE;
|
|
|
|
if (device_property_read_bool(tmpdev, "usb3-lpm-capable"))
|
|
xhci->quirks |= XHCI_LPM_SUPPORT;
|
|
|
|
if (device_property_read_bool(tmpdev, "quirk-broken-port-ped"))
|
|
xhci->quirks |= XHCI_BROKEN_PORT_PED;
|
|
|
|
device_property_read_u32(tmpdev, "imod-interval-ns",
|
|
&xhci->imod_interval);
|
|
}
|
|
|
|
hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0);
|
|
if (IS_ERR(hcd->usb_phy)) {
|
|
ret = PTR_ERR(hcd->usb_phy);
|
|
if (ret == -EPROBE_DEFER)
|
|
goto put_usb3_hcd;
|
|
hcd->usb_phy = NULL;
|
|
} else {
|
|
ret = usb_phy_init(hcd->usb_phy);
|
|
if (ret)
|
|
goto put_usb3_hcd;
|
|
}
|
|
|
|
hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node);
|
|
xhci->shared_hcd->tpl_support = hcd->tpl_support;
|
|
if (priv && (priv->quirks & XHCI_SKIP_PHY_INIT))
|
|
hcd->skip_phy_initialization = 1;
|
|
|
|
if (priv && (priv->quirks & XHCI_SG_TRB_CACHE_SIZE_QUIRK))
|
|
xhci->quirks |= XHCI_SG_TRB_CACHE_SIZE_QUIRK;
|
|
|
|
ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
|
|
if (ret)
|
|
goto disable_usb_phy;
|
|
|
|
if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
|
|
xhci->shared_hcd->can_do_streams = 1;
|
|
|
|
ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
|
|
if (ret)
|
|
goto dealloc_usb2_hcd;
|
|
|
|
device_enable_async_suspend(&pdev->dev);
|
|
pm_runtime_put_noidle(&pdev->dev);
|
|
|
|
/*
|
|
* Prevent runtime pm from being on as default, users should enable
|
|
* runtime pm using power/control in sysfs.
|
|
*/
|
|
pm_runtime_forbid(&pdev->dev);
|
|
|
|
return 0;
|
|
|
|
|
|
dealloc_usb2_hcd:
|
|
usb_remove_hcd(hcd);
|
|
|
|
disable_usb_phy:
|
|
usb_phy_shutdown(hcd->usb_phy);
|
|
|
|
put_usb3_hcd:
|
|
usb_put_hcd(xhci->shared_hcd);
|
|
|
|
disable_clk:
|
|
clk_disable_unprepare(xhci->clk);
|
|
|
|
disable_reg_clk:
|
|
clk_disable_unprepare(xhci->reg_clk);
|
|
|
|
put_hcd:
|
|
usb_put_hcd(hcd);
|
|
|
|
disable_runtime:
|
|
pm_runtime_put_noidle(&pdev->dev);
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int xhci_plat_remove(struct platform_device *dev)
|
|
{
|
|
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
|
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
|
|
struct clk *clk = xhci->clk;
|
|
struct clk *reg_clk = xhci->reg_clk;
|
|
struct usb_hcd *shared_hcd = xhci->shared_hcd;
|
|
|
|
pm_runtime_get_sync(&dev->dev);
|
|
xhci->xhc_state |= XHCI_STATE_REMOVING;
|
|
|
|
usb_remove_hcd(shared_hcd);
|
|
xhci->shared_hcd = NULL;
|
|
usb_phy_shutdown(hcd->usb_phy);
|
|
|
|
usb_remove_hcd(hcd);
|
|
usb_put_hcd(shared_hcd);
|
|
|
|
clk_disable_unprepare(clk);
|
|
clk_disable_unprepare(reg_clk);
|
|
usb_put_hcd(hcd);
|
|
|
|
pm_runtime_disable(&dev->dev);
|
|
pm_runtime_put_noidle(&dev->dev);
|
|
pm_runtime_set_suspended(&dev->dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __maybe_unused xhci_plat_suspend(struct device *dev)
|
|
{
|
|
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
|
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
|
|
int ret;
|
|
|
|
ret = xhci_priv_suspend_quirk(hcd);
|
|
if (ret)
|
|
return ret;
|
|
/*
|
|
* xhci_suspend() needs `do_wakeup` to know whether host is allowed
|
|
* to do wakeup during suspend.
|
|
*/
|
|
return xhci_suspend(xhci, device_may_wakeup(dev));
|
|
}
|
|
|
|
static int __maybe_unused xhci_plat_resume(struct device *dev)
|
|
{
|
|
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
|
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
|
|
int ret;
|
|
|
|
ret = xhci_priv_resume_quirk(hcd);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = xhci_resume(xhci, 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
pm_runtime_disable(dev);
|
|
pm_runtime_set_active(dev);
|
|
pm_runtime_enable(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __maybe_unused xhci_plat_runtime_suspend(struct device *dev)
|
|
{
|
|
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
|
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
|
|
int ret;
|
|
|
|
ret = xhci_priv_suspend_quirk(hcd);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return xhci_suspend(xhci, true);
|
|
}
|
|
|
|
static int __maybe_unused xhci_plat_runtime_resume(struct device *dev)
|
|
{
|
|
struct usb_hcd *hcd = dev_get_drvdata(dev);
|
|
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
|
|
|
|
return xhci_resume(xhci, 0);
|
|
}
|
|
|
|
static const struct dev_pm_ops xhci_plat_pm_ops = {
|
|
SET_SYSTEM_SLEEP_PM_OPS(xhci_plat_suspend, xhci_plat_resume)
|
|
|
|
SET_RUNTIME_PM_OPS(xhci_plat_runtime_suspend,
|
|
xhci_plat_runtime_resume,
|
|
NULL)
|
|
};
|
|
|
|
#ifdef CONFIG_ACPI
|
|
static const struct acpi_device_id usb_xhci_acpi_match[] = {
|
|
/* XHCI-compliant USB Controller */
|
|
{ "PNP0D10", },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match);
|
|
#endif
|
|
|
|
static struct platform_driver usb_xhci_driver = {
|
|
.probe = xhci_plat_probe,
|
|
.remove = xhci_plat_remove,
|
|
.shutdown = usb_hcd_platform_shutdown,
|
|
.driver = {
|
|
.name = "xhci-hcd",
|
|
.pm = &xhci_plat_pm_ops,
|
|
.of_match_table = of_match_ptr(usb_xhci_of_match),
|
|
.acpi_match_table = ACPI_PTR(usb_xhci_acpi_match),
|
|
},
|
|
};
|
|
MODULE_ALIAS("platform:xhci-hcd");
|
|
|
|
static int __init xhci_plat_init(void)
|
|
{
|
|
xhci_init_driver(&xhci_plat_hc_driver, &xhci_plat_overrides);
|
|
return platform_driver_register(&usb_xhci_driver);
|
|
}
|
|
module_init(xhci_plat_init);
|
|
|
|
static void __exit xhci_plat_exit(void)
|
|
{
|
|
platform_driver_unregister(&usb_xhci_driver);
|
|
}
|
|
module_exit(xhci_plat_exit);
|
|
|
|
MODULE_DESCRIPTION("xHCI Platform Host Controller Driver");
|
|
MODULE_LICENSE("GPL");
|