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