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