[linux-block.git] / drivers / usb / host / xhci-histb.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;

	histb->ctrl = devm_platform_get_and_ioremap_resource(pdev, 0, &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");
Commit	Line	Data
c508f41d JS	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* xHCI host controller driver for HiSilicon STB SoCs
	4	*
	5	* Copyright (C) 2017-2018 HiSilicon Co., Ltd. http://www.hisilicon.com
	6	*
	7	* Authors: Jianguo Sun <sunjianguo1@huawei.com>
	8	*/
	9
	10	#include <linux/clk.h>
	11	#include <linux/dma-mapping.h>
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/of.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/pm_runtime.h>
	17	#include <linux/reset.h>
	18
	19	#include "xhci.h"
	20
	21	#define GTXTHRCFG 0xc108
	22	#define GRXTHRCFG 0xc10c
	23	#define REG_GUSB2PHYCFG0 0xc200
	24	#define BIT_UTMI_8_16 BIT(3)
	25	#define BIT_UTMI_ULPI BIT(4)
	26	#define BIT_FREECLK_EXIST BIT(30)
	27
	28	#define REG_GUSB3PIPECTL0 0xc2c0
	29	#define USB3_DEEMPHASIS_MASK GENMASK(2, 1)
	30	#define USB3_DEEMPHASIS0 BIT(1)
	31	#define USB3_TX_MARGIN1 BIT(4)
	32
	33	struct xhci_hcd_histb {
	34	struct device *dev;
	35	struct usb_hcd *hcd;
	36	void __iomem *ctrl;
	37	struct clk *bus_clk;
	38	struct clk *utmi_clk;
	39	struct clk *pipe_clk;
	40	struct clk *suspend_clk;
	41	struct reset_control *soft_reset;
	42	};
	43
	44	static inline struct xhci_hcd_histb hcd_to_histb(struct usb_hcd hcd)
	45	{
	46	return dev_get_drvdata(hcd->self.controller);
	47	}
	48
	49	static int xhci_histb_config(struct xhci_hcd_histb *histb)
	50	{
	51	struct device_node *np = histb->dev->of_node;
	52	u32 regval;
	53
	54	if (of_property_match_string(np, "phys-names", "inno") >= 0) {
	55	/* USB2 PHY chose ulpi 8bit interface */
	56	regval = readl(histb->ctrl + REG_GUSB2PHYCFG0);
	57	regval &= ~BIT_UTMI_ULPI;
	58	regval &= ~(BIT_UTMI_8_16);
	59	regval &= ~BIT_FREECLK_EXIST;
	60	writel(regval, histb->ctrl + REG_GUSB2PHYCFG0);
	61	}
	62
	63	if (of_property_match_string(np, "phys-names", "combo") >= 0) {
	64	/*
65	* write 0x010c0012 to GUSB3PIPECTL0
66	* GUSB3PIPECTL0[5:3] = 010 : Tx Margin = 900mV ,
67	* decrease TX voltage
68	* GUSB3PIPECTL0[2:1] = 01 : Tx Deemphasis = -3.5dB,
69	* refer to xHCI spec
70	*/
71	regval = readl(histb->ctrl + REG_GUSB3PIPECTL0);
72	regval &= ~USB3_DEEMPHASIS_MASK;
73	regval \|= USB3_DEEMPHASIS0;
74	regval \|= USB3_TX_MARGIN1;
75	writel(regval, histb->ctrl + REG_GUSB3PIPECTL0);
76	}
77
78	writel(0x23100000, histb->ctrl + GTXTHRCFG);
79	writel(0x23100000, histb->ctrl + GRXTHRCFG);
80
81	return 0;
82	}
83
84	static int xhci_histb_clks_get(struct xhci_hcd_histb *histb)
85	{
86	struct device *dev = histb->dev;
87
88	histb->bus_clk = devm_clk_get(dev, "bus");
89	if (IS_ERR(histb->bus_clk)) {
90	dev_err(dev, "fail to get bus clk\n");
91	return PTR_ERR(histb->bus_clk);
92	}
93
94	histb->utmi_clk = devm_clk_get(dev, "utmi");
95	if (IS_ERR(histb->utmi_clk)) {
96	dev_err(dev, "fail to get utmi clk\n");
97	return PTR_ERR(histb->utmi_clk);
98	}
99
100	histb->pipe_clk = devm_clk_get(dev, "pipe");
101	if (IS_ERR(histb->pipe_clk)) {
102	dev_err(dev, "fail to get pipe clk\n");
103	return PTR_ERR(histb->pipe_clk);
104	}
105
106	histb->suspend_clk = devm_clk_get(dev, "suspend");
107	if (IS_ERR(histb->suspend_clk)) {
108	dev_err(dev, "fail to get suspend clk\n");
109	return PTR_ERR(histb->suspend_clk);
110	}
111
112	return 0;
113	}
114
115	static int xhci_histb_host_enable(struct xhci_hcd_histb *histb)
116	{
117	int ret;
118
119	ret = clk_prepare_enable(histb->bus_clk);
120	if (ret) {
121	dev_err(histb->dev, "failed to enable bus clk\n");
122	return ret;
123	}
124
125	ret = clk_prepare_enable(histb->utmi_clk);
126	if (ret) {
127	dev_err(histb->dev, "failed to enable utmi clk\n");
128	goto err_utmi_clk;
129	}
130
131	ret = clk_prepare_enable(histb->pipe_clk);
132	if (ret) {
133	dev_err(histb->dev, "failed to enable pipe clk\n");
134	goto err_pipe_clk;
135	}
136
137	ret = clk_prepare_enable(histb->suspend_clk);
138	if (ret) {
139	dev_err(histb->dev, "failed to enable suspend clk\n");
140	goto err_suspend_clk;
141	}
142
143	reset_control_deassert(histb->soft_reset);
144
145	return 0;
146
147	err_suspend_clk:
148	clk_disable_unprepare(histb->pipe_clk);
149	err_pipe_clk:
150	clk_disable_unprepare(histb->utmi_clk);
151	err_utmi_clk:
152	clk_disable_unprepare(histb->bus_clk);
153
154	return ret;
155	}
156
157	static void xhci_histb_host_disable(struct xhci_hcd_histb *histb)
158	{
159	reset_control_assert(histb->soft_reset);
160
161	clk_disable_unprepare(histb->suspend_clk);
162	clk_disable_unprepare(histb->pipe_clk);
163	clk_disable_unprepare(histb->utmi_clk);
164	clk_disable_unprepare(histb->bus_clk);
165	}
166
167	static void xhci_histb_quirks(struct device dev, struct xhci_hcd xhci)
168	{
169	/*
170	* As of now platform drivers don't provide MSI support so we ensure
171	* here that the generic code does not try to make a pci_dev from our
172	* dev struct in order to setup MSI
173	*/
174	xhci->quirks \|= XHCI_PLAT;
175	}
176
177	/* called during probe() after chip reset completes */
178	static int xhci_histb_setup(struct usb_hcd *hcd)
179	{
180	struct xhci_hcd_histb *histb = hcd_to_histb(hcd);
181	int ret;
182
183	if (usb_hcd_is_primary_hcd(hcd)) {
184	ret = xhci_histb_config(histb);
185	if (ret)
186	return ret;
187	}
188
189	return xhci_gen_setup(hcd, xhci_histb_quirks);
190	}
191
192	static const struct xhci_driver_overrides xhci_histb_overrides __initconst = {
193	.reset = xhci_histb_setup,
194	};
195
196	static struct hc_driver __read_mostly xhci_histb_hc_driver;
197	static int xhci_histb_probe(struct platform_device *pdev)
198	{
199	struct device *dev = &pdev->dev;
200	struct xhci_hcd_histb *histb;
201	const struct hc_driver *driver;
202	struct usb_hcd *hcd;
203	struct xhci_hcd *xhci;
204	struct resource *res;
205	int irq;
206	int ret = -ENODEV;
207
208	if (usb_disabled())
209	return -ENODEV;
210
211	driver = &xhci_histb_hc_driver;
212	histb = devm_kzalloc(dev, sizeof(*histb), GFP_KERNEL);
213	if (!histb)
214	return -ENOMEM;
215
216	histb->dev = dev;
217
218	irq = platform_get_irq(pdev, 0);
219	if (irq < 0)
220	return irq;
221
558963c4	222	histb->ctrl = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
c508f41d JS	223	if (IS_ERR(histb->ctrl))
	224	return PTR_ERR(histb->ctrl);
	225
	226	ret = xhci_histb_clks_get(histb);
	227	if (ret)
	228	return ret;
	229
	230	histb->soft_reset = devm_reset_control_get(dev, "soft");
	231	if (IS_ERR(histb->soft_reset)) {
	232	dev_err(dev, "failed to get soft reset\n");
	233	return PTR_ERR(histb->soft_reset);
	234	}
	235
	236	pm_runtime_enable(dev);
	237	pm_runtime_get_sync(dev);
	238	device_enable_async_suspend(dev);
	239
	240	/* Initialize dma_mask and coherent_dma_mask to 32-bits */
	241	ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
	242	if (ret)
	243	return ret;
	244
	245	hcd = usb_create_hcd(driver, dev, dev_name(dev));
	246	if (!hcd) {
	247	ret = -ENOMEM;
	248	goto disable_pm;
	249	}
	250
	251	hcd->regs = histb->ctrl;
	252	hcd->rsrc_start = res->start;
	253	hcd->rsrc_len = resource_size(res);
	254
	255	histb->hcd = hcd;
	256	dev_set_drvdata(hcd->self.controller, histb);
	257
	258	ret = xhci_histb_host_enable(histb);
	259	if (ret)
	260	goto put_hcd;
	261
	262	xhci = hcd_to_xhci(hcd);
	263
	264	device_wakeup_enable(hcd->self.controller);
	265
	266	xhci->main_hcd = hcd;
	267	xhci->shared_hcd = usb_create_shared_hcd(driver, dev, dev_name(dev),
	268	hcd);
	269	if (!xhci->shared_hcd) {
	270	ret = -ENOMEM;
	271	goto disable_host;
	272	}
	273
	274	if (device_property_read_bool(dev, "usb2-lpm-disable"))
	275	xhci->quirks \|= XHCI_HW_LPM_DISABLE;
	276
	277	if (device_property_read_bool(dev, "usb3-lpm-capable"))
	278	xhci->quirks \|= XHCI_LPM_SUPPORT;
	279
	280	/* imod_interval is the interrupt moderation value in nanoseconds. */
	281	xhci->imod_interval = 40000;
	282	device_property_read_u32(dev, "imod-interval-ns",
	283	&xhci->imod_interval);
	284
	285	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
	286	if (ret)
287	goto put_usb3_hcd;
288
289	if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
290	xhci->shared_hcd->can_do_streams = 1;
291
292	ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
293	if (ret)
294	goto dealloc_usb2_hcd;
295
296	device_enable_async_suspend(dev);
297	pm_runtime_put_noidle(dev);
298
299	/*
300	* Prevent runtime pm from being on as default, users should enable
301	* runtime pm using power/control in sysfs.
302	*/
303	pm_runtime_forbid(dev);
304
305	return 0;
306
307	dealloc_usb2_hcd:
308	usb_remove_hcd(hcd);
309	put_usb3_hcd:
310	usb_put_hcd(xhci->shared_hcd);
311	disable_host:
312	xhci_histb_host_disable(histb);
313	put_hcd:
314	usb_put_hcd(hcd);
315	disable_pm:
316	pm_runtime_put_sync(dev);
317	pm_runtime_disable(dev);
318
319	return ret;
320	}
321
322	static int xhci_histb_remove(struct platform_device *dev)
323	{
324	struct xhci_hcd_histb *histb = platform_get_drvdata(dev);
325	struct usb_hcd *hcd = histb->hcd;
326	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
f0680904	327	struct usb_hcd *shared_hcd = xhci->shared_hcd;
c508f41d JS	328
	329	xhci->xhc_state \|= XHCI_STATE_REMOVING;
	330
f0680904 MN	331	usb_remove_hcd(shared_hcd);
f0680904 MN	332	xhci->shared_hcd = NULL;
c508f41d JS	333	device_wakeup_disable(&dev->dev);
	334
	335	usb_remove_hcd(hcd);
f0680904	336	usb_put_hcd(shared_hcd);
c508f41d JS	337
	338	xhci_histb_host_disable(histb);
	339	usb_put_hcd(hcd);
	340	pm_runtime_put_sync(&dev->dev);
	341	pm_runtime_disable(&dev->dev);
	342
	343	return 0;
	344	}
	345
	346	static int __maybe_unused xhci_histb_suspend(struct device *dev)
	347	{
	348	struct xhci_hcd_histb *histb = dev_get_drvdata(dev);
	349	struct usb_hcd *hcd = histb->hcd;
	350	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
	351	int ret;
	352
	353	ret = xhci_suspend(xhci, device_may_wakeup(dev));
	354
	355	if (!device_may_wakeup(dev))
	356	xhci_histb_host_disable(histb);
	357
	358	return ret;
	359	}
	360
	361	static int __maybe_unused xhci_histb_resume(struct device *dev)
	362	{
	363	struct xhci_hcd_histb *histb = dev_get_drvdata(dev);
	364	struct usb_hcd *hcd = histb->hcd;
	365	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
	366
	367	if (!device_may_wakeup(dev))
	368	xhci_histb_host_enable(histb);
	369
	370	return xhci_resume(xhci, 0);
	371	}
	372
	373	static const struct dev_pm_ops xhci_histb_pm_ops = {
	374	SET_SYSTEM_SLEEP_PM_OPS(xhci_histb_suspend, xhci_histb_resume)
	375	};
	376	#define DEV_PM_OPS (IS_ENABLED(CONFIG_PM) ? &xhci_histb_pm_ops : NULL)
	377
	378	#ifdef CONFIG_OF
	379	static const struct of_device_id histb_xhci_of_match[] = {
	380	{ .compatible = "hisilicon,hi3798cv200-xhci"},
	381	{ },
	382	};
	383	MODULE_DEVICE_TABLE(of, histb_xhci_of_match);
	384	#endif
	385
	386	static struct platform_driver histb_xhci_driver = {
	387	.probe = xhci_histb_probe,
	388	.remove = xhci_histb_remove,
	389	.driver = {
	390	.name = "xhci-histb",
	391	.pm = DEV_PM_OPS,
	392	.of_match_table = of_match_ptr(histb_xhci_of_match),
	393	},
	394	};
	395	MODULE_ALIAS("platform:xhci-histb");
	396
	397	static int __init xhci_histb_init(void)
	398	{
	399	xhci_init_driver(&xhci_histb_hc_driver, &xhci_histb_overrides);
	400	return platform_driver_register(&histb_xhci_driver);
401	}
402	module_init(xhci_histb_init);
403
404	static void __exit xhci_histb_exit(void)
405	{
406	platform_driver_unregister(&histb_xhci_driver);
407	}
408	module_exit(xhci_histb_exit);
409
410	MODULE_DESCRIPTION("HiSilicon STB xHCI Host Controller Driver");
411	MODULE_LICENSE("GPL v2");