linux/drivers/usb/host/xhci-histb.c
Mathias Nyman f068090426 xhci: Fix leaking USB3 shared_hcd at xhci removal
Ensure that the shared_hcd pointer is valid when calling usb_put_hcd()

The shared_hcd is removed and freed in xhci by first calling
usb_remove_hcd(xhci->shared_hcd), and later
usb_put_hcd(xhci->shared_hcd)

Afer commit fe190ed0d6 ("xhci: Do not halt the host until both HCD have
disconnected their devices.") the shared_hcd was never properly put as
xhci->shared_hcd was set to NULL before usb_put_hcd(xhci->shared_hcd) was
called.

shared_hcd (USB3) is removed before primary hcd (USB2).
While removing the primary hcd we might need to handle xhci interrupts
to cleanly remove last USB2 devices, therefore we need to set
xhci->shared_hcd to NULL before removing the primary hcd to let xhci
interrupt handler know shared_hcd is no longer available.

xhci-plat.c, xhci-histb.c and xhci-mtk first create both their hcd's before
adding them. so to keep the correct reverse removal order use a temporary
shared_hcd variable for them.
For more details see commit 4ac53087d6 ("usb: xhci: plat: Create both
HCDs before adding them")

Fixes: fe190ed0d6 ("xhci: Do not halt the host until both HCD have disconnected their devices.")
Cc: Joel Stanley <joel@jms.id.au>
Cc: Chunfeng Yun <chunfeng.yun@mediatek.com>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Jianguo Sun <sunjianguo1@huawei.com>
Cc: <stable@vger.kernel.org>
Reported-by: Jack Pham <jackp@codeaurora.org>
Tested-by: Jack Pham <jackp@codeaurora.org>
Tested-by: Peter Chen <peter.chen@nxp.com>
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-11-09 08:31:08 -08:00

413 lines
9.6 KiB
C

// SPDX-License-Identifier: GPL-2.0
/*
* xHCI host controller driver for HiSilicon STB SoCs
*
* Copyright (C) 2017-2018 HiSilicon Co., Ltd. http://www.hisilicon.com
*
* Authors: Jianguo Sun <sunjianguo1@huawei.com>
*/
#include <linux/clk.h>
#include <linux/dma-mapping.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>
#include "xhci.h"
#define GTXTHRCFG 0xc108
#define GRXTHRCFG 0xc10c
#define REG_GUSB2PHYCFG0 0xc200
#define BIT_UTMI_8_16 BIT(3)
#define BIT_UTMI_ULPI BIT(4)
#define BIT_FREECLK_EXIST BIT(30)
#define REG_GUSB3PIPECTL0 0xc2c0
#define USB3_DEEMPHASIS_MASK GENMASK(2, 1)
#define USB3_DEEMPHASIS0 BIT(1)
#define USB3_TX_MARGIN1 BIT(4)
struct xhci_hcd_histb {
struct device *dev;
struct usb_hcd *hcd;
void __iomem *ctrl;
struct clk *bus_clk;
struct clk *utmi_clk;
struct clk *pipe_clk;
struct clk *suspend_clk;
struct reset_control *soft_reset;
};
static inline struct xhci_hcd_histb *hcd_to_histb(struct usb_hcd *hcd)
{
return dev_get_drvdata(hcd->self.controller);
}
static int xhci_histb_config(struct xhci_hcd_histb *histb)
{
struct device_node *np = histb->dev->of_node;
u32 regval;
if (of_property_match_string(np, "phys-names", "inno") >= 0) {
/* USB2 PHY chose ulpi 8bit interface */
regval = readl(histb->ctrl + REG_GUSB2PHYCFG0);
regval &= ~BIT_UTMI_ULPI;
regval &= ~(BIT_UTMI_8_16);
regval &= ~BIT_FREECLK_EXIST;
writel(regval, histb->ctrl + REG_GUSB2PHYCFG0);
}
if (of_property_match_string(np, "phys-names", "combo") >= 0) {
/*
* write 0x010c0012 to GUSB3PIPECTL0
* GUSB3PIPECTL0[5:3] = 010 : Tx Margin = 900mV ,
* decrease TX voltage
* GUSB3PIPECTL0[2:1] = 01 : Tx Deemphasis = -3.5dB,
* refer to xHCI spec
*/
regval = readl(histb->ctrl + REG_GUSB3PIPECTL0);
regval &= ~USB3_DEEMPHASIS_MASK;
regval |= USB3_DEEMPHASIS0;
regval |= USB3_TX_MARGIN1;
writel(regval, histb->ctrl + REG_GUSB3PIPECTL0);
}
writel(0x23100000, histb->ctrl + GTXTHRCFG);
writel(0x23100000, histb->ctrl + GRXTHRCFG);
return 0;
}
static int xhci_histb_clks_get(struct xhci_hcd_histb *histb)
{
struct device *dev = histb->dev;
histb->bus_clk = devm_clk_get(dev, "bus");
if (IS_ERR(histb->bus_clk)) {
dev_err(dev, "fail to get bus clk\n");
return PTR_ERR(histb->bus_clk);
}
histb->utmi_clk = devm_clk_get(dev, "utmi");
if (IS_ERR(histb->utmi_clk)) {
dev_err(dev, "fail to get utmi clk\n");
return PTR_ERR(histb->utmi_clk);
}
histb->pipe_clk = devm_clk_get(dev, "pipe");
if (IS_ERR(histb->pipe_clk)) {
dev_err(dev, "fail to get pipe clk\n");
return PTR_ERR(histb->pipe_clk);
}
histb->suspend_clk = devm_clk_get(dev, "suspend");
if (IS_ERR(histb->suspend_clk)) {
dev_err(dev, "fail to get suspend clk\n");
return PTR_ERR(histb->suspend_clk);
}
return 0;
}
static int xhci_histb_host_enable(struct xhci_hcd_histb *histb)
{
int ret;
ret = clk_prepare_enable(histb->bus_clk);
if (ret) {
dev_err(histb->dev, "failed to enable bus clk\n");
return ret;
}
ret = clk_prepare_enable(histb->utmi_clk);
if (ret) {
dev_err(histb->dev, "failed to enable utmi clk\n");
goto err_utmi_clk;
}
ret = clk_prepare_enable(histb->pipe_clk);
if (ret) {
dev_err(histb->dev, "failed to enable pipe clk\n");
goto err_pipe_clk;
}
ret = clk_prepare_enable(histb->suspend_clk);
if (ret) {
dev_err(histb->dev, "failed to enable suspend clk\n");
goto err_suspend_clk;
}
reset_control_deassert(histb->soft_reset);
return 0;
err_suspend_clk:
clk_disable_unprepare(histb->pipe_clk);
err_pipe_clk:
clk_disable_unprepare(histb->utmi_clk);
err_utmi_clk:
clk_disable_unprepare(histb->bus_clk);
return ret;
}
static void xhci_histb_host_disable(struct xhci_hcd_histb *histb)
{
reset_control_assert(histb->soft_reset);
clk_disable_unprepare(histb->suspend_clk);
clk_disable_unprepare(histb->pipe_clk);
clk_disable_unprepare(histb->utmi_clk);
clk_disable_unprepare(histb->bus_clk);
}
static void xhci_histb_quirks(struct device *dev, struct xhci_hcd *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;
}
/* called during probe() after chip reset completes */
static int xhci_histb_setup(struct usb_hcd *hcd)
{
struct xhci_hcd_histb *histb = hcd_to_histb(hcd);
int ret;
if (usb_hcd_is_primary_hcd(hcd)) {
ret = xhci_histb_config(histb);
if (ret)
return ret;
}
return xhci_gen_setup(hcd, xhci_histb_quirks);
}
static const struct xhci_driver_overrides xhci_histb_overrides __initconst = {
.reset = xhci_histb_setup,
};
static struct hc_driver __read_mostly xhci_histb_hc_driver;
static int xhci_histb_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct xhci_hcd_histb *histb;
const struct hc_driver *driver;
struct usb_hcd *hcd;
struct xhci_hcd *xhci;
struct resource *res;
int irq;
int ret = -ENODEV;
if (usb_disabled())
return -ENODEV;
driver = &xhci_histb_hc_driver;
histb = devm_kzalloc(dev, sizeof(*histb), GFP_KERNEL);
if (!histb)
return -ENOMEM;
histb->dev = dev;
irq = platform_get_irq(pdev, 0);
if (irq < 0)
return irq;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
histb->ctrl = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(histb->ctrl))
return PTR_ERR(histb->ctrl);
ret = xhci_histb_clks_get(histb);
if (ret)
return ret;
histb->soft_reset = devm_reset_control_get(dev, "soft");
if (IS_ERR(histb->soft_reset)) {
dev_err(dev, "failed to get soft reset\n");
return PTR_ERR(histb->soft_reset);
}
pm_runtime_enable(dev);
pm_runtime_get_sync(dev);
device_enable_async_suspend(dev);
/* Initialize dma_mask and coherent_dma_mask to 32-bits */
ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
if (ret)
return ret;
hcd = usb_create_hcd(driver, dev, dev_name(dev));
if (!hcd) {
ret = -ENOMEM;
goto disable_pm;
}
hcd->regs = histb->ctrl;
hcd->rsrc_start = res->start;
hcd->rsrc_len = resource_size(res);
histb->hcd = hcd;
dev_set_drvdata(hcd->self.controller, histb);
ret = xhci_histb_host_enable(histb);
if (ret)
goto put_hcd;
xhci = hcd_to_xhci(hcd);
device_wakeup_enable(hcd->self.controller);
xhci->main_hcd = hcd;
xhci->shared_hcd = usb_create_shared_hcd(driver, dev, dev_name(dev),
hcd);
if (!xhci->shared_hcd) {
ret = -ENOMEM;
goto disable_host;
}
if (device_property_read_bool(dev, "usb2-lpm-disable"))
xhci->quirks |= XHCI_HW_LPM_DISABLE;
if (device_property_read_bool(dev, "usb3-lpm-capable"))
xhci->quirks |= XHCI_LPM_SUPPORT;
/* imod_interval is the interrupt moderation value in nanoseconds. */
xhci->imod_interval = 40000;
device_property_read_u32(dev, "imod-interval-ns",
&xhci->imod_interval);
ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
if (ret)
goto put_usb3_hcd;
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(dev);
pm_runtime_put_noidle(dev);
/*
* Prevent runtime pm from being on as default, users should enable
* runtime pm using power/control in sysfs.
*/
pm_runtime_forbid(dev);
return 0;
dealloc_usb2_hcd:
usb_remove_hcd(hcd);
put_usb3_hcd:
usb_put_hcd(xhci->shared_hcd);
disable_host:
xhci_histb_host_disable(histb);
put_hcd:
usb_put_hcd(hcd);
disable_pm:
pm_runtime_put_sync(dev);
pm_runtime_disable(dev);
return ret;
}
static int xhci_histb_remove(struct platform_device *dev)
{
struct xhci_hcd_histb *histb = platform_get_drvdata(dev);
struct usb_hcd *hcd = histb->hcd;
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct usb_hcd *shared_hcd = xhci->shared_hcd;
xhci->xhc_state |= XHCI_STATE_REMOVING;
usb_remove_hcd(shared_hcd);
xhci->shared_hcd = NULL;
device_wakeup_disable(&dev->dev);
usb_remove_hcd(hcd);
usb_put_hcd(shared_hcd);
xhci_histb_host_disable(histb);
usb_put_hcd(hcd);
pm_runtime_put_sync(&dev->dev);
pm_runtime_disable(&dev->dev);
return 0;
}
static int __maybe_unused xhci_histb_suspend(struct device *dev)
{
struct xhci_hcd_histb *histb = dev_get_drvdata(dev);
struct usb_hcd *hcd = histb->hcd;
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
int ret;
ret = xhci_suspend(xhci, device_may_wakeup(dev));
if (!device_may_wakeup(dev))
xhci_histb_host_disable(histb);
return ret;
}
static int __maybe_unused xhci_histb_resume(struct device *dev)
{
struct xhci_hcd_histb *histb = dev_get_drvdata(dev);
struct usb_hcd *hcd = histb->hcd;
struct xhci_hcd *xhci = hcd_to_xhci(hcd);
if (!device_may_wakeup(dev))
xhci_histb_host_enable(histb);
return xhci_resume(xhci, 0);
}
static const struct dev_pm_ops xhci_histb_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(xhci_histb_suspend, xhci_histb_resume)
};
#define DEV_PM_OPS (IS_ENABLED(CONFIG_PM) ? &xhci_histb_pm_ops : NULL)
#ifdef CONFIG_OF
static const struct of_device_id histb_xhci_of_match[] = {
{ .compatible = "hisilicon,hi3798cv200-xhci"},
{ },
};
MODULE_DEVICE_TABLE(of, histb_xhci_of_match);
#endif
static struct platform_driver histb_xhci_driver = {
.probe = xhci_histb_probe,
.remove = xhci_histb_remove,
.driver = {
.name = "xhci-histb",
.pm = DEV_PM_OPS,
.of_match_table = of_match_ptr(histb_xhci_of_match),
},
};
MODULE_ALIAS("platform:xhci-histb");
static int __init xhci_histb_init(void)
{
xhci_init_driver(&xhci_histb_hc_driver, &xhci_histb_overrides);
return platform_driver_register(&histb_xhci_driver);
}
module_init(xhci_histb_init);
static void __exit xhci_histb_exit(void)
{
platform_driver_unregister(&histb_xhci_driver);
}
module_exit(xhci_histb_exit);
MODULE_DESCRIPTION("HiSilicon STB xHCI Host Controller Driver");
MODULE_LICENSE("GPL v2");