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 retval = -ENODEV; 104 goto fail_create_hcd; 105 } 106 107 /* Right now device-tree probed devices don't get dma_mask set. 108 * Since shared usb code relies on it, set it here for now. 109 * Once we have dma capability bindings this can go away. 110 */ 111 retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 112 if (retval) 113 goto fail_create_hcd; 114 115 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); 116 if (!hcd) { 117 retval = -ENOMEM; 118 goto fail_create_hcd; 119 } 120 atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 121 122 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 123 hcd->regs = devm_ioremap_resource(&pdev->dev, res); 124 if (IS_ERR(hcd->regs)) { 125 retval = PTR_ERR(hcd->regs); 126 goto fail_request_resource; 127 } 128 129 hcd->rsrc_start = res->start; 130 hcd->rsrc_len = resource_size(res); 131 132 atmel_ehci->iclk = devm_clk_get(&pdev->dev, "ehci_clk"); 133 if (IS_ERR(atmel_ehci->iclk)) { 134 dev_err(&pdev->dev, "Error getting interface clock\n"); 135 retval = -ENOENT; 136 goto fail_request_resource; 137 } 138 139 atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk"); 140 if (IS_ERR(atmel_ehci->uclk)) { 141 dev_err(&pdev->dev, "failed to get uclk\n"); 142 retval = PTR_ERR(atmel_ehci->uclk); 143 goto fail_request_resource; 144 } 145 146 ehci = hcd_to_ehci(hcd); 147 /* registers start at offset 0x0 */ 148 ehci->caps = hcd->regs; 149 150 atmel_start_ehci(pdev); 151 152 retval = usb_add_hcd(hcd, irq, IRQF_SHARED); 153 if (retval) 154 goto fail_add_hcd; 155 device_wakeup_enable(hcd->self.controller); 156 157 return retval; 158 159 fail_add_hcd: 160 atmel_stop_ehci(pdev); 161 fail_request_resource: 162 usb_put_hcd(hcd); 163 fail_create_hcd: 164 dev_err(&pdev->dev, "init %s fail, %d\n", 165 dev_name(&pdev->dev), retval); 166 167 return retval; 168 } 169 170 static int ehci_atmel_drv_remove(struct platform_device *pdev) 171 { 172 struct usb_hcd *hcd = platform_get_drvdata(pdev); 173 174 usb_remove_hcd(hcd); 175 usb_put_hcd(hcd); 176 177 atmel_stop_ehci(pdev); 178 179 return 0; 180 } 181 182 static int __maybe_unused ehci_atmel_drv_suspend(struct device *dev) 183 { 184 struct usb_hcd *hcd = dev_get_drvdata(dev); 185 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 186 int ret; 187 188 ret = ehci_suspend(hcd, false); 189 if (ret) 190 return ret; 191 192 atmel_stop_clock(atmel_ehci); 193 return 0; 194 } 195 196 static int __maybe_unused ehci_atmel_drv_resume(struct device *dev) 197 { 198 struct usb_hcd *hcd = dev_get_drvdata(dev); 199 struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd); 200 201 atmel_start_clock(atmel_ehci); 202 ehci_resume(hcd, false); 203 return 0; 204 } 205 206 #ifdef CONFIG_OF 207 static const struct of_device_id atmel_ehci_dt_ids[] = { 208 { .compatible = "atmel,at91sam9g45-ehci" }, 209 { /* sentinel */ } 210 }; 211 212 MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids); 213 #endif 214 215 static SIMPLE_DEV_PM_OPS(ehci_atmel_pm_ops, ehci_atmel_drv_suspend, 216 ehci_atmel_drv_resume); 217 218 static struct platform_driver ehci_atmel_driver = { 219 .probe = ehci_atmel_drv_probe, 220 .remove = ehci_atmel_drv_remove, 221 .shutdown = usb_hcd_platform_shutdown, 222 .driver = { 223 .name = "atmel-ehci", 224 .pm = &ehci_atmel_pm_ops, 225 .of_match_table = of_match_ptr(atmel_ehci_dt_ids), 226 }, 227 }; 228 229 static int __init ehci_atmel_init(void) 230 { 231 if (usb_disabled()) 232 return -ENODEV; 233 234 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 235 ehci_init_driver(&ehci_atmel_hc_driver, &ehci_atmel_drv_overrides); 236 return platform_driver_register(&ehci_atmel_driver); 237 } 238 module_init(ehci_atmel_init); 239 240 static void __exit ehci_atmel_cleanup(void) 241 { 242 platform_driver_unregister(&ehci_atmel_driver); 243 } 244 module_exit(ehci_atmel_cleanup); 245 246 MODULE_DESCRIPTION(DRIVER_DESC); 247 MODULE_ALIAS("platform:atmel-ehci"); 248 MODULE_AUTHOR("Nicolas Ferre"); 249 MODULE_LICENSE("GPL"); 250