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