1 /* 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 14 #include <linux/clk.h> 15 #include <linux/dma-mapping.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/platform_device.h> 19 #include <linux/usb/phy.h> 20 #include <linux/slab.h> 21 #include <linux/usb/xhci_pdriver.h> 22 23 #include "xhci.h" 24 #include "xhci-mvebu.h" 25 #include "xhci-rcar.h" 26 27 static struct hc_driver __read_mostly xhci_plat_hc_driver; 28 29 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci) 30 { 31 /* 32 * As of now platform drivers don't provide MSI support so we ensure 33 * here that the generic code does not try to make a pci_dev from our 34 * dev struct in order to setup MSI 35 */ 36 xhci->quirks |= XHCI_PLAT; 37 } 38 39 /* called during probe() after chip reset completes */ 40 static int xhci_plat_setup(struct usb_hcd *hcd) 41 { 42 struct device_node *of_node = hcd->self.controller->of_node; 43 int ret; 44 45 if (of_device_is_compatible(of_node, "renesas,xhci-r8a7790") || 46 of_device_is_compatible(of_node, "renesas,xhci-r8a7791")) { 47 ret = xhci_rcar_init_quirk(hcd); 48 if (ret) 49 return ret; 50 } 51 52 return xhci_gen_setup(hcd, xhci_plat_quirks); 53 } 54 55 static int xhci_plat_start(struct usb_hcd *hcd) 56 { 57 struct device_node *of_node = hcd->self.controller->of_node; 58 59 if (of_device_is_compatible(of_node, "renesas,xhci-r8a7790") || 60 of_device_is_compatible(of_node, "renesas,xhci-r8a7791")) 61 xhci_rcar_start(hcd); 62 63 return xhci_run(hcd); 64 } 65 66 static int xhci_plat_probe(struct platform_device *pdev) 67 { 68 struct device_node *node = pdev->dev.of_node; 69 struct usb_xhci_pdata *pdata = dev_get_platdata(&pdev->dev); 70 const struct hc_driver *driver; 71 struct xhci_hcd *xhci; 72 struct resource *res; 73 struct usb_hcd *hcd; 74 struct clk *clk; 75 int ret; 76 int irq; 77 78 if (usb_disabled()) 79 return -ENODEV; 80 81 driver = &xhci_plat_hc_driver; 82 83 irq = platform_get_irq(pdev, 0); 84 if (irq < 0) 85 return -ENODEV; 86 87 /* Initialize dma_mask and coherent_dma_mask to 32-bits */ 88 ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 89 if (ret) 90 return ret; 91 if (!pdev->dev.dma_mask) 92 pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; 93 else 94 dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); 95 96 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); 97 if (!hcd) 98 return -ENOMEM; 99 100 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 101 hcd->regs = devm_ioremap_resource(&pdev->dev, res); 102 if (IS_ERR(hcd->regs)) { 103 ret = PTR_ERR(hcd->regs); 104 goto put_hcd; 105 } 106 107 hcd->rsrc_start = res->start; 108 hcd->rsrc_len = resource_size(res); 109 110 /* 111 * Not all platforms have a clk so it is not an error if the 112 * clock does not exists. 113 */ 114 clk = devm_clk_get(&pdev->dev, NULL); 115 if (!IS_ERR(clk)) { 116 ret = clk_prepare_enable(clk); 117 if (ret) 118 goto put_hcd; 119 } 120 121 if (of_device_is_compatible(pdev->dev.of_node, 122 "marvell,armada-375-xhci") || 123 of_device_is_compatible(pdev->dev.of_node, 124 "marvell,armada-380-xhci")) { 125 ret = xhci_mvebu_mbus_init_quirk(pdev); 126 if (ret) 127 goto disable_clk; 128 } 129 130 ret = usb_add_hcd(hcd, irq, IRQF_SHARED); 131 if (ret) 132 goto disable_clk; 133 134 device_wakeup_enable(hcd->self.controller); 135 136 /* USB 2.0 roothub is stored in the platform_device now. */ 137 hcd = platform_get_drvdata(pdev); 138 xhci = hcd_to_xhci(hcd); 139 xhci->clk = clk; 140 xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev, 141 dev_name(&pdev->dev), hcd); 142 if (!xhci->shared_hcd) { 143 ret = -ENOMEM; 144 goto dealloc_usb2_hcd; 145 } 146 147 if ((node && of_property_read_bool(node, "usb3-lpm-capable")) || 148 (pdata && pdata->usb3_lpm_capable)) 149 xhci->quirks |= XHCI_LPM_SUPPORT; 150 /* 151 * Set the xHCI pointer before xhci_plat_setup() (aka hcd_driver.reset) 152 * is called by usb_add_hcd(). 153 */ 154 *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci; 155 156 if (HCC_MAX_PSA(xhci->hcc_params) >= 4) 157 xhci->shared_hcd->can_do_streams = 1; 158 159 hcd->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0); 160 if (IS_ERR(hcd->usb_phy)) { 161 ret = PTR_ERR(hcd->usb_phy); 162 if (ret == -EPROBE_DEFER) 163 goto put_usb3_hcd; 164 hcd->usb_phy = NULL; 165 } else { 166 ret = usb_phy_init(hcd->usb_phy); 167 if (ret) 168 goto put_usb3_hcd; 169 } 170 171 ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED); 172 if (ret) 173 goto disable_usb_phy; 174 175 return 0; 176 177 disable_usb_phy: 178 usb_phy_shutdown(hcd->usb_phy); 179 180 put_usb3_hcd: 181 usb_put_hcd(xhci->shared_hcd); 182 183 dealloc_usb2_hcd: 184 usb_remove_hcd(hcd); 185 186 disable_clk: 187 if (!IS_ERR(clk)) 188 clk_disable_unprepare(clk); 189 190 put_hcd: 191 usb_put_hcd(hcd); 192 193 return ret; 194 } 195 196 static int xhci_plat_remove(struct platform_device *dev) 197 { 198 struct usb_hcd *hcd = platform_get_drvdata(dev); 199 struct xhci_hcd *xhci = hcd_to_xhci(hcd); 200 struct clk *clk = xhci->clk; 201 202 usb_remove_hcd(xhci->shared_hcd); 203 usb_phy_shutdown(hcd->usb_phy); 204 usb_put_hcd(xhci->shared_hcd); 205 206 usb_remove_hcd(hcd); 207 if (!IS_ERR(clk)) 208 clk_disable_unprepare(clk); 209 usb_put_hcd(hcd); 210 kfree(xhci); 211 212 return 0; 213 } 214 215 #ifdef CONFIG_PM_SLEEP 216 static int xhci_plat_suspend(struct device *dev) 217 { 218 struct usb_hcd *hcd = dev_get_drvdata(dev); 219 struct xhci_hcd *xhci = hcd_to_xhci(hcd); 220 221 /* 222 * xhci_suspend() needs `do_wakeup` to know whether host is allowed 223 * to do wakeup during suspend. Since xhci_plat_suspend is currently 224 * only designed for system suspend, device_may_wakeup() is enough 225 * to dertermine whether host is allowed to do wakeup. Need to 226 * reconsider this when xhci_plat_suspend enlarges its scope, e.g., 227 * also applies to runtime suspend. 228 */ 229 return xhci_suspend(xhci, device_may_wakeup(dev)); 230 } 231 232 static int xhci_plat_resume(struct device *dev) 233 { 234 struct usb_hcd *hcd = dev_get_drvdata(dev); 235 struct xhci_hcd *xhci = hcd_to_xhci(hcd); 236 237 return xhci_resume(xhci, 0); 238 } 239 240 static const struct dev_pm_ops xhci_plat_pm_ops = { 241 SET_SYSTEM_SLEEP_PM_OPS(xhci_plat_suspend, xhci_plat_resume) 242 }; 243 #define DEV_PM_OPS (&xhci_plat_pm_ops) 244 #else 245 #define DEV_PM_OPS NULL 246 #endif /* CONFIG_PM */ 247 248 #ifdef CONFIG_OF 249 static const struct of_device_id usb_xhci_of_match[] = { 250 { .compatible = "generic-xhci" }, 251 { .compatible = "xhci-platform" }, 252 { .compatible = "marvell,armada-375-xhci"}, 253 { .compatible = "marvell,armada-380-xhci"}, 254 { .compatible = "renesas,xhci-r8a7790"}, 255 { .compatible = "renesas,xhci-r8a7791"}, 256 { }, 257 }; 258 MODULE_DEVICE_TABLE(of, usb_xhci_of_match); 259 #endif 260 261 static struct platform_driver usb_xhci_driver = { 262 .probe = xhci_plat_probe, 263 .remove = xhci_plat_remove, 264 .driver = { 265 .name = "xhci-hcd", 266 .pm = DEV_PM_OPS, 267 .of_match_table = of_match_ptr(usb_xhci_of_match), 268 }, 269 }; 270 MODULE_ALIAS("platform:xhci-hcd"); 271 272 static int __init xhci_plat_init(void) 273 { 274 xhci_init_driver(&xhci_plat_hc_driver, xhci_plat_setup); 275 xhci_plat_hc_driver.start = xhci_plat_start; 276 return platform_driver_register(&usb_xhci_driver); 277 } 278 module_init(xhci_plat_init); 279 280 static void __exit xhci_plat_exit(void) 281 { 282 platform_driver_unregister(&usb_xhci_driver); 283 } 284 module_exit(xhci_plat_exit); 285 286 MODULE_DESCRIPTION("xHCI Platform Host Controller Driver"); 287 MODULE_LICENSE("GPL"); 288