blob: 588546a9e4a4035ffc78559b9a026bb10a9f14cd [file] [log] [blame]
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +02001/*
2 * xhci-plat.c - xHCI host controller driver platform Bus Glue.
3 *
4 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
5 * Author: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
6 *
7 * A lot of code borrowed from the Linux xHCI driver.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 as published by the Free Software Foundation.
12 */
13
Gregory CLEMENT4718c172014-05-15 12:17:32 +020014#include <linux/clk.h>
Xenia Ragiadakouc10cf112013-08-14 05:55:19 +030015#include <linux/dma-mapping.h>
Gregory CLEMENT48157bb2014-05-15 12:17:31 +020016#include <linux/module.h>
Arnd Bergmanna9ff9112017-03-13 10:18:44 +080017#include <linux/pci.h>
Gregory CLEMENT48157bb2014-05-15 12:17:31 +020018#include <linux/of.h>
19#include <linux/platform_device.h>
Maxime Ripard7b8ef222015-03-17 18:32:22 +020020#include <linux/usb/phy.h>
Gregory CLEMENT48157bb2014-05-15 12:17:31 +020021#include <linux/slab.h>
Duc Dang579085b2015-10-09 13:30:12 +030022#include <linux/acpi.h>
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +020023
24#include "xhci.h"
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +020025#include "xhci-plat.h"
Gregory CLEMENT97374792014-05-15 12:17:33 +020026#include "xhci-mvebu.h"
Yoshihiro Shimoda4ac89182014-07-09 10:08:52 +090027#include "xhci-rcar.h"
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +020028
Andrew Bresticker1885d9a2014-10-03 11:35:26 +030029static struct hc_driver __read_mostly xhci_plat_hc_driver;
30
Roger Quadroscd33a322015-05-29 17:01:46 +030031static int xhci_plat_setup(struct usb_hcd *hcd);
32static int xhci_plat_start(struct usb_hcd *hcd);
33
34static const struct xhci_driver_overrides xhci_plat_overrides __initconst = {
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +020035 .extra_priv_size = sizeof(struct xhci_plat_priv),
Roger Quadroscd33a322015-05-29 17:01:46 +030036 .reset = xhci_plat_setup,
37 .start = xhci_plat_start,
38};
39
Felipe Balbib1c127ae2016-04-22 13:17:16 +030040static void xhci_priv_plat_start(struct usb_hcd *hcd)
41{
42 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
43
44 if (priv->plat_start)
45 priv->plat_start(hcd);
46}
47
48static int xhci_priv_init_quirk(struct usb_hcd *hcd)
49{
50 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
51
52 if (!priv->init_quirk)
53 return 0;
54
55 return priv->init_quirk(hcd);
56}
57
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +020058static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
59{
60 /*
61 * As of now platform drivers don't provide MSI support so we ensure
62 * here that the generic code does not try to make a pci_dev from our
63 * dev struct in order to setup MSI
64 */
Sarah Sharp52fb6122013-08-08 10:08:34 -070065 xhci->quirks |= XHCI_PLAT;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +020066}
67
68/* called during probe() after chip reset completes */
69static int xhci_plat_setup(struct usb_hcd *hcd)
70{
Yoshihiro Shimoda4ac89182014-07-09 10:08:52 +090071 int ret;
72
Yoshihiro Shimoda4ac89182014-07-09 10:08:52 +090073
Felipe Balbib1c127ae2016-04-22 13:17:16 +030074 ret = xhci_priv_init_quirk(hcd);
75 if (ret)
76 return ret;
Felipe Balbi3bdb2632016-04-22 13:17:14 +030077
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +020078 return xhci_gen_setup(hcd, xhci_plat_quirks);
79}
80
Yoshihiro Shimoda94adcdc2014-05-28 20:22:58 +090081static int xhci_plat_start(struct usb_hcd *hcd)
82{
Felipe Balbib1c127ae2016-04-22 13:17:16 +030083 xhci_priv_plat_start(hcd);
Yoshihiro Shimoda94adcdc2014-05-28 20:22:58 +090084 return xhci_run(hcd);
85}
86
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +020087#ifdef CONFIG_OF
88static const struct xhci_plat_priv xhci_plat_marvell_armada = {
Felipe Balbib1c127ae2016-04-22 13:17:16 +030089 .init_quirk = xhci_mvebu_mbus_init_quirk,
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +020090};
91
92static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen2 = {
Yoshihiro Shimoda9bf9d9d2015-11-24 13:09:51 +020093 .firmware_name = XHCI_RCAR_FIRMWARE_NAME_V1,
Felipe Balbib1c127ae2016-04-22 13:17:16 +030094 .init_quirk = xhci_rcar_init_quirk,
95 .plat_start = xhci_rcar_start,
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +020096};
97
Yoshihiro Shimoda526a2402015-11-24 13:09:53 +020098static const struct xhci_plat_priv xhci_plat_renesas_rcar_gen3 = {
Yoshihiro Shimoda526a2402015-11-24 13:09:53 +020099 .firmware_name = XHCI_RCAR_FIRMWARE_NAME_V2,
Felipe Balbib1c127ae2016-04-22 13:17:16 +0300100 .init_quirk = xhci_rcar_init_quirk,
101 .plat_start = xhci_rcar_start,
Yoshihiro Shimoda526a2402015-11-24 13:09:53 +0200102};
103
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200104static const struct of_device_id usb_xhci_of_match[] = {
105 {
106 .compatible = "generic-xhci",
107 }, {
108 .compatible = "xhci-platform",
109 }, {
110 .compatible = "marvell,armada-375-xhci",
111 .data = &xhci_plat_marvell_armada,
112 }, {
113 .compatible = "marvell,armada-380-xhci",
114 .data = &xhci_plat_marvell_armada,
115 }, {
116 .compatible = "renesas,xhci-r8a7790",
117 .data = &xhci_plat_renesas_rcar_gen2,
118 }, {
119 .compatible = "renesas,xhci-r8a7791",
120 .data = &xhci_plat_renesas_rcar_gen2,
121 }, {
Yoshihiro Shimoda82487b72015-11-24 13:09:52 +0200122 .compatible = "renesas,xhci-r8a7793",
123 .data = &xhci_plat_renesas_rcar_gen2,
124 }, {
Yoshihiro Shimoda526a2402015-11-24 13:09:53 +0200125 .compatible = "renesas,xhci-r8a7795",
126 .data = &xhci_plat_renesas_rcar_gen3,
127 }, {
Simon Hormanf1bbdc32016-02-18 17:55:49 +0200128 .compatible = "renesas,rcar-gen2-xhci",
129 .data = &xhci_plat_renesas_rcar_gen2,
130 }, {
131 .compatible = "renesas,rcar-gen3-xhci",
132 .data = &xhci_plat_renesas_rcar_gen3,
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200133 },
Julia Lawallff075d672016-02-18 17:55:50 +0200134 {},
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200135};
136MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
137#endif
138
Devdutt Patnaikcf1d53c2015-05-04 22:02:36 -0700139static ssize_t config_imod_store(struct device *pdev,
140 struct device_attribute *attr, const char *buff, size_t size)
141{
142 struct usb_hcd *hcd = dev_get_drvdata(pdev);
143 struct xhci_hcd *xhci;
144 u32 temp;
145 u32 imod;
146 unsigned long flags;
147
148 if (kstrtouint(buff, 10, &imod) != 1)
149 return 0;
150
151 imod &= ER_IRQ_INTERVAL_MASK;
152 xhci = hcd_to_xhci(hcd);
153
154 if (xhci->shared_hcd->state == HC_STATE_SUSPENDED
155 && hcd->state == HC_STATE_SUSPENDED)
156 return -EACCES;
157
158 spin_lock_irqsave(&xhci->lock, flags);
159 temp = readl_relaxed(&xhci->ir_set->irq_control);
160 temp &= ~ER_IRQ_INTERVAL_MASK;
161 temp |= imod;
162 writel_relaxed(temp, &xhci->ir_set->irq_control);
163 spin_unlock_irqrestore(&xhci->lock, flags);
164
165 return size;
166}
167
168static ssize_t config_imod_show(struct device *pdev,
169 struct device_attribute *attr, char *buff)
170{
171 struct usb_hcd *hcd = dev_get_drvdata(pdev);
172 struct xhci_hcd *xhci;
173 u32 temp;
174 unsigned long flags;
175
176 xhci = hcd_to_xhci(hcd);
177
178 if (xhci->shared_hcd->state == HC_STATE_SUSPENDED
179 && hcd->state == HC_STATE_SUSPENDED)
180 return -EACCES;
181
182 spin_lock_irqsave(&xhci->lock, flags);
183 temp = readl_relaxed(&xhci->ir_set->irq_control) &
184 ER_IRQ_INTERVAL_MASK;
185 spin_unlock_irqrestore(&xhci->lock, flags);
186
187 return snprintf(buff, PAGE_SIZE, "%08u\n", temp);
188}
189
190static DEVICE_ATTR(config_imod, 0644, config_imod_show, config_imod_store);
191
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200192static int xhci_plat_probe(struct platform_device *pdev)
193{
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200194 const struct of_device_id *match;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200195 const struct hc_driver *driver;
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800196 struct device *sysdev;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200197 struct xhci_hcd *xhci;
198 struct resource *res;
199 struct usb_hcd *hcd;
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200200 struct clk *clk;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200201 int ret;
202 int irq;
Mayank Rana87283452017-03-29 18:33:39 -0700203 u32 temp, imod;
204 unsigned long flags;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200205
206 if (usb_disabled())
207 return -ENODEV;
208
Andrew Bresticker1885d9a2014-10-03 11:35:26 +0300209 driver = &xhci_plat_hc_driver;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200210
211 irq = platform_get_irq(pdev, 0);
212 if (irq < 0)
Thomas Petazzoni1a926912017-05-17 18:32:06 +0300213 return irq;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200214
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800215 /*
216 * sysdev must point to a device that is known to the system firmware
217 * or PCI hardware. We handle these three cases here:
218 * 1. xhci_plat comes from firmware
219 * 2. xhci_plat is child of a device from firmware (dwc3-plat)
220 * 3. xhci_plat is grandchild of a pci device (dwc3-pci)
221 */
222 sysdev = &pdev->dev;
223 if (sysdev->parent && !sysdev->of_node && sysdev->parent->of_node)
224 sysdev = sysdev->parent;
225#ifdef CONFIG_PCI
226 else if (sysdev->parent && sysdev->parent->parent &&
227 sysdev->parent->parent->bus == &pci_bus_type)
228 sysdev = sysdev->parent->parent;
229#endif
230
Duc Dang0ebbe392015-10-09 13:30:11 +0300231 /* Try to set 64-bit DMA first */
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800232 if (WARN_ON(!sysdev->dma_mask))
Duc Dang0ebbe392015-10-09 13:30:11 +0300233 /* Platform did not initialize dma_mask */
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800234 ret = dma_coerce_mask_and_coherent(sysdev,
Duc Dang0ebbe392015-10-09 13:30:11 +0300235 DMA_BIT_MASK(64));
Xenia Ragiadakouc10cf112013-08-14 05:55:19 +0300236 else
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800237 ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64));
Duc Dang0ebbe392015-10-09 13:30:11 +0300238
239 /* If seting 64-bit DMA mask fails, fall back to 32-bit DMA mask */
240 if (ret) {
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800241 ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32));
Duc Dang0ebbe392015-10-09 13:30:11 +0300242 if (ret)
243 return ret;
244 }
Xenia Ragiadakouc10cf112013-08-14 05:55:19 +0300245
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800246 hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
247 dev_name(&pdev->dev), NULL);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200248 if (!hcd)
249 return -ENOMEM;
250
Hemant Kumar0641f222016-11-15 19:10:42 -0800251 hcd_to_bus(hcd)->skip_resume = true;
252
Varka Bhadrame7020f12014-11-04 07:51:27 +0530253 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
Himangi Saraogifd666342014-06-20 23:11:23 +0530254 hcd->regs = devm_ioremap_resource(&pdev->dev, res);
255 if (IS_ERR(hcd->regs)) {
256 ret = PTR_ERR(hcd->regs);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200257 goto put_hcd;
258 }
259
Varka Bhadrame7020f12014-11-04 07:51:27 +0530260 hcd->rsrc_start = res->start;
261 hcd->rsrc_len = resource_size(res);
262
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200263 /*
264 * Not all platforms have a clk so it is not an error if the
265 * clock does not exists.
266 */
267 clk = devm_clk_get(&pdev->dev, NULL);
268 if (!IS_ERR(clk)) {
269 ret = clk_prepare_enable(clk);
270 if (ret)
Himangi Saraogifd666342014-06-20 23:11:23 +0530271 goto put_hcd;
Thomas Petazzonide95c402016-06-01 18:09:09 +0300272 } else if (PTR_ERR(clk) == -EPROBE_DEFER) {
273 ret = -EPROBE_DEFER;
274 goto put_hcd;
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200275 }
276
Mayank Ranaa99689a2016-08-10 17:39:47 -0700277 if (pdev->dev.parent)
278 pm_runtime_resume(pdev->dev.parent);
279
280 pm_runtime_use_autosuspend(&pdev->dev);
281 pm_runtime_set_autosuspend_delay(&pdev->dev, 1000);
282 pm_runtime_set_active(&pdev->dev);
283 pm_runtime_enable(&pdev->dev);
284 pm_runtime_get_sync(&pdev->dev);
285
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200286 xhci = hcd_to_xhci(hcd);
Heikki Krogerus76f95022016-06-21 10:58:08 +0300287 match = of_match_node(usb_xhci_of_match, pdev->dev.of_node);
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200288 if (match) {
289 const struct xhci_plat_priv *priv_match = match->data;
290 struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
291
292 /* Just copy data for now */
Gregory CLEMENT2ad294d2016-01-26 17:50:11 +0200293 if (priv_match)
294 *priv = *priv_match;
Yoshihiro Shimoda4efb2f62015-11-24 13:09:49 +0200295 }
296
Peter Chen3c9740a2013-11-05 10:46:02 +0800297 device_wakeup_enable(hcd->self.controller);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200298
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200299 xhci->clk = clk;
Roger Quadros9fa733f2015-05-29 17:01:50 +0300300 xhci->main_hcd = hcd;
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800301 xhci->shared_hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200302 dev_name(&pdev->dev), hcd);
303 if (!xhci->shared_hcd) {
304 ret = -ENOMEM;
Roger Quadros4ac53082015-05-29 17:01:47 +0300305 goto disable_clk;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200306 }
307
Hemant Kumar0641f222016-11-15 19:10:42 -0800308 hcd_to_bus(xhci->shared_hcd)->skip_resume = true;
309
Mayank Ranad89f1fe2017-09-28 14:04:07 -0700310 if (device_property_read_bool(&pdev->dev, "usb3-lpm-capable"))
Pratyush Anand20f6fdd2014-07-04 17:01:25 +0300311 xhci->quirks |= XHCI_LPM_SUPPORT;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200312
Felipe Balbi7bdf7be2017-04-04 19:32:24 +0000313 if (device_property_read_bool(&pdev->dev, "quirk-broken-port-ped"))
314 xhci->quirks |= XHCI_BROKEN_PORT_PED;
315
Mayank Ranae27420f2017-10-10 15:44:19 -0700316 if (device_property_read_u32(&pdev->dev, "xhci-imod-value", &imod))
Mayank Rana87283452017-03-29 18:33:39 -0700317 imod = 0;
318
Hemant Kumare7113fb2017-08-18 16:40:58 -0700319 if (device_property_read_u32(sysdev, "usb-core-id", &xhci->core_id))
320 xhci->core_id = -EINVAL;
321
Arnd Bergmanna9ff9112017-03-13 10:18:44 +0800322 hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0);
Maxime Ripard7b8ef222015-03-17 18:32:22 +0200323 if (IS_ERR(hcd->usb_phy)) {
324 ret = PTR_ERR(hcd->usb_phy);
325 if (ret == -EPROBE_DEFER)
326 goto put_usb3_hcd;
327 hcd->usb_phy = NULL;
328 } else {
329 ret = usb_phy_init(hcd->usb_phy);
330 if (ret)
331 goto put_usb3_hcd;
332 }
333
Mayank Ranaf616a7f2017-03-20 16:10:39 -0700334 ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200335 if (ret)
Maxime Ripard7b8ef222015-03-17 18:32:22 +0200336 goto disable_usb_phy;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200337
Jack Pham629f6cd2016-10-26 19:36:55 -0700338 device_wakeup_enable(&hcd->self.root_hub->dev);
339
William wu82bd5602017-01-17 15:32:07 +0800340 if (HCC_MAX_PSA(xhci->hcc_params) >= 4)
341 xhci->shared_hcd->can_do_streams = 1;
342
Mayank Ranaf616a7f2017-03-20 16:10:39 -0700343 ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
Roger Quadros4ac53082015-05-29 17:01:47 +0300344 if (ret)
345 goto dealloc_usb2_hcd;
346
Jack Pham629f6cd2016-10-26 19:36:55 -0700347 device_wakeup_enable(&xhci->shared_hcd->self.root_hub->dev);
348
Mayank Rana87283452017-03-29 18:33:39 -0700349 /* override imod interval if specified */
350 if (imod) {
351 imod &= ER_IRQ_INTERVAL_MASK;
352 spin_lock_irqsave(&xhci->lock, flags);
353 temp = readl_relaxed(&xhci->ir_set->irq_control);
354 temp &= ~ER_IRQ_INTERVAL_MASK;
355 temp |= imod;
356 writel_relaxed(temp, &xhci->ir_set->irq_control);
357 spin_unlock_irqrestore(&xhci->lock, flags);
358 dev_dbg(&pdev->dev, "%s: imod set to %u\n", __func__, imod);
359 }
360
Devdutt Patnaikcf1d53c2015-05-04 22:02:36 -0700361 ret = device_create_file(&pdev->dev, &dev_attr_config_imod);
362 if (ret)
363 dev_err(&pdev->dev, "%s: unable to create imod sysfs entry\n",
364 __func__);
365
Mayank Ranaa99689a2016-08-10 17:39:47 -0700366 pm_runtime_mark_last_busy(&pdev->dev);
367 pm_runtime_put_autosuspend(&pdev->dev);
368
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200369 return 0;
370
Roger Quadros4ac53082015-05-29 17:01:47 +0300371
372dealloc_usb2_hcd:
373 usb_remove_hcd(hcd);
374
Maxime Ripard7b8ef222015-03-17 18:32:22 +0200375disable_usb_phy:
376 usb_phy_shutdown(hcd->usb_phy);
377
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200378put_usb3_hcd:
379 usb_put_hcd(xhci->shared_hcd);
380
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200381disable_clk:
382 if (!IS_ERR(clk))
383 clk_disable_unprepare(clk);
384
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200385put_hcd:
386 usb_put_hcd(hcd);
387
388 return ret;
389}
390
391static int xhci_plat_remove(struct platform_device *dev)
392{
393 struct usb_hcd *hcd = platform_get_drvdata(dev);
394 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200395 struct clk *clk = xhci->clk;
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200396
Mayank Ranaa99689a2016-08-10 17:39:47 -0700397 pm_runtime_disable(&dev->dev);
Guenter Roeck24db1c52017-03-09 15:39:37 +0200398 xhci->xhc_state |= XHCI_STATE_REMOVING;
Mayank Ranaa99689a2016-08-10 17:39:47 -0700399
Devdutt Patnaikcf1d53c2015-05-04 22:02:36 -0700400 device_remove_file(&dev->dev, &dev_attr_config_imod);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200401 usb_remove_hcd(xhci->shared_hcd);
Maxime Ripard7b8ef222015-03-17 18:32:22 +0200402 usb_phy_shutdown(hcd->usb_phy);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200403
404 usb_remove_hcd(hcd);
Roger Quadros4ac53082015-05-29 17:01:47 +0300405 usb_put_hcd(xhci->shared_hcd);
406
Gregory CLEMENT4718c172014-05-15 12:17:32 +0200407 if (!IS_ERR(clk))
408 clk_disable_unprepare(clk);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200409 usb_put_hcd(hcd);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200410
411 return 0;
412}
413
Mayank Ranaa99689a2016-08-10 17:39:47 -0700414#ifdef CONFIG_PM
415static int xhci_plat_runtime_idle(struct device *dev)
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200416{
Lu Baolua1377e52014-11-18 11:27:14 +0200417 /*
Mayank Ranaa99689a2016-08-10 17:39:47 -0700418 * When pm_runtime_put_autosuspend() is called on this device,
419 * after this idle callback returns the PM core will schedule the
420 * autosuspend if there is any remaining time until expiry. However,
421 * when reaching this point because the child_count becomes 0, the
422 * core does not honor autosuspend in that case and results in
423 * idle/suspend happening immediately. In order to have a delay
424 * before suspend we have to call pm_runtime_autosuspend() manually.
Lu Baolua1377e52014-11-18 11:27:14 +0200425 */
Mayank Ranaa99689a2016-08-10 17:39:47 -0700426 pm_runtime_mark_last_busy(dev);
427 pm_runtime_autosuspend(dev);
428 return -EBUSY;
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200429}
430
Mayank Ranaa99689a2016-08-10 17:39:47 -0700431static int xhci_plat_runtime_suspend(struct device *dev)
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200432{
Mayank Ranaa99689a2016-08-10 17:39:47 -0700433 struct usb_hcd *hcd = dev_get_drvdata(dev);
434 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200435
Mayank Ranaa99689a2016-08-10 17:39:47 -0700436 if (!xhci)
437 return 0;
438
439 dev_dbg(dev, "xhci-plat runtime suspend\n");
440
Jack Pham3b4ebc12017-04-17 12:09:58 -0700441 return xhci_suspend(xhci, true);
Mayank Ranaa99689a2016-08-10 17:39:47 -0700442}
443
444static int xhci_plat_runtime_resume(struct device *dev)
445{
446 struct usb_hcd *hcd = dev_get_drvdata(dev);
447 struct xhci_hcd *xhci = hcd_to_xhci(hcd);
448 int ret;
449
450 if (!xhci)
451 return 0;
452
453 dev_dbg(dev, "xhci-plat runtime resume\n");
454
Jack Pham3b4ebc12017-04-17 12:09:58 -0700455 ret = xhci_resume(xhci, false);
Mayank Ranaa99689a2016-08-10 17:39:47 -0700456 pm_runtime_mark_last_busy(dev);
457
458 return ret;
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200459}
460
461static const struct dev_pm_ops xhci_plat_pm_ops = {
Mayank Ranaa99689a2016-08-10 17:39:47 -0700462 SET_SYSTEM_SLEEP_PM_OPS(NULL, NULL)
463 SET_RUNTIME_PM_OPS(xhci_plat_runtime_suspend, xhci_plat_runtime_resume,
464 xhci_plat_runtime_idle)
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200465};
466#define DEV_PM_OPS (&xhci_plat_pm_ops)
467#else
468#define DEV_PM_OPS NULL
469#endif /* CONFIG_PM */
470
Duc Dang579085b2015-10-09 13:30:12 +0300471static const struct acpi_device_id usb_xhci_acpi_match[] = {
472 /* XHCI-compliant USB Controller */
473 { "PNP0D10", },
474 { }
475};
476MODULE_DEVICE_TABLE(acpi, usb_xhci_acpi_match);
477
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200478static struct platform_driver usb_xhci_driver = {
479 .probe = xhci_plat_probe,
480 .remove = xhci_plat_remove,
481 .driver = {
482 .name = "xhci-hcd",
Vikas Sajjan57d04eb2013-02-11 12:58:00 +0200483 .pm = DEV_PM_OPS,
Al Cooper1fe6c452013-07-25 19:04:44 -0400484 .of_match_table = of_match_ptr(usb_xhci_of_match),
Duc Dang579085b2015-10-09 13:30:12 +0300485 .acpi_match_table = ACPI_PTR(usb_xhci_acpi_match),
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200486 },
487};
488MODULE_ALIAS("platform:xhci-hcd");
489
Andrew Bresticker29e409f2014-10-03 11:35:29 +0300490static int __init xhci_plat_init(void)
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200491{
Roger Quadroscd33a322015-05-29 17:01:46 +0300492 xhci_init_driver(&xhci_plat_hc_driver, &xhci_plat_overrides);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200493 return platform_driver_register(&usb_xhci_driver);
494}
Andrew Bresticker29e409f2014-10-03 11:35:29 +0300495module_init(xhci_plat_init);
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200496
Andrew Bresticker29e409f2014-10-03 11:35:29 +0300497static void __exit xhci_plat_exit(void)
Sebastian Andrzej Siewior3429e912012-03-13 16:57:41 +0200498{
499 platform_driver_unregister(&usb_xhci_driver);
500}
Andrew Bresticker29e409f2014-10-03 11:35:29 +0300501module_exit(xhci_plat_exit);
502
503MODULE_DESCRIPTION("xHCI Platform Host Controller Driver");
504MODULE_LICENSE("GPL");