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