This source file includes following definitions.
- of_get_phy_id
- of_mdiobus_register_phy
- of_mdiobus_register_device
- of_mdiobus_child_is_phy
- of_mdiobus_register
- of_phy_find_device
- of_phy_connect
- of_phy_get_and_connect
- of_phy_attach
- of_phy_is_fixed_link
- of_phy_register_fixed_link
- of_phy_deregister_fixed_link
1
2
3
4
5
6
7
8
9
10
11 #include <linux/kernel.h>
12 #include <linux/device.h>
13 #include <linux/netdevice.h>
14 #include <linux/err.h>
15 #include <linux/phy.h>
16 #include <linux/phy_fixed.h>
17 #include <linux/of.h>
18 #include <linux/of_irq.h>
19 #include <linux/of_mdio.h>
20 #include <linux/of_net.h>
21 #include <linux/module.h>
22
23 #define DEFAULT_GPIO_RESET_DELAY 10
24
25 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
26 MODULE_LICENSE("GPL");
27
28
29
30 static int of_get_phy_id(struct device_node *device, u32 *phy_id)
31 {
32 struct property *prop;
33 const char *cp;
34 unsigned int upper, lower;
35
36 of_property_for_each_string(device, "compatible", prop, cp) {
37 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) == 2) {
38 *phy_id = ((upper & 0xFFFF) << 16) | (lower & 0xFFFF);
39 return 0;
40 }
41 }
42 return -EINVAL;
43 }
44
45 static int of_mdiobus_register_phy(struct mii_bus *mdio,
46 struct device_node *child, u32 addr)
47 {
48 struct phy_device *phy;
49 bool is_c45;
50 int rc;
51 u32 phy_id;
52
53 is_c45 = of_device_is_compatible(child,
54 "ethernet-phy-ieee802.3-c45");
55
56 if (!is_c45 && !of_get_phy_id(child, &phy_id))
57 phy = phy_device_create(mdio, addr, phy_id, 0, NULL);
58 else
59 phy = get_phy_device(mdio, addr, is_c45);
60 if (IS_ERR(phy))
61 return PTR_ERR(phy);
62
63 rc = of_irq_get(child, 0);
64 if (rc == -EPROBE_DEFER) {
65 phy_device_free(phy);
66 return rc;
67 }
68 if (rc > 0) {
69 phy->irq = rc;
70 mdio->irq[addr] = rc;
71 } else {
72 phy->irq = mdio->irq[addr];
73 }
74
75 if (of_property_read_bool(child, "broken-turn-around"))
76 mdio->phy_ignore_ta_mask |= 1 << addr;
77
78 of_property_read_u32(child, "reset-assert-us",
79 &phy->mdio.reset_assert_delay);
80 of_property_read_u32(child, "reset-deassert-us",
81 &phy->mdio.reset_deassert_delay);
82
83
84
85 of_node_get(child);
86 phy->mdio.dev.of_node = child;
87 phy->mdio.dev.fwnode = of_fwnode_handle(child);
88
89
90
91 rc = phy_device_register(phy);
92 if (rc) {
93 phy_device_free(phy);
94 of_node_put(child);
95 return rc;
96 }
97
98 dev_dbg(&mdio->dev, "registered phy %pOFn at address %i\n",
99 child, addr);
100 return 0;
101 }
102
103 static int of_mdiobus_register_device(struct mii_bus *mdio,
104 struct device_node *child, u32 addr)
105 {
106 struct mdio_device *mdiodev;
107 int rc;
108
109 mdiodev = mdio_device_create(mdio, addr);
110 if (IS_ERR(mdiodev))
111 return PTR_ERR(mdiodev);
112
113
114
115
116 of_node_get(child);
117 mdiodev->dev.of_node = child;
118 mdiodev->dev.fwnode = of_fwnode_handle(child);
119
120
121 rc = mdio_device_register(mdiodev);
122 if (rc) {
123 mdio_device_free(mdiodev);
124 of_node_put(child);
125 return rc;
126 }
127
128 dev_dbg(&mdio->dev, "registered mdio device %pOFn at address %i\n",
129 child, addr);
130 return 0;
131 }
132
133
134
135
136
137
138
139 static const struct of_device_id whitelist_phys[] = {
140 { .compatible = "brcm,40nm-ephy" },
141 { .compatible = "broadcom,bcm5241" },
142 { .compatible = "marvell,88E1111", },
143 { .compatible = "marvell,88e1116", },
144 { .compatible = "marvell,88e1118", },
145 { .compatible = "marvell,88e1145", },
146 { .compatible = "marvell,88e1149r", },
147 { .compatible = "marvell,88e1310", },
148 { .compatible = "marvell,88E1510", },
149 { .compatible = "marvell,88E1514", },
150 { .compatible = "moxa,moxart-rtl8201cp", },
151 {}
152 };
153
154
155
156
157
158
159
160
161
162
163
164
165 static bool of_mdiobus_child_is_phy(struct device_node *child)
166 {
167 u32 phy_id;
168
169 if (of_get_phy_id(child, &phy_id) != -EINVAL)
170 return true;
171
172 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c45"))
173 return true;
174
175 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c22"))
176 return true;
177
178 if (of_match_node(whitelist_phys, child)) {
179 pr_warn(FW_WARN
180 "%pOF: Whitelisted compatible string. Please remove\n",
181 child);
182 return true;
183 }
184
185 if (!of_find_property(child, "compatible", NULL))
186 return true;
187
188 return false;
189 }
190
191
192
193
194
195
196
197
198
199 int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
200 {
201 struct device_node *child;
202 bool scanphys = false;
203 int addr, rc;
204
205 if (!np)
206 return mdiobus_register(mdio);
207
208
209 if (!of_device_is_available(np))
210 return -ENODEV;
211
212
213
214 mdio->phy_mask = ~0;
215
216 mdio->dev.of_node = np;
217 mdio->dev.fwnode = of_fwnode_handle(np);
218
219
220 mdio->reset_delay_us = DEFAULT_GPIO_RESET_DELAY;
221 of_property_read_u32(np, "reset-delay-us", &mdio->reset_delay_us);
222
223
224 rc = mdiobus_register(mdio);
225 if (rc)
226 return rc;
227
228
229 for_each_available_child_of_node(np, child) {
230 addr = of_mdio_parse_addr(&mdio->dev, child);
231 if (addr < 0) {
232 scanphys = true;
233 continue;
234 }
235
236 if (of_mdiobus_child_is_phy(child))
237 rc = of_mdiobus_register_phy(mdio, child, addr);
238 else
239 rc = of_mdiobus_register_device(mdio, child, addr);
240
241 if (rc == -ENODEV)
242 dev_err(&mdio->dev,
243 "MDIO device at address %d is missing.\n",
244 addr);
245 else if (rc)
246 goto unregister;
247 }
248
249 if (!scanphys)
250 return 0;
251
252
253 for_each_available_child_of_node(np, child) {
254
255 if (of_find_property(child, "reg", NULL))
256 continue;
257
258 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
259
260 if (mdiobus_is_registered_device(mdio, addr))
261 continue;
262
263
264 dev_info(&mdio->dev, "scan phy %pOFn at address %i\n",
265 child, addr);
266
267 if (of_mdiobus_child_is_phy(child)) {
268 rc = of_mdiobus_register_phy(mdio, child, addr);
269 if (rc && rc != -ENODEV)
270 goto unregister;
271 break;
272 }
273 }
274 }
275
276 return 0;
277
278 unregister:
279 mdiobus_unregister(mdio);
280 return rc;
281 }
282 EXPORT_SYMBOL(of_mdiobus_register);
283
284
285
286
287
288
289
290
291 struct phy_device *of_phy_find_device(struct device_node *phy_np)
292 {
293 struct device *d;
294 struct mdio_device *mdiodev;
295
296 if (!phy_np)
297 return NULL;
298
299 d = bus_find_device_by_of_node(&mdio_bus_type, phy_np);
300 if (d) {
301 mdiodev = to_mdio_device(d);
302 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
303 return to_phy_device(d);
304 put_device(d);
305 }
306
307 return NULL;
308 }
309 EXPORT_SYMBOL(of_phy_find_device);
310
311
312
313
314
315
316
317
318
319
320
321
322
323 struct phy_device *of_phy_connect(struct net_device *dev,
324 struct device_node *phy_np,
325 void (*hndlr)(struct net_device *), u32 flags,
326 phy_interface_t iface)
327 {
328 struct phy_device *phy = of_phy_find_device(phy_np);
329 int ret;
330
331 if (!phy)
332 return NULL;
333
334 phy->dev_flags = flags;
335
336 ret = phy_connect_direct(dev, phy, hndlr, iface);
337
338
339 put_device(&phy->mdio.dev);
340
341 return ret ? NULL : phy;
342 }
343 EXPORT_SYMBOL(of_phy_connect);
344
345
346
347
348
349
350
351
352
353
354
355
356 struct phy_device *of_phy_get_and_connect(struct net_device *dev,
357 struct device_node *np,
358 void (*hndlr)(struct net_device *))
359 {
360 phy_interface_t iface;
361 struct device_node *phy_np;
362 struct phy_device *phy;
363 int ret;
364
365 iface = of_get_phy_mode(np);
366 if ((int)iface < 0)
367 return NULL;
368 if (of_phy_is_fixed_link(np)) {
369 ret = of_phy_register_fixed_link(np);
370 if (ret < 0) {
371 netdev_err(dev, "broken fixed-link specification\n");
372 return NULL;
373 }
374 phy_np = of_node_get(np);
375 } else {
376 phy_np = of_parse_phandle(np, "phy-handle", 0);
377 if (!phy_np)
378 return NULL;
379 }
380
381 phy = of_phy_connect(dev, phy_np, hndlr, 0, iface);
382
383 of_node_put(phy_np);
384
385 return phy;
386 }
387 EXPORT_SYMBOL(of_phy_get_and_connect);
388
389
390
391
392
393
394
395
396
397
398
399
400 struct phy_device *of_phy_attach(struct net_device *dev,
401 struct device_node *phy_np, u32 flags,
402 phy_interface_t iface)
403 {
404 struct phy_device *phy = of_phy_find_device(phy_np);
405 int ret;
406
407 if (!phy)
408 return NULL;
409
410 ret = phy_attach_direct(dev, phy, flags, iface);
411
412
413 put_device(&phy->mdio.dev);
414
415 return ret ? NULL : phy;
416 }
417 EXPORT_SYMBOL(of_phy_attach);
418
419
420
421
422
423
424
425
426
427 bool of_phy_is_fixed_link(struct device_node *np)
428 {
429 struct device_node *dn;
430 int len, err;
431 const char *managed;
432
433
434 dn = of_get_child_by_name(np, "fixed-link");
435 if (dn) {
436 of_node_put(dn);
437 return true;
438 }
439
440 err = of_property_read_string(np, "managed", &managed);
441 if (err == 0 && strcmp(managed, "auto") != 0)
442 return true;
443
444
445 if (of_get_property(np, "fixed-link", &len) &&
446 len == (5 * sizeof(__be32)))
447 return true;
448
449 return false;
450 }
451 EXPORT_SYMBOL(of_phy_is_fixed_link);
452
453 int of_phy_register_fixed_link(struct device_node *np)
454 {
455 struct fixed_phy_status status = {};
456 struct device_node *fixed_link_node;
457 u32 fixed_link_prop[5];
458 const char *managed;
459
460 if (of_property_read_string(np, "managed", &managed) == 0 &&
461 strcmp(managed, "in-band-status") == 0) {
462
463 goto register_phy;
464 }
465
466
467 fixed_link_node = of_get_child_by_name(np, "fixed-link");
468 if (fixed_link_node) {
469 status.link = 1;
470 status.duplex = of_property_read_bool(fixed_link_node,
471 "full-duplex");
472 if (of_property_read_u32(fixed_link_node, "speed",
473 &status.speed)) {
474 of_node_put(fixed_link_node);
475 return -EINVAL;
476 }
477 status.pause = of_property_read_bool(fixed_link_node, "pause");
478 status.asym_pause = of_property_read_bool(fixed_link_node,
479 "asym-pause");
480 of_node_put(fixed_link_node);
481
482 goto register_phy;
483 }
484
485
486 if (of_property_read_u32_array(np, "fixed-link", fixed_link_prop,
487 ARRAY_SIZE(fixed_link_prop)) == 0) {
488 status.link = 1;
489 status.duplex = fixed_link_prop[1];
490 status.speed = fixed_link_prop[2];
491 status.pause = fixed_link_prop[3];
492 status.asym_pause = fixed_link_prop[4];
493 goto register_phy;
494 }
495
496 return -ENODEV;
497
498 register_phy:
499 return PTR_ERR_OR_ZERO(fixed_phy_register(PHY_POLL, &status, np));
500 }
501 EXPORT_SYMBOL(of_phy_register_fixed_link);
502
503 void of_phy_deregister_fixed_link(struct device_node *np)
504 {
505 struct phy_device *phydev;
506
507 phydev = of_phy_find_device(np);
508 if (!phydev)
509 return;
510
511 fixed_phy_unregister(phydev);
512
513 put_device(&phydev->mdio.dev);
514 phy_device_free(phydev);
515 }
516 EXPORT_SYMBOL(of_phy_deregister_fixed_link);