1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for EHCI UHP on Atmel chips 4 * 5 * Copyright (C) 2009 Atmel Corporation, 6 * Nicolas Ferre <nicolas.ferre@atmel.com> 7 * 8 * Based on various ehci-*.c drivers 9 */ 10 11 #include <linux/clk.h> 12 #include <linux/dma-mapping.h> 13 #include <linux/io.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/of_platform.h> 18 #include <linux/platform_device.h> 19 #include <linux/usb.h> 20 #include <linux/usb/hcd.h> 21 22 #include "ehci.h" 23 24 #define DRIVER_DESC "EHCI Atmel driver" 25 26 static const char hcd_name[] = "ehci-atmel"; 27 28 /* interface and function clocks */ 29 #define hcd_to_atmel_ehci_priv(h) \ 30 ((struct atmel_ehci_priv *)hcd_to_ehci(h)->priv) 31 32 struct atmel_ehci_priv { 33 struct clk *iclk; 34 struct clk *uclk; 35 bool clocked; 36 }; 37 38 static struct hc_driver __read_mostly ehci_atmel_hc_driver; 39 40 static const struct ehci_driver_overrides ehci_atmel_drv_overrides __initconst = { 41 .extra_priv_size = sizeof(struct atmel_ehci_priv), 42 }; 43 44 /*-------------------------------------------------------------------------*/ 45 46 static void atmel_start_clock(struct atmel_ehci_priv *atmel_ehci) 47 { 48 if (atmel_ehci->clocked) 49 return; 50 51 clk_prepare_enable(atmel_ehci->uclk); 52 clk_prepare_enable(atmel_ehci->iclk); 53 atmel_ehci->clocked = true; 54 } 55 56 static void atmel_stop_clock(struct atmel_ehci_priv *atmel_ehci) 57 { 58 if (!atmel_ehci->clocked) 59 return; 60 61 clk_disable_unprepare(atmel_ehci->iclk); 62 clk_disable_unprepare(atmel_ehci->uclk); 63 atmel_ehci->clocked = false; 64 } 65 66 static void atmel_start_ehci(struct platform_device *pdev) 67 { 68 struct usb_hcd *hcd = platform_get_drvdata(pdev); 69 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 70 71 dev_dbg(&pdev->dev, "start\n"); 72 atmel_start_clock(atmel_ehci); 73 } 74 75 static void atmel_stop_ehci(struct platform_device *pdev) 76 { 77 struct usb_hcd *hcd = platform_get_drvdata(pdev); 78 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 79 80 dev_dbg(&pdev->dev, "stop\n"); 81 atmel_stop_clock(atmel_ehci); 82 } 83 84 /*-------------------------------------------------------------------------*/ 85 86 static int ehci_atmel_drv_probe(struct platform_device *pdev) 87 { 88 struct usb_hcd *hcd; 89 const struct hc_driver *driver = &ehci_atmel_hc_driver; 90 struct resource *res; 91 struct ehci_hcd *ehci; 92 struct atmel_ehci_priv *atmel_ehci; 93 int irq; 94 int retval; 95 96 if (usb_disabled()) 97 return -ENODEV; 98 99 pr_debug("Initializing Atmel-SoC USB Host Controller\n"); 100 101 irq = platform_get_irq(pdev, 0); 102 if (irq <= 0) { 103 dev_err(&pdev->dev, 104 "Found HC with no IRQ. Check %s setup!\n", 105 dev_name(&pdev->dev)); 106 retval = -ENODEV; 107 goto fail_create_hcd; 108 } 109 110 /* Right now device-tree probed devices don't get dma_mask set. 111 * Since shared usb code relies on it, set it here for now. 112 * Once we have dma capability bindings this can go away. 113 */ 114 retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 115 if (retval) 116 goto fail_create_hcd; 117 118 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); 119 if (!hcd) { 120 retval = -ENOMEM; 121 goto fail_create_hcd; 122 } 123 atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 124 125 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 126 hcd->regs = devm_ioremap_resource(&pdev->dev, res); 127 if (IS_ERR(hcd->regs)) { 128 retval = PTR_ERR(hcd->regs); 129 goto fail_request_resource; 130 } 131 132 hcd->rsrc_start = res->start; 133 hcd->rsrc_len = resource_size(res); 134 135 atmel_ehci->iclk = devm_clk_get(&pdev->dev, "ehci_clk"); 136 if (IS_ERR(atmel_ehci->iclk)) { 137 dev_err(&pdev->dev, "Error getting interface clock\n"); 138 retval = -ENOENT; 139 goto fail_request_resource; 140 } 141 142 atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk"); 143 if (IS_ERR(atmel_ehci->uclk)) { 144 dev_err(&pdev->dev, "failed to get uclk\n"); 145 retval = PTR_ERR(atmel_ehci->uclk); 146 goto fail_request_resource; 147 } 148 149 ehci = hcd_to_ehci(hcd); 150 /* registers start at offset 0x0 */ 151 ehci->caps = hcd->regs; 152 153 atmel_start_ehci(pdev); 154 155 retval = usb_add_hcd(hcd, irq, IRQF_SHARED); 156 if (retval) 157 goto fail_add_hcd; 158 device_wakeup_enable(hcd->self.controller); 159 160 return retval; 161 162 fail_add_hcd: 163 atmel_stop_ehci(pdev); 164 fail_request_resource: 165 usb_put_hcd(hcd); 166 fail_create_hcd: 167 dev_err(&pdev->dev, "init %s fail, %d\n", 168 dev_name(&pdev->dev), retval); 169 170 return retval; 171 } 172 173 static int ehci_atmel_drv_remove(struct platform_device *pdev) 174 { 175 struct usb_hcd *hcd = platform_get_drvdata(pdev); 176 177 usb_remove_hcd(hcd); 178 usb_put_hcd(hcd); 179 180 atmel_stop_ehci(pdev); 181 182 return 0; 183 } 184 185 static int __maybe_unused ehci_atmel_drv_suspend(struct device *dev) 186 { 187 struct usb_hcd *hcd = dev_get_drvdata(dev); 188 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 189 int ret; 190 191 ret = ehci_suspend(hcd, false); 192 if (ret) 193 return ret; 194 195 atmel_stop_clock(atmel_ehci); 196 return 0; 197 } 198 199 static int __maybe_unused ehci_atmel_drv_resume(struct device *dev) 200 { 201 struct usb_hcd *hcd = dev_get_drvdata(dev); 202 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 203 204 atmel_start_clock(atmel_ehci); 205 ehci_resume(hcd, false); 206 return 0; 207 } 208 209 #ifdef CONFIG_OF 210 static const struct of_device_id atmel_ehci_dt_ids[] = { 211 { .compatible = "atmel,at91sam9g45-ehci" }, 212 { /* sentinel */ } 213 }; 214 215 MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids); 216 #endif 217 218 static SIMPLE_DEV_PM_OPS(ehci_atmel_pm_ops, ehci_atmel_drv_suspend, 219 ehci_atmel_drv_resume); 220 221 static struct platform_driver ehci_atmel_driver = { 222 .probe = ehci_atmel_drv_probe, 223 .remove = ehci_atmel_drv_remove, 224 .shutdown = usb_hcd_platform_shutdown, 225 .driver = { 226 .name = "atmel-ehci", 227 .pm = &ehci_atmel_pm_ops, 228 .of_match_table = of_match_ptr(atmel_ehci_dt_ids), 229 }, 230 }; 231 232 static int __init ehci_atmel_init(void) 233 { 234 if (usb_disabled()) 235 return -ENODEV; 236 237 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 238 ehci_init_driver(&ehci_atmel_hc_driver, &ehci_atmel_drv_overrides); 239 return platform_driver_register(&ehci_atmel_driver); 240 } 241 module_init(ehci_atmel_init); 242 243 static void __exit ehci_atmel_cleanup(void) 244 { 245 platform_driver_unregister(&ehci_atmel_driver); 246 } 247 module_exit(ehci_atmel_cleanup); 248 249 MODULE_DESCRIPTION(DRIVER_DESC); 250 MODULE_ALIAS("platform:atmel-ehci"); 251 MODULE_AUTHOR("Nicolas Ferre"); 252 MODULE_LICENSE("GPL"); 253