1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Samsung SoC USB 1.1/2.0 PHY driver 4 * 5 * Copyright (C) 2013 Samsung Electronics Co., Ltd. 6 * Author: Kamil Debski <k.debski@samsung.com> 7 */ 8 9 #include <linux/clk.h> 10 #include <linux/mfd/syscon.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/of_address.h> 14 #include <linux/of_device.h> 15 #include <linux/phy/phy.h> 16 #include <linux/platform_device.h> 17 #include <linux/spinlock.h> 18 #include "phy-samsung-usb2.h" 19 20 static int samsung_usb2_phy_power_on(struct phy *phy) 21 { 22 struct samsung_usb2_phy_instance *inst = phy_get_drvdata(phy); 23 struct samsung_usb2_phy_driver *drv = inst->drv; 24 int ret; 25 26 dev_dbg(drv->dev, "Request to power_on \"%s\" usb phy\n", 27 inst->cfg->label); 28 29 if (drv->vbus) { 30 ret = regulator_enable(drv->vbus); 31 if (ret) 32 goto err_regulator; 33 } 34 35 ret = clk_prepare_enable(drv->clk); 36 if (ret) 37 goto err_main_clk; 38 ret = clk_prepare_enable(drv->ref_clk); 39 if (ret) 40 goto err_instance_clk; 41 if (inst->cfg->power_on) { 42 spin_lock(&drv->lock); 43 ret = inst->cfg->power_on(inst); 44 spin_unlock(&drv->lock); 45 if (ret) 46 goto err_power_on; 47 } 48 49 return 0; 50 51 err_power_on: 52 clk_disable_unprepare(drv->ref_clk); 53 err_instance_clk: 54 clk_disable_unprepare(drv->clk); 55 err_main_clk: 56 if (drv->vbus) 57 regulator_disable(drv->vbus); 58 err_regulator: 59 return ret; 60 } 61 62 static int samsung_usb2_phy_power_off(struct phy *phy) 63 { 64 struct samsung_usb2_phy_instance *inst = phy_get_drvdata(phy); 65 struct samsung_usb2_phy_driver *drv = inst->drv; 66 int ret = 0; 67 68 dev_dbg(drv->dev, "Request to power_off \"%s\" usb phy\n", 69 inst->cfg->label); 70 if (inst->cfg->power_off) { 71 spin_lock(&drv->lock); 72 ret = inst->cfg->power_off(inst); 73 spin_unlock(&drv->lock); 74 if (ret) 75 return ret; 76 } 77 clk_disable_unprepare(drv->ref_clk); 78 clk_disable_unprepare(drv->clk); 79 if (drv->vbus) 80 ret = regulator_disable(drv->vbus); 81 82 return ret; 83 } 84 85 static const struct phy_ops samsung_usb2_phy_ops = { 86 .power_on = samsung_usb2_phy_power_on, 87 .power_off = samsung_usb2_phy_power_off, 88 .owner = THIS_MODULE, 89 }; 90 91 static struct phy *samsung_usb2_phy_xlate(struct device *dev, 92 struct of_phandle_args *args) 93 { 94 struct samsung_usb2_phy_driver *drv; 95 96 drv = dev_get_drvdata(dev); 97 if (!drv) 98 return ERR_PTR(-EINVAL); 99 100 if (WARN_ON(args->args[0] >= drv->cfg->num_phys)) 101 return ERR_PTR(-ENODEV); 102 103 return drv->instances[args->args[0]].phy; 104 } 105 106 static const struct of_device_id samsung_usb2_phy_of_match[] = { 107 #ifdef CONFIG_PHY_EXYNOS4X12_USB2 108 { 109 .compatible = "samsung,exynos3250-usb2-phy", 110 .data = &exynos3250_usb2_phy_config, 111 }, 112 #endif 113 #ifdef CONFIG_PHY_EXYNOS4210_USB2 114 { 115 .compatible = "samsung,exynos4210-usb2-phy", 116 .data = &exynos4210_usb2_phy_config, 117 }, 118 #endif 119 #ifdef CONFIG_PHY_EXYNOS4X12_USB2 120 { 121 .compatible = "samsung,exynos4x12-usb2-phy", 122 .data = &exynos4x12_usb2_phy_config, 123 }, 124 #endif 125 #ifdef CONFIG_PHY_EXYNOS5250_USB2 126 { 127 .compatible = "samsung,exynos5250-usb2-phy", 128 .data = &exynos5250_usb2_phy_config, 129 }, 130 { 131 .compatible = "samsung,exynos5420-usb2-phy", 132 .data = &exynos5420_usb2_phy_config, 133 }, 134 #endif 135 #ifdef CONFIG_PHY_S5PV210_USB2 136 { 137 .compatible = "samsung,s5pv210-usb2-phy", 138 .data = &s5pv210_usb2_phy_config, 139 }, 140 #endif 141 { }, 142 }; 143 MODULE_DEVICE_TABLE(of, samsung_usb2_phy_of_match); 144 145 static int samsung_usb2_phy_probe(struct platform_device *pdev) 146 { 147 const struct samsung_usb2_phy_config *cfg; 148 struct device *dev = &pdev->dev; 149 struct phy_provider *phy_provider; 150 struct samsung_usb2_phy_driver *drv; 151 int i, ret; 152 153 if (!pdev->dev.of_node) { 154 dev_err(dev, "This driver is required to be instantiated from device tree\n"); 155 return -EINVAL; 156 } 157 158 cfg = of_device_get_match_data(dev); 159 if (!cfg) 160 return -EINVAL; 161 162 drv = devm_kzalloc(dev, struct_size(drv, instances, cfg->num_phys), 163 GFP_KERNEL); 164 if (!drv) 165 return -ENOMEM; 166 167 dev_set_drvdata(dev, drv); 168 spin_lock_init(&drv->lock); 169 170 drv->cfg = cfg; 171 drv->dev = dev; 172 173 drv->reg_phy = devm_platform_ioremap_resource(pdev, 0); 174 if (IS_ERR(drv->reg_phy)) { 175 dev_err(dev, "Failed to map register memory (phy)\n"); 176 return PTR_ERR(drv->reg_phy); 177 } 178 179 drv->reg_pmu = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, 180 "samsung,pmureg-phandle"); 181 if (IS_ERR(drv->reg_pmu)) { 182 dev_err(dev, "Failed to map PMU registers (via syscon)\n"); 183 return PTR_ERR(drv->reg_pmu); 184 } 185 186 if (drv->cfg->has_mode_switch) { 187 drv->reg_sys = syscon_regmap_lookup_by_phandle( 188 pdev->dev.of_node, "samsung,sysreg-phandle"); 189 if (IS_ERR(drv->reg_sys)) { 190 dev_err(dev, "Failed to map system registers (via syscon)\n"); 191 return PTR_ERR(drv->reg_sys); 192 } 193 } 194 195 drv->clk = devm_clk_get(dev, "phy"); 196 if (IS_ERR(drv->clk)) { 197 dev_err(dev, "Failed to get clock of phy controller\n"); 198 return PTR_ERR(drv->clk); 199 } 200 201 drv->ref_clk = devm_clk_get(dev, "ref"); 202 if (IS_ERR(drv->ref_clk)) { 203 dev_err(dev, "Failed to get reference clock for the phy controller\n"); 204 return PTR_ERR(drv->ref_clk); 205 } 206 207 drv->ref_rate = clk_get_rate(drv->ref_clk); 208 if (drv->cfg->rate_to_clk) { 209 ret = drv->cfg->rate_to_clk(drv->ref_rate, &drv->ref_reg_val); 210 if (ret) 211 return ret; 212 } 213 214 drv->vbus = devm_regulator_get(dev, "vbus"); 215 if (IS_ERR(drv->vbus)) { 216 ret = PTR_ERR(drv->vbus); 217 if (ret == -EPROBE_DEFER) 218 return ret; 219 drv->vbus = NULL; 220 } 221 222 for (i = 0; i < drv->cfg->num_phys; i++) { 223 char *label = drv->cfg->phys[i].label; 224 struct samsung_usb2_phy_instance *p = &drv->instances[i]; 225 226 dev_dbg(dev, "Creating phy \"%s\"\n", label); 227 p->phy = devm_phy_create(dev, NULL, &samsung_usb2_phy_ops); 228 if (IS_ERR(p->phy)) { 229 dev_err(drv->dev, "Failed to create usb2_phy \"%s\"\n", 230 label); 231 return PTR_ERR(p->phy); 232 } 233 234 p->cfg = &drv->cfg->phys[i]; 235 p->drv = drv; 236 phy_set_bus_width(p->phy, 8); 237 phy_set_drvdata(p->phy, p); 238 } 239 240 phy_provider = devm_of_phy_provider_register(dev, 241 samsung_usb2_phy_xlate); 242 if (IS_ERR(phy_provider)) { 243 dev_err(drv->dev, "Failed to register phy provider\n"); 244 return PTR_ERR(phy_provider); 245 } 246 247 return 0; 248 } 249 250 static struct platform_driver samsung_usb2_phy_driver = { 251 .probe = samsung_usb2_phy_probe, 252 .driver = { 253 .of_match_table = samsung_usb2_phy_of_match, 254 .name = "samsung-usb2-phy", 255 .suppress_bind_attrs = true, 256 } 257 }; 258 259 module_platform_driver(samsung_usb2_phy_driver); 260 MODULE_DESCRIPTION("Samsung S5P/Exynos SoC USB PHY driver"); 261 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>"); 262 MODULE_LICENSE("GPL v2"); 263 MODULE_ALIAS("platform:samsung-usb2-phy"); 264