1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/
4 * Written by Jean-Jacques Hiblot <jjhiblot@ti.com>
5 */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <dm/device_compat.h>
10 #include <dm/devres.h>
11 #include <generic-phy.h>
12
phy_dev_ops(struct udevice * dev)13 static inline struct phy_ops *phy_dev_ops(struct udevice *dev)
14 {
15 return (struct phy_ops *)dev->driver->ops;
16 }
17
generic_phy_xlate_offs_flags(struct phy * phy,struct ofnode_phandle_args * args)18 static int generic_phy_xlate_offs_flags(struct phy *phy,
19 struct ofnode_phandle_args *args)
20 {
21 debug("%s(phy=%p)\n", __func__, phy);
22
23 if (args->args_count > 1) {
24 debug("Invaild args_count: %d\n", args->args_count);
25 return -EINVAL;
26 }
27
28 if (args->args_count)
29 phy->id = args->args[0];
30 else
31 phy->id = 0;
32
33 return 0;
34 }
35
generic_phy_get_by_index_nodev(ofnode node,int index,struct phy * phy)36 int generic_phy_get_by_index_nodev(ofnode node, int index, struct phy *phy)
37 {
38 struct ofnode_phandle_args args;
39 struct phy_ops *ops;
40 struct udevice *phydev;
41 int i, ret;
42
43 debug("%s(node=%s, index=%d, phy=%p)\n",
44 __func__, ofnode_get_name(node), index, phy);
45
46 assert(phy);
47 phy->dev = NULL;
48 ret = ofnode_parse_phandle_with_args(node, "phys", "#phy-cells", 0,
49 index, &args);
50 if (ret) {
51 debug("%s: dev_read_phandle_with_args failed: err=%d\n",
52 __func__, ret);
53 return ret;
54 }
55
56 ret = uclass_get_device_by_ofnode(UCLASS_PHY, args.node, &phydev);
57 if (ret) {
58 debug("%s: uclass_get_device_by_ofnode failed: err=%d\n",
59 __func__, ret);
60
61 /* Check if args.node's parent is a PHY provider */
62 ret = uclass_get_device_by_ofnode(UCLASS_PHY,
63 ofnode_get_parent(args.node),
64 &phydev);
65 if (ret)
66 return ret;
67
68 /* insert phy idx at first position into args array */
69 for (i = args.args_count; i >= 1 ; i--)
70 args.args[i] = args.args[i - 1];
71
72 args.args_count++;
73 args.args[0] = ofnode_read_u32_default(args.node, "reg", -1);
74 }
75
76 phy->dev = phydev;
77
78 ops = phy_dev_ops(phydev);
79
80 if (ops->of_xlate)
81 ret = ops->of_xlate(phy, &args);
82 else
83 ret = generic_phy_xlate_offs_flags(phy, &args);
84 if (ret) {
85 debug("of_xlate() failed: %d\n", ret);
86 goto err;
87 }
88
89 return 0;
90
91 err:
92 return ret;
93 }
94
generic_phy_get_by_index(struct udevice * dev,int index,struct phy * phy)95 int generic_phy_get_by_index(struct udevice *dev, int index,
96 struct phy *phy)
97 {
98 return generic_phy_get_by_index_nodev(dev_ofnode(dev), index, phy);
99 }
100
generic_phy_get_by_name(struct udevice * dev,const char * phy_name,struct phy * phy)101 int generic_phy_get_by_name(struct udevice *dev, const char *phy_name,
102 struct phy *phy)
103 {
104 int index;
105
106 debug("%s(dev=%p, name=%s, phy=%p)\n", __func__, dev, phy_name, phy);
107
108 index = dev_read_stringlist_search(dev, "phy-names", phy_name);
109 if (index < 0) {
110 debug("dev_read_stringlist_search() failed: %d\n", index);
111 return index;
112 }
113
114 return generic_phy_get_by_index(dev, index, phy);
115 }
116
generic_phy_init(struct phy * phy)117 int generic_phy_init(struct phy *phy)
118 {
119 struct phy_ops const *ops;
120 int ret;
121
122 if (!generic_phy_valid(phy))
123 return 0;
124 ops = phy_dev_ops(phy->dev);
125 if (!ops->init)
126 return 0;
127 ret = ops->init(phy);
128 if (ret)
129 dev_err(phy->dev, "PHY: Failed to init %s: %d.\n",
130 phy->dev->name, ret);
131
132 return ret;
133 }
134
generic_phy_reset(struct phy * phy)135 int generic_phy_reset(struct phy *phy)
136 {
137 struct phy_ops const *ops;
138 int ret;
139
140 if (!generic_phy_valid(phy))
141 return 0;
142 ops = phy_dev_ops(phy->dev);
143 if (!ops->reset)
144 return 0;
145 ret = ops->reset(phy);
146 if (ret)
147 dev_err(phy->dev, "PHY: Failed to reset %s: %d.\n",
148 phy->dev->name, ret);
149
150 return ret;
151 }
152
generic_phy_exit(struct phy * phy)153 int generic_phy_exit(struct phy *phy)
154 {
155 struct phy_ops const *ops;
156 int ret;
157
158 if (!generic_phy_valid(phy))
159 return 0;
160 ops = phy_dev_ops(phy->dev);
161 if (!ops->exit)
162 return 0;
163 ret = ops->exit(phy);
164 if (ret)
165 dev_err(phy->dev, "PHY: Failed to exit %s: %d.\n",
166 phy->dev->name, ret);
167
168 return ret;
169 }
170
generic_phy_power_on(struct phy * phy)171 int generic_phy_power_on(struct phy *phy)
172 {
173 struct phy_ops const *ops;
174 int ret;
175
176 if (!generic_phy_valid(phy))
177 return 0;
178 ops = phy_dev_ops(phy->dev);
179 if (!ops->power_on)
180 return 0;
181 ret = ops->power_on(phy);
182 if (ret)
183 dev_err(phy->dev, "PHY: Failed to power on %s: %d.\n",
184 phy->dev->name, ret);
185
186 return ret;
187 }
188
generic_phy_power_off(struct phy * phy)189 int generic_phy_power_off(struct phy *phy)
190 {
191 struct phy_ops const *ops;
192 int ret;
193
194 if (!generic_phy_valid(phy))
195 return 0;
196 ops = phy_dev_ops(phy->dev);
197 if (!ops->power_off)
198 return 0;
199 ret = ops->power_off(phy);
200 if (ret)
201 dev_err(phy->dev, "PHY: Failed to power off %s: %d.\n",
202 phy->dev->name, ret);
203
204 return ret;
205 }
206
generic_phy_configure(struct phy * phy,void * params)207 int generic_phy_configure(struct phy *phy, void *params)
208 {
209 struct phy_ops const *ops;
210
211 if (!generic_phy_valid(phy))
212 return 0;
213 ops = phy_dev_ops(phy->dev);
214
215 return ops->configure ? ops->configure(phy, params) : 0;
216 }
217
generic_phy_get_bulk(struct udevice * dev,struct phy_bulk * bulk)218 int generic_phy_get_bulk(struct udevice *dev, struct phy_bulk *bulk)
219 {
220 int i, ret, count;
221
222 bulk->count = 0;
223
224 /* Return if no phy declared */
225 if (!dev_read_prop(dev, "phys", NULL))
226 return 0;
227
228 count = dev_count_phandle_with_args(dev, "phys", "#phy-cells", 0);
229 if (count < 1)
230 return count;
231
232 bulk->phys = devm_kcalloc(dev, count, sizeof(struct phy), GFP_KERNEL);
233 if (!bulk->phys)
234 return -ENOMEM;
235
236 for (i = 0; i < count; i++) {
237 ret = generic_phy_get_by_index(dev, i, &bulk->phys[i]);
238 if (ret) {
239 pr_err("Failed to get PHY%d for %s\n", i, dev->name);
240 return ret;
241 }
242 bulk->count++;
243 }
244
245 return 0;
246 }
247
generic_phy_init_bulk(struct phy_bulk * bulk)248 int generic_phy_init_bulk(struct phy_bulk *bulk)
249 {
250 struct phy *phys = bulk->phys;
251 int i, ret;
252
253 for (i = 0; i < bulk->count; i++) {
254 ret = generic_phy_init(&phys[i]);
255 if (ret) {
256 pr_err("Can't init PHY%d\n", i);
257 goto phys_init_err;
258 }
259 }
260
261 return 0;
262
263 phys_init_err:
264 for (; i > 0; i--)
265 generic_phy_exit(&phys[i - 1]);
266
267 return ret;
268 }
269
generic_phy_exit_bulk(struct phy_bulk * bulk)270 int generic_phy_exit_bulk(struct phy_bulk *bulk)
271 {
272 struct phy *phys = bulk->phys;
273 int i, ret = 0;
274
275 for (i = 0; i < bulk->count; i++)
276 ret |= generic_phy_exit(&phys[i]);
277
278 return ret;
279 }
280
generic_phy_power_on_bulk(struct phy_bulk * bulk)281 int generic_phy_power_on_bulk(struct phy_bulk *bulk)
282 {
283 struct phy *phys = bulk->phys;
284 int i, ret;
285
286 for (i = 0; i < bulk->count; i++) {
287 ret = generic_phy_power_on(&phys[i]);
288 if (ret) {
289 pr_err("Can't power on PHY%d\n", i);
290 goto phys_poweron_err;
291 }
292 }
293
294 return 0;
295
296 phys_poweron_err:
297 for (; i > 0; i--)
298 generic_phy_power_off(&phys[i - 1]);
299
300 return ret;
301 }
302
generic_phy_power_off_bulk(struct phy_bulk * bulk)303 int generic_phy_power_off_bulk(struct phy_bulk *bulk)
304 {
305 struct phy *phys = bulk->phys;
306 int i, ret = 0;
307
308 for (i = 0; i < bulk->count; i++)
309 ret |= generic_phy_power_off(&phys[i]);
310
311 return ret;
312 }
313
314 UCLASS_DRIVER(phy) = {
315 .id = UCLASS_PHY,
316 .name = "phy",
317 };
318