1 /** 2 * dwc3-exynos.c - Samsung EXYNOS DWC3 Specific Glue layer 3 * 4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com 6 * 7 * Author: Anton Tikhomirov <av.tikhomirov@samsung.com> 8 * 9 * This program is free software: you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 of 11 * the License as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/module.h> 20 #include <linux/kernel.h> 21 #include <linux/slab.h> 22 #include <linux/platform_device.h> 23 #include <linux/dma-mapping.h> 24 #include <linux/clk.h> 25 #include <linux/usb/otg.h> 26 #include <linux/usb/usb_phy_generic.h> 27 #include <linux/of.h> 28 #include <linux/of_platform.h> 29 #include <linux/regulator/consumer.h> 30 31 struct dwc3_exynos { 32 struct platform_device *usb2_phy; 33 struct platform_device *usb3_phy; 34 struct device *dev; 35 36 struct clk *clk; 37 struct clk *susp_clk; 38 struct clk *axius_clk; 39 40 struct regulator *vdd33; 41 struct regulator *vdd10; 42 }; 43 44 static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos) 45 { 46 struct usb_phy_generic_platform_data pdata; 47 struct platform_device *pdev; 48 int ret; 49 50 memset(&pdata, 0x00, sizeof(pdata)); 51 52 pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO); 53 if (!pdev) 54 return -ENOMEM; 55 56 exynos->usb2_phy = pdev; 57 pdata.type = USB_PHY_TYPE_USB2; 58 pdata.gpio_reset = -1; 59 60 ret = platform_device_add_data(exynos->usb2_phy, &pdata, sizeof(pdata)); 61 if (ret) 62 goto err1; 63 64 pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO); 65 if (!pdev) { 66 ret = -ENOMEM; 67 goto err1; 68 } 69 70 exynos->usb3_phy = pdev; 71 pdata.type = USB_PHY_TYPE_USB3; 72 73 ret = platform_device_add_data(exynos->usb3_phy, &pdata, sizeof(pdata)); 74 if (ret) 75 goto err2; 76 77 ret = platform_device_add(exynos->usb2_phy); 78 if (ret) 79 goto err2; 80 81 ret = platform_device_add(exynos->usb3_phy); 82 if (ret) 83 goto err3; 84 85 return 0; 86 87 err3: 88 platform_device_del(exynos->usb2_phy); 89 90 err2: 91 platform_device_put(exynos->usb3_phy); 92 93 err1: 94 platform_device_put(exynos->usb2_phy); 95 96 return ret; 97 } 98 99 static int dwc3_exynos_remove_child(struct device *dev, void *unused) 100 { 101 struct platform_device *pdev = to_platform_device(dev); 102 103 platform_device_unregister(pdev); 104 105 return 0; 106 } 107 108 static int dwc3_exynos_probe(struct platform_device *pdev) 109 { 110 struct dwc3_exynos *exynos; 111 struct device *dev = &pdev->dev; 112 struct device_node *node = dev->of_node; 113 114 int ret; 115 116 exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL); 117 if (!exynos) 118 return -ENOMEM; 119 120 /* 121 * Right now device-tree probed devices don't get dma_mask set. 122 * Since shared usb code relies on it, set it here for now. 123 * Once we move to full device tree support this will vanish off. 124 */ 125 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32)); 126 if (ret) 127 return ret; 128 129 platform_set_drvdata(pdev, exynos); 130 131 exynos->dev = dev; 132 133 exynos->clk = devm_clk_get(dev, "usbdrd30"); 134 if (IS_ERR(exynos->clk)) { 135 dev_err(dev, "couldn't get clock\n"); 136 return -EINVAL; 137 } 138 clk_prepare_enable(exynos->clk); 139 140 exynos->susp_clk = devm_clk_get(dev, "usbdrd30_susp_clk"); 141 if (IS_ERR(exynos->susp_clk)) { 142 dev_info(dev, "no suspend clk specified\n"); 143 exynos->susp_clk = NULL; 144 } 145 clk_prepare_enable(exynos->susp_clk); 146 147 if (of_device_is_compatible(node, "samsung,exynos7-dwusb3")) { 148 exynos->axius_clk = devm_clk_get(dev, "usbdrd30_axius_clk"); 149 if (IS_ERR(exynos->axius_clk)) { 150 dev_err(dev, "no AXI UpScaler clk specified\n"); 151 return -ENODEV; 152 } 153 clk_prepare_enable(exynos->axius_clk); 154 } else { 155 exynos->axius_clk = NULL; 156 } 157 158 exynos->vdd33 = devm_regulator_get(dev, "vdd33"); 159 if (IS_ERR(exynos->vdd33)) { 160 ret = PTR_ERR(exynos->vdd33); 161 goto err2; 162 } 163 ret = regulator_enable(exynos->vdd33); 164 if (ret) { 165 dev_err(dev, "Failed to enable VDD33 supply\n"); 166 goto err2; 167 } 168 169 exynos->vdd10 = devm_regulator_get(dev, "vdd10"); 170 if (IS_ERR(exynos->vdd10)) { 171 ret = PTR_ERR(exynos->vdd10); 172 goto err3; 173 } 174 ret = regulator_enable(exynos->vdd10); 175 if (ret) { 176 dev_err(dev, "Failed to enable VDD10 supply\n"); 177 goto err3; 178 } 179 180 ret = dwc3_exynos_register_phys(exynos); 181 if (ret) { 182 dev_err(dev, "couldn't register PHYs\n"); 183 goto err4; 184 } 185 186 if (node) { 187 ret = of_platform_populate(node, NULL, NULL, dev); 188 if (ret) { 189 dev_err(dev, "failed to add dwc3 core\n"); 190 goto err5; 191 } 192 } else { 193 dev_err(dev, "no device node, failed to add dwc3 core\n"); 194 ret = -ENODEV; 195 goto err5; 196 } 197 198 return 0; 199 200 err5: 201 platform_device_unregister(exynos->usb2_phy); 202 platform_device_unregister(exynos->usb3_phy); 203 err4: 204 regulator_disable(exynos->vdd10); 205 err3: 206 regulator_disable(exynos->vdd33); 207 err2: 208 clk_disable_unprepare(exynos->axius_clk); 209 clk_disable_unprepare(exynos->susp_clk); 210 clk_disable_unprepare(exynos->clk); 211 return ret; 212 } 213 214 static int dwc3_exynos_remove(struct platform_device *pdev) 215 { 216 struct dwc3_exynos *exynos = platform_get_drvdata(pdev); 217 218 device_for_each_child(&pdev->dev, NULL, dwc3_exynos_remove_child); 219 platform_device_unregister(exynos->usb2_phy); 220 platform_device_unregister(exynos->usb3_phy); 221 222 clk_disable_unprepare(exynos->axius_clk); 223 clk_disable_unprepare(exynos->susp_clk); 224 clk_disable_unprepare(exynos->clk); 225 226 regulator_disable(exynos->vdd33); 227 regulator_disable(exynos->vdd10); 228 229 return 0; 230 } 231 232 static const struct of_device_id exynos_dwc3_match[] = { 233 { .compatible = "samsung,exynos5250-dwusb3" }, 234 { .compatible = "samsung,exynos7-dwusb3" }, 235 {}, 236 }; 237 MODULE_DEVICE_TABLE(of, exynos_dwc3_match); 238 239 #ifdef CONFIG_PM_SLEEP 240 static int dwc3_exynos_suspend(struct device *dev) 241 { 242 struct dwc3_exynos *exynos = dev_get_drvdata(dev); 243 244 clk_disable(exynos->axius_clk); 245 clk_disable(exynos->clk); 246 247 regulator_disable(exynos->vdd33); 248 regulator_disable(exynos->vdd10); 249 250 return 0; 251 } 252 253 static int dwc3_exynos_resume(struct device *dev) 254 { 255 struct dwc3_exynos *exynos = dev_get_drvdata(dev); 256 int ret; 257 258 ret = regulator_enable(exynos->vdd33); 259 if (ret) { 260 dev_err(dev, "Failed to enable VDD33 supply\n"); 261 return ret; 262 } 263 ret = regulator_enable(exynos->vdd10); 264 if (ret) { 265 dev_err(dev, "Failed to enable VDD10 supply\n"); 266 return ret; 267 } 268 269 clk_enable(exynos->clk); 270 clk_enable(exynos->axius_clk); 271 272 /* runtime set active to reflect active state. */ 273 pm_runtime_disable(dev); 274 pm_runtime_set_active(dev); 275 pm_runtime_enable(dev); 276 277 return 0; 278 } 279 280 static const struct dev_pm_ops dwc3_exynos_dev_pm_ops = { 281 SET_SYSTEM_SLEEP_PM_OPS(dwc3_exynos_suspend, dwc3_exynos_resume) 282 }; 283 284 #define DEV_PM_OPS (&dwc3_exynos_dev_pm_ops) 285 #else 286 #define DEV_PM_OPS NULL 287 #endif /* CONFIG_PM_SLEEP */ 288 289 static struct platform_driver dwc3_exynos_driver = { 290 .probe = dwc3_exynos_probe, 291 .remove = dwc3_exynos_remove, 292 .driver = { 293 .name = "exynos-dwc3", 294 .of_match_table = exynos_dwc3_match, 295 .pm = DEV_PM_OPS, 296 }, 297 }; 298 299 module_platform_driver(dwc3_exynos_driver); 300 301 MODULE_ALIAS("platform:exynos-dwc3"); 302 MODULE_AUTHOR("Anton Tikhomirov <av.tikhomirov@samsung.com>"); 303 MODULE_LICENSE("GPL v2"); 304 MODULE_DESCRIPTION("DesignWare USB3 EXYNOS Glue Layer"); 305