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/clk.h> 24 #include <linux/usb/otg.h> 25 #include <linux/usb/usb_phy_generic.h> 26 #include <linux/of.h> 27 #include <linux/of_platform.h> 28 #include <linux/regulator/consumer.h> 29 30 struct dwc3_exynos { 31 struct platform_device *usb2_phy; 32 struct platform_device *usb3_phy; 33 struct device *dev; 34 35 struct clk *clk; 36 struct clk *susp_clk; 37 struct clk *axius_clk; 38 39 struct regulator *vdd33; 40 struct regulator *vdd10; 41 }; 42 43 static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos) 44 { 45 struct usb_phy_generic_platform_data pdata; 46 struct platform_device *pdev; 47 int ret; 48 49 memset(&pdata, 0x00, sizeof(pdata)); 50 51 pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO); 52 if (!pdev) 53 return -ENOMEM; 54 55 exynos->usb2_phy = pdev; 56 pdata.type = USB_PHY_TYPE_USB2; 57 pdata.gpio_reset = -1; 58 59 ret = platform_device_add_data(exynos->usb2_phy, &pdata, sizeof(pdata)); 60 if (ret) 61 goto err1; 62 63 pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO); 64 if (!pdev) { 65 ret = -ENOMEM; 66 goto err1; 67 } 68 69 exynos->usb3_phy = pdev; 70 pdata.type = USB_PHY_TYPE_USB3; 71 72 ret = platform_device_add_data(exynos->usb3_phy, &pdata, sizeof(pdata)); 73 if (ret) 74 goto err2; 75 76 ret = platform_device_add(exynos->usb2_phy); 77 if (ret) 78 goto err2; 79 80 ret = platform_device_add(exynos->usb3_phy); 81 if (ret) 82 goto err3; 83 84 return 0; 85 86 err3: 87 platform_device_del(exynos->usb2_phy); 88 89 err2: 90 platform_device_put(exynos->usb3_phy); 91 92 err1: 93 platform_device_put(exynos->usb2_phy); 94 95 return ret; 96 } 97 98 static int dwc3_exynos_remove_child(struct device *dev, void *unused) 99 { 100 struct platform_device *pdev = to_platform_device(dev); 101 102 platform_device_unregister(pdev); 103 104 return 0; 105 } 106 107 static int dwc3_exynos_probe(struct platform_device *pdev) 108 { 109 struct dwc3_exynos *exynos; 110 struct device *dev = &pdev->dev; 111 struct device_node *node = dev->of_node; 112 113 int ret; 114 115 exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL); 116 if (!exynos) 117 return -ENOMEM; 118 119 platform_set_drvdata(pdev, exynos); 120 121 exynos->dev = dev; 122 123 exynos->clk = devm_clk_get(dev, "usbdrd30"); 124 if (IS_ERR(exynos->clk)) { 125 dev_err(dev, "couldn't get clock\n"); 126 return -EINVAL; 127 } 128 clk_prepare_enable(exynos->clk); 129 130 exynos->susp_clk = devm_clk_get(dev, "usbdrd30_susp_clk"); 131 if (IS_ERR(exynos->susp_clk)) 132 exynos->susp_clk = NULL; 133 clk_prepare_enable(exynos->susp_clk); 134 135 if (of_device_is_compatible(node, "samsung,exynos7-dwusb3")) { 136 exynos->axius_clk = devm_clk_get(dev, "usbdrd30_axius_clk"); 137 if (IS_ERR(exynos->axius_clk)) { 138 dev_err(dev, "no AXI UpScaler clk specified\n"); 139 ret = -ENODEV; 140 goto axius_clk_err; 141 } 142 clk_prepare_enable(exynos->axius_clk); 143 } else { 144 exynos->axius_clk = NULL; 145 } 146 147 exynos->vdd33 = devm_regulator_get(dev, "vdd33"); 148 if (IS_ERR(exynos->vdd33)) { 149 ret = PTR_ERR(exynos->vdd33); 150 goto vdd33_err; 151 } 152 ret = regulator_enable(exynos->vdd33); 153 if (ret) { 154 dev_err(dev, "Failed to enable VDD33 supply\n"); 155 goto vdd33_err; 156 } 157 158 exynos->vdd10 = devm_regulator_get(dev, "vdd10"); 159 if (IS_ERR(exynos->vdd10)) { 160 ret = PTR_ERR(exynos->vdd10); 161 goto vdd10_err; 162 } 163 ret = regulator_enable(exynos->vdd10); 164 if (ret) { 165 dev_err(dev, "Failed to enable VDD10 supply\n"); 166 goto vdd10_err; 167 } 168 169 ret = dwc3_exynos_register_phys(exynos); 170 if (ret) { 171 dev_err(dev, "couldn't register PHYs\n"); 172 goto phys_err; 173 } 174 175 if (node) { 176 ret = of_platform_populate(node, NULL, NULL, dev); 177 if (ret) { 178 dev_err(dev, "failed to add dwc3 core\n"); 179 goto populate_err; 180 } 181 } else { 182 dev_err(dev, "no device node, failed to add dwc3 core\n"); 183 ret = -ENODEV; 184 goto populate_err; 185 } 186 187 return 0; 188 189 populate_err: 190 platform_device_unregister(exynos->usb2_phy); 191 platform_device_unregister(exynos->usb3_phy); 192 phys_err: 193 regulator_disable(exynos->vdd10); 194 vdd10_err: 195 regulator_disable(exynos->vdd33); 196 vdd33_err: 197 clk_disable_unprepare(exynos->axius_clk); 198 axius_clk_err: 199 clk_disable_unprepare(exynos->susp_clk); 200 clk_disable_unprepare(exynos->clk); 201 return ret; 202 } 203 204 static int dwc3_exynos_remove(struct platform_device *pdev) 205 { 206 struct dwc3_exynos *exynos = platform_get_drvdata(pdev); 207 208 device_for_each_child(&pdev->dev, NULL, dwc3_exynos_remove_child); 209 platform_device_unregister(exynos->usb2_phy); 210 platform_device_unregister(exynos->usb3_phy); 211 212 clk_disable_unprepare(exynos->axius_clk); 213 clk_disable_unprepare(exynos->susp_clk); 214 clk_disable_unprepare(exynos->clk); 215 216 regulator_disable(exynos->vdd33); 217 regulator_disable(exynos->vdd10); 218 219 return 0; 220 } 221 222 static const struct of_device_id exynos_dwc3_match[] = { 223 { .compatible = "samsung,exynos5250-dwusb3" }, 224 { .compatible = "samsung,exynos7-dwusb3" }, 225 {}, 226 }; 227 MODULE_DEVICE_TABLE(of, exynos_dwc3_match); 228 229 #ifdef CONFIG_PM_SLEEP 230 static int dwc3_exynos_suspend(struct device *dev) 231 { 232 struct dwc3_exynos *exynos = dev_get_drvdata(dev); 233 234 clk_disable(exynos->axius_clk); 235 clk_disable(exynos->clk); 236 237 regulator_disable(exynos->vdd33); 238 regulator_disable(exynos->vdd10); 239 240 return 0; 241 } 242 243 static int dwc3_exynos_resume(struct device *dev) 244 { 245 struct dwc3_exynos *exynos = dev_get_drvdata(dev); 246 int ret; 247 248 ret = regulator_enable(exynos->vdd33); 249 if (ret) { 250 dev_err(dev, "Failed to enable VDD33 supply\n"); 251 return ret; 252 } 253 ret = regulator_enable(exynos->vdd10); 254 if (ret) { 255 dev_err(dev, "Failed to enable VDD10 supply\n"); 256 return ret; 257 } 258 259 clk_enable(exynos->clk); 260 clk_enable(exynos->axius_clk); 261 262 /* runtime set active to reflect active state. */ 263 pm_runtime_disable(dev); 264 pm_runtime_set_active(dev); 265 pm_runtime_enable(dev); 266 267 return 0; 268 } 269 270 static const struct dev_pm_ops dwc3_exynos_dev_pm_ops = { 271 SET_SYSTEM_SLEEP_PM_OPS(dwc3_exynos_suspend, dwc3_exynos_resume) 272 }; 273 274 #define DEV_PM_OPS (&dwc3_exynos_dev_pm_ops) 275 #else 276 #define DEV_PM_OPS NULL 277 #endif /* CONFIG_PM_SLEEP */ 278 279 static struct platform_driver dwc3_exynos_driver = { 280 .probe = dwc3_exynos_probe, 281 .remove = dwc3_exynos_remove, 282 .driver = { 283 .name = "exynos-dwc3", 284 .of_match_table = exynos_dwc3_match, 285 .pm = DEV_PM_OPS, 286 }, 287 }; 288 289 module_platform_driver(dwc3_exynos_driver); 290 291 MODULE_AUTHOR("Anton Tikhomirov <av.tikhomirov@samsung.com>"); 292 MODULE_LICENSE("GPL v2"); 293 MODULE_DESCRIPTION("DesignWare USB3 EXYNOS Glue Layer"); 294