1 /*
2 * OF helpers for the MDIO (Ethernet PHY) API
3 *
4 * Copyright (c) 2009 Secret Lab Technologies, Ltd.
5 *
6 * This file is released under the GPLv2
7 *
8 * This file provides helper functions for extracting PHY device information
9 * out of the OpenFirmware device tree and using it to populate an mii_bus.
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 /* in microseconds */
26
27 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
28 MODULE_LICENSE("GPL");
29
30 /* Extract the clause 22 phy ID from the compatible string of the form
31 * ethernet-phy-idAAAA.BBBB */
of_get_phy_id(struct device_node * device,u32 * phy_id)32 static 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
of_mdiobus_register_phy(struct mii_bus * mdio,struct device_node * child,u32 addr)47 static int 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 PTR_ERR(phy);
64
65 rc = of_irq_get(child, 0);
66 if (rc == -EPROBE_DEFER) {
67 phy_device_free(phy);
68 return rc;
69 }
70 if (rc > 0) {
71 phy->irq = rc;
72 mdio->irq[addr] = rc;
73 } else {
74 phy->irq = mdio->irq[addr];
75 }
76
77 if (of_property_read_bool(child, "broken-turn-around"))
78 mdio->phy_ignore_ta_mask |= 1 << addr;
79
80 of_property_read_u32(child, "reset-assert-us",
81 &phy->mdio.reset_assert_delay);
82 of_property_read_u32(child, "reset-deassert-us",
83 &phy->mdio.reset_deassert_delay);
84
85 /* Associate the OF node with the device structure so it
86 * can be looked up later */
87 of_node_get(child);
88 phy->mdio.dev.of_node = child;
89 phy->mdio.dev.fwnode = of_fwnode_handle(child);
90
91 /* All data is now stored in the phy struct;
92 * register it */
93 rc = phy_device_register(phy);
94 if (rc) {
95 phy_device_free(phy);
96 of_node_put(child);
97 return rc;
98 }
99
100 dev_dbg(&mdio->dev, "registered phy %s at address %i\n",
101 child->name, addr);
102 return 0;
103 }
104
of_mdiobus_register_device(struct mii_bus * mdio,struct device_node * child,u32 addr)105 static int of_mdiobus_register_device(struct mii_bus *mdio,
106 struct device_node *child, u32 addr)
107 {
108 struct mdio_device *mdiodev;
109 int rc;
110
111 mdiodev = mdio_device_create(mdio, addr);
112 if (IS_ERR(mdiodev))
113 return PTR_ERR(mdiodev);
114
115 /* Associate the OF node with the device structure so it
116 * can be looked up later.
117 */
118 of_node_get(child);
119 mdiodev->dev.of_node = child;
120 mdiodev->dev.fwnode = of_fwnode_handle(child);
121
122 /* All data is now stored in the mdiodev struct; register it. */
123 rc = mdio_device_register(mdiodev);
124 if (rc) {
125 mdio_device_free(mdiodev);
126 of_node_put(child);
127 return rc;
128 }
129
130 dev_dbg(&mdio->dev, "registered mdio device %s at address %i\n",
131 child->name, addr);
132 return 0;
133 }
134
135 /* The following is a list of PHY compatible strings which appear in
136 * some DTBs. The compatible string is never matched against a PHY
137 * driver, so is pointless. We only expect devices which are not PHYs
138 * to have a compatible string, so they can be matched to an MDIO
139 * driver. Encourage users to upgrade their DT blobs to remove these.
140 */
141 static const struct of_device_id whitelist_phys[] = {
142 { .compatible = "brcm,40nm-ephy" },
143 { .compatible = "broadcom,bcm5241" },
144 { .compatible = "marvell,88E1111", },
145 { .compatible = "marvell,88e1116", },
146 { .compatible = "marvell,88e1118", },
147 { .compatible = "marvell,88e1145", },
148 { .compatible = "marvell,88e1149r", },
149 { .compatible = "marvell,88e1310", },
150 { .compatible = "marvell,88E1510", },
151 { .compatible = "marvell,88E1514", },
152 { .compatible = "moxa,moxart-rtl8201cp", },
153 {}
154 };
155
156 /*
157 * Return true if the child node is for a phy. It must either:
158 * o Compatible string of "ethernet-phy-idX.X"
159 * o Compatible string of "ethernet-phy-ieee802.3-c45"
160 * o Compatible string of "ethernet-phy-ieee802.3-c22"
161 * o In the white list above (and issue a warning)
162 * o No compatibility string
163 *
164 * A device which is not a phy is expected to have a compatible string
165 * indicating what sort of device it is.
166 */
of_mdiobus_child_is_phy(struct device_node * child)167 static bool of_mdiobus_child_is_phy(struct device_node *child)
168 {
169 u32 phy_id;
170
171 if (of_get_phy_id(child, &phy_id) != -EINVAL)
172 return true;
173
174 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c45"))
175 return true;
176
177 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c22"))
178 return true;
179
180 if (of_match_node(whitelist_phys, child)) {
181 pr_warn(FW_WARN
182 "%pOF: Whitelisted compatible string. Please remove\n",
183 child);
184 return true;
185 }
186
187 if (!of_find_property(child, "compatible", NULL))
188 return true;
189
190 return false;
191 }
192
193 /**
194 * of_mdiobus_register - Register mii_bus and create PHYs from the device tree
195 * @mdio: pointer to mii_bus structure
196 * @np: pointer to device_node of MDIO bus.
197 *
198 * This function registers the mii_bus structure and registers a phy_device
199 * for each child node of @np.
200 */
of_mdiobus_register(struct mii_bus * mdio,struct device_node * np)201 int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
202 {
203 struct device_node *child;
204 bool scanphys = false;
205 int addr, rc;
206
207 if (!np)
208 return mdiobus_register(mdio);
209
210 /* Do not continue if the node is disabled */
211 if (!of_device_is_available(np))
212 return -ENODEV;
213
214 /* Mask out all PHYs from auto probing. Instead the PHYs listed in
215 * the device tree are populated after the bus has been registered */
216 mdio->phy_mask = ~0;
217
218 mdio->dev.of_node = np;
219 mdio->dev.fwnode = of_fwnode_handle(np);
220
221 /* Get bus level PHY reset GPIO details */
222 mdio->reset_delay_us = DEFAULT_GPIO_RESET_DELAY;
223 of_property_read_u32(np, "reset-delay-us", &mdio->reset_delay_us);
224
225 /* Register the MDIO bus */
226 rc = mdiobus_register(mdio);
227 if (rc)
228 return rc;
229
230 /* Loop over the child nodes and register a phy_device for each phy */
231 for_each_available_child_of_node(np, child) {
232 addr = of_mdio_parse_addr(&mdio->dev, child);
233 if (addr < 0) {
234 scanphys = true;
235 continue;
236 }
237
238 if (of_mdiobus_child_is_phy(child))
239 rc = of_mdiobus_register_phy(mdio, child, addr);
240 else
241 rc = of_mdiobus_register_device(mdio, child, addr);
242
243 if (rc == -ENODEV)
244 dev_err(&mdio->dev,
245 "MDIO device at address %d is missing.\n",
246 addr);
247 else if (rc)
248 goto unregister;
249 }
250
251 if (!scanphys)
252 return 0;
253
254 /* auto scan for PHYs with empty reg property */
255 for_each_available_child_of_node(np, child) {
256 /* Skip PHYs with reg property set */
257 if (of_find_property(child, "reg", NULL))
258 continue;
259
260 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
261 /* skip already registered PHYs */
262 if (mdiobus_is_registered_device(mdio, addr))
263 continue;
264
265 /* be noisy to encourage people to set reg property */
266 dev_info(&mdio->dev, "scan phy %s at address %i\n",
267 child->name, addr);
268
269 if (of_mdiobus_child_is_phy(child)) {
270 rc = of_mdiobus_register_phy(mdio, child, addr);
271 if (rc && rc != -ENODEV)
272 goto unregister;
273 }
274 }
275 }
276
277 return 0;
278
279 unregister:
280 mdiobus_unregister(mdio);
281 return rc;
282 }
283 EXPORT_SYMBOL(of_mdiobus_register);
284
285 /* Helper function for of_phy_find_device */
of_phy_match(struct device * dev,void * phy_np)286 static int of_phy_match(struct device *dev, void *phy_np)
287 {
288 return dev->of_node == phy_np;
289 }
290
291 /**
292 * of_phy_find_device - Give a PHY node, find the phy_device
293 * @phy_np: Pointer to the phy's device tree node
294 *
295 * If successful, returns a pointer to the phy_device with the embedded
296 * struct device refcount incremented by one, or NULL on failure.
297 */
of_phy_find_device(struct device_node * phy_np)298 struct phy_device *of_phy_find_device(struct device_node *phy_np)
299 {
300 struct device *d;
301 struct mdio_device *mdiodev;
302
303 if (!phy_np)
304 return NULL;
305
306 d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
307 if (d) {
308 mdiodev = to_mdio_device(d);
309 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
310 return to_phy_device(d);
311 put_device(d);
312 }
313
314 return NULL;
315 }
316 EXPORT_SYMBOL(of_phy_find_device);
317
318 /**
319 * of_phy_connect - Connect to the phy described in the device tree
320 * @dev: pointer to net_device claiming the phy
321 * @phy_np: Pointer to device tree node for the PHY
322 * @hndlr: Link state callback for the network device
323 * @flags: flags to pass to the PHY
324 * @iface: PHY data interface type
325 *
326 * If successful, returns a pointer to the phy_device with the embedded
327 * struct device refcount incremented by one, or NULL on failure. The
328 * refcount must be dropped by calling phy_disconnect() or phy_detach().
329 */
of_phy_connect(struct net_device * dev,struct device_node * phy_np,void (* hndlr)(struct net_device *),u32 flags,phy_interface_t iface)330 struct phy_device *of_phy_connect(struct net_device *dev,
331 struct device_node *phy_np,
332 void (*hndlr)(struct net_device *), u32 flags,
333 phy_interface_t iface)
334 {
335 struct phy_device *phy = of_phy_find_device(phy_np);
336 int ret;
337
338 if (!phy)
339 return NULL;
340
341 phy->dev_flags = flags;
342
343 ret = phy_connect_direct(dev, phy, hndlr, iface);
344
345 /* refcount is held by phy_connect_direct() on success */
346 put_device(&phy->mdio.dev);
347
348 return ret ? NULL : phy;
349 }
350 EXPORT_SYMBOL(of_phy_connect);
351
352 /**
353 * of_phy_get_and_connect
354 * - Get phy node and connect to the phy described in the device tree
355 * @dev: pointer to net_device claiming the phy
356 * @np: Pointer to device tree node for the net_device claiming the phy
357 * @hndlr: Link state callback for the network device
358 *
359 * If successful, returns a pointer to the phy_device with the embedded
360 * struct device refcount incremented by one, or NULL on failure. The
361 * refcount must be dropped by calling phy_disconnect() or phy_detach().
362 */
of_phy_get_and_connect(struct net_device * dev,struct device_node * np,void (* hndlr)(struct net_device *))363 struct phy_device *of_phy_get_and_connect(struct net_device *dev,
364 struct device_node *np,
365 void (*hndlr)(struct net_device *))
366 {
367 phy_interface_t iface;
368 struct device_node *phy_np;
369 struct phy_device *phy;
370 int ret;
371
372 iface = of_get_phy_mode(np);
373 if (iface < 0)
374 return NULL;
375 if (of_phy_is_fixed_link(np)) {
376 ret = of_phy_register_fixed_link(np);
377 if (ret < 0) {
378 netdev_err(dev, "broken fixed-link specification\n");
379 return NULL;
380 }
381 phy_np = of_node_get(np);
382 } else {
383 phy_np = of_parse_phandle(np, "phy-handle", 0);
384 if (!phy_np)
385 return NULL;
386 }
387
388 phy = of_phy_connect(dev, phy_np, hndlr, 0, iface);
389
390 of_node_put(phy_np);
391
392 return phy;
393 }
394 EXPORT_SYMBOL(of_phy_get_and_connect);
395
396 /**
397 * of_phy_attach - Attach to a PHY without starting the state machine
398 * @dev: pointer to net_device claiming the phy
399 * @phy_np: Node pointer for the PHY
400 * @flags: flags to pass to the PHY
401 * @iface: PHY data interface type
402 *
403 * If successful, returns a pointer to the phy_device with the embedded
404 * struct device refcount incremented by one, or NULL on failure. The
405 * refcount must be dropped by calling phy_disconnect() or phy_detach().
406 */
of_phy_attach(struct net_device * dev,struct device_node * phy_np,u32 flags,phy_interface_t iface)407 struct phy_device *of_phy_attach(struct net_device *dev,
408 struct device_node *phy_np, u32 flags,
409 phy_interface_t iface)
410 {
411 struct phy_device *phy = of_phy_find_device(phy_np);
412 int ret;
413
414 if (!phy)
415 return NULL;
416
417 ret = phy_attach_direct(dev, phy, flags, iface);
418
419 /* refcount is held by phy_attach_direct() on success */
420 put_device(&phy->mdio.dev);
421
422 return ret ? NULL : phy;
423 }
424 EXPORT_SYMBOL(of_phy_attach);
425
426 /*
427 * of_phy_is_fixed_link() and of_phy_register_fixed_link() must
428 * support two DT bindings:
429 * - the old DT binding, where 'fixed-link' was a property with 5
430 * cells encoding various informations about the fixed PHY
431 * - the new DT binding, where 'fixed-link' is a sub-node of the
432 * Ethernet device.
433 */
of_phy_is_fixed_link(struct device_node * np)434 bool of_phy_is_fixed_link(struct device_node *np)
435 {
436 struct device_node *dn;
437 int len, err;
438 const char *managed;
439
440 /* New binding */
441 dn = of_get_child_by_name(np, "fixed-link");
442 if (dn) {
443 of_node_put(dn);
444 return true;
445 }
446
447 err = of_property_read_string(np, "managed", &managed);
448 if (err == 0 && strcmp(managed, "auto") != 0)
449 return true;
450
451 /* Old binding */
452 if (of_get_property(np, "fixed-link", &len) &&
453 len == (5 * sizeof(__be32)))
454 return true;
455
456 return false;
457 }
458 EXPORT_SYMBOL(of_phy_is_fixed_link);
459
of_phy_register_fixed_link(struct device_node * np)460 int of_phy_register_fixed_link(struct device_node *np)
461 {
462 struct fixed_phy_status status = {};
463 struct device_node *fixed_link_node;
464 u32 fixed_link_prop[5];
465 const char *managed;
466 int link_gpio = -1;
467
468 if (of_property_read_string(np, "managed", &managed) == 0 &&
469 strcmp(managed, "in-band-status") == 0) {
470 /* status is zeroed, namely its .link member */
471 goto register_phy;
472 }
473
474 /* New binding */
475 fixed_link_node = of_get_child_by_name(np, "fixed-link");
476 if (fixed_link_node) {
477 status.link = 1;
478 status.duplex = of_property_read_bool(fixed_link_node,
479 "full-duplex");
480 if (of_property_read_u32(fixed_link_node, "speed",
481 &status.speed)) {
482 of_node_put(fixed_link_node);
483 return -EINVAL;
484 }
485 status.pause = of_property_read_bool(fixed_link_node, "pause");
486 status.asym_pause = of_property_read_bool(fixed_link_node,
487 "asym-pause");
488 link_gpio = of_get_named_gpio_flags(fixed_link_node,
489 "link-gpios", 0, NULL);
490 of_node_put(fixed_link_node);
491 if (link_gpio == -EPROBE_DEFER)
492 return -EPROBE_DEFER;
493
494 goto register_phy;
495 }
496
497 /* Old binding */
498 if (of_property_read_u32_array(np, "fixed-link", fixed_link_prop,
499 ARRAY_SIZE(fixed_link_prop)) == 0) {
500 status.link = 1;
501 status.duplex = fixed_link_prop[1];
502 status.speed = fixed_link_prop[2];
503 status.pause = fixed_link_prop[3];
504 status.asym_pause = fixed_link_prop[4];
505 goto register_phy;
506 }
507
508 return -ENODEV;
509
510 register_phy:
511 return PTR_ERR_OR_ZERO(fixed_phy_register(PHY_POLL, &status, link_gpio,
512 np));
513 }
514 EXPORT_SYMBOL(of_phy_register_fixed_link);
515
of_phy_deregister_fixed_link(struct device_node * np)516 void of_phy_deregister_fixed_link(struct device_node *np)
517 {
518 struct phy_device *phydev;
519
520 phydev = of_phy_find_device(np);
521 if (!phydev)
522 return;
523
524 fixed_phy_unregister(phydev);
525
526 put_device(&phydev->mdio.dev); /* of_phy_find_device() */
527 phy_device_free(phydev); /* fixed_phy_register() */
528 }
529 EXPORT_SYMBOL(of_phy_deregister_fixed_link);
530
