blob: 86829f8064a61eb324a0a9ea28f63f0bf3ceadbd [file] [log] [blame]
Grant Likely8bc487d2009-04-25 12:52:56 +00001/*
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
Anton Vorontsov24c30db2009-07-16 21:31:31 +000012#include <linux/kernel.h>
13#include <linux/device.h>
14#include <linux/netdevice.h>
15#include <linux/err.h>
Grant Likely8bc487d2009-04-25 12:52:56 +000016#include <linux/phy.h>
Thomas Petazzoni3be2a492014-05-16 16:14:05 +020017#include <linux/phy_fixed.h>
Grant Likely8bc487d2009-04-25 12:52:56 +000018#include <linux/of.h>
Andrew Lunna5597002015-08-31 15:56:53 +020019#include <linux/of_gpio.h>
Grant Likelye3873442010-06-18 11:09:59 -060020#include <linux/of_irq.h>
Grant Likely8bc487d2009-04-25 12:52:56 +000021#include <linux/of_mdio.h>
22#include <linux/module.h>
23
24MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
25MODULE_LICENSE("GPL");
26
Jason Gunthorpe3c6f5592014-03-19 16:15:24 -060027/* Extract the clause 22 phy ID from the compatible string of the form
28 * ethernet-phy-idAAAA.BBBB */
29static int of_get_phy_id(struct device_node *device, u32 *phy_id)
30{
31 struct property *prop;
32 const char *cp;
33 unsigned int upper, lower;
34
35 of_property_for_each_string(device, "compatible", prop, cp) {
36 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) == 2) {
37 *phy_id = ((upper & 0xFFFF) << 16) | (lower & 0xFFFF);
38 return 0;
39 }
40 }
41 return -EINVAL;
42}
43
Florian Fainelli2e79cb32013-12-05 14:52:10 -080044static int of_mdiobus_register_phy(struct mii_bus *mdio, struct device_node *child,
45 u32 addr)
46{
47 struct phy_device *phy;
48 bool is_c45;
Ben Dooksf15c5862014-02-18 12:16:58 +000049 int rc;
Jason Gunthorpe3c6f5592014-03-19 16:15:24 -060050 u32 phy_id;
Florian Fainelli2e79cb32013-12-05 14:52:10 -080051
52 is_c45 = of_device_is_compatible(child,
53 "ethernet-phy-ieee802.3-c45");
54
Jason Gunthorpe3c6f5592014-03-19 16:15:24 -060055 if (!is_c45 && !of_get_phy_id(child, &phy_id))
56 phy = phy_device_create(mdio, addr, phy_id, 0, NULL);
57 else
58 phy = get_phy_device(mdio, addr, is_c45);
Florian Fainelli2e79cb32013-12-05 14:52:10 -080059 if (!phy || IS_ERR(phy))
60 return 1;
61
Ben Dooksf15c5862014-02-18 12:16:58 +000062 rc = irq_of_parse_and_map(child, 0);
63 if (rc > 0) {
64 phy->irq = rc;
Dan Carpenter1bc16ad2016-01-12 12:35:34 +030065 mdio->irq[addr] = rc;
Ben Dooksf15c5862014-02-18 12:16:58 +000066 } else {
Dan Carpenter1bc16ad2016-01-12 12:35:34 +030067 phy->irq = mdio->irq[addr];
Florian Fainelli2e79cb32013-12-05 14:52:10 -080068 }
69
Florian Fainelliab6016e2015-05-12 10:33:25 -070070 if (of_property_read_bool(child, "broken-turn-around"))
71 mdio->phy_ignore_ta_mask |= 1 << addr;
72
Florian Fainelli2e79cb32013-12-05 14:52:10 -080073 /* Associate the OF node with the device structure so it
74 * can be looked up later */
75 of_node_get(child);
Andrew Lunne5a03bf2016-01-06 20:11:16 +010076 phy->mdio.dev.of_node = child;
Florian Fainelli2e79cb32013-12-05 14:52:10 -080077
78 /* All data is now stored in the phy struct;
79 * register it */
80 rc = phy_device_register(phy);
81 if (rc) {
82 phy_device_free(phy);
83 of_node_put(child);
84 return 1;
85 }
86
87 dev_dbg(&mdio->dev, "registered phy %s at address %i\n",
Florian Fainelli8fdade42013-12-05 14:52:14 -080088 child->name, addr);
Florian Fainelli2e79cb32013-12-05 14:52:10 -080089
90 return 0;
91}
92
Andrew Lunna9049e02016-01-06 20:11:26 +010093static int of_mdiobus_register_device(struct mii_bus *mdio,
94 struct device_node *child,
95 u32 addr)
96{
97 struct mdio_device *mdiodev;
98 int rc;
99
100 mdiodev = mdio_device_create(mdio, addr);
101 if (!mdiodev || IS_ERR(mdiodev))
102 return 1;
103
104 /* Associate the OF node with the device structure so it
105 * can be looked up later.
106 */
107 of_node_get(child);
108 mdiodev->dev.of_node = child;
109
110 /* All data is now stored in the mdiodev struct; register it. */
111 rc = mdio_device_register(mdiodev);
112 if (rc) {
113 mdio_device_free(mdiodev);
114 of_node_put(child);
115 return 1;
116 }
117
118 dev_dbg(&mdio->dev, "registered mdio device %s at address %i\n",
119 child->name, addr);
120
121 return 0;
122}
123
Florian Fainelli33d67372015-03-10 16:57:11 -0700124int of_mdio_parse_addr(struct device *dev, const struct device_node *np)
Daniel Mack8f838282014-05-24 09:34:25 +0200125{
126 u32 addr;
127 int ret;
128
129 ret = of_property_read_u32(np, "reg", &addr);
130 if (ret < 0) {
131 dev_err(dev, "%s has invalid PHY address\n", np->full_name);
132 return ret;
133 }
134
135 /* A PHY must have a reg property in the range [0-31] */
136 if (addr >= PHY_MAX_ADDR) {
137 dev_err(dev, "%s PHY address %i is too large\n",
138 np->full_name, addr);
139 return -EINVAL;
140 }
141
142 return addr;
143}
Florian Fainelli33d67372015-03-10 16:57:11 -0700144EXPORT_SYMBOL(of_mdio_parse_addr);
Daniel Mack8f838282014-05-24 09:34:25 +0200145
Andrew Lunn801a8ef2016-01-06 20:11:17 +0100146/*
147 * Return true if the child node is for a phy. It must either:
148 * o Compatible string of "ethernet-phy-idX.X"
149 * o Compatible string of "ethernet-phy-ieee802.3-c45"
150 * o Compatible string of "ethernet-phy-ieee802.3-c22"
151 * o No compatibility string
152 *
153 * A device which is not a phy is expected to have a compatible string
154 * indicating what sort of device it is.
155 */
156static bool of_mdiobus_child_is_phy(struct device_node *child)
157{
158 u32 phy_id;
159
160 if (of_get_phy_id(child, &phy_id) != -EINVAL)
161 return true;
162
163 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c45"))
164 return true;
165
166 if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c22"))
167 return true;
168
169 if (!of_find_property(child, "compatible", NULL))
170 return true;
171
172 return false;
173}
174
Grant Likely8bc487d2009-04-25 12:52:56 +0000175/**
176 * of_mdiobus_register - Register mii_bus and create PHYs from the device tree
177 * @mdio: pointer to mii_bus structure
178 * @np: pointer to device_node of MDIO bus.
179 *
180 * This function registers the mii_bus structure and registers a phy_device
181 * for each child node of @np.
182 */
183int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
184{
Grant Likely8bc487d2009-04-25 12:52:56 +0000185 struct device_node *child;
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000186 const __be32 *paddr;
Florian Fainelli2e79cb32013-12-05 14:52:10 -0800187 bool scanphys = false;
Andrew Lunne7f4dc32016-01-06 20:11:15 +0100188 int addr, rc;
Grant Likely8bc487d2009-04-25 12:52:56 +0000189
190 /* Mask out all PHYs from auto probing. Instead the PHYs listed in
191 * the device tree are populated after the bus has been registered */
192 mdio->phy_mask = ~0;
193
David Daney25106022012-05-02 15:16:37 +0000194 mdio->dev.of_node = np;
195
Grant Likely8bc487d2009-04-25 12:52:56 +0000196 /* Register the MDIO bus */
197 rc = mdiobus_register(mdio);
198 if (rc)
199 return rc;
200
Andrew Lunn801a8ef2016-01-06 20:11:17 +0100201 /* Loop over the child nodes and register a phy_device for each phy */
Alexander Sverdline207e762012-11-29 08:45:20 +0100202 for_each_available_child_of_node(np, child) {
Daniel Mack8f838282014-05-24 09:34:25 +0200203 addr = of_mdio_parse_addr(&mdio->dev, child);
204 if (addr < 0) {
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000205 scanphys = true;
David Daney19458862010-10-27 18:03:47 -0700206 continue;
Grant Likely8bc487d2009-04-25 12:52:56 +0000207 }
208
Andrew Lunn801a8ef2016-01-06 20:11:17 +0100209 if (of_mdiobus_child_is_phy(child))
210 of_mdiobus_register_phy(mdio, child, addr);
Andrew Lunna9049e02016-01-06 20:11:26 +0100211 else
212 of_mdiobus_register_device(mdio, child, addr);
Grant Likely8bc487d2009-04-25 12:52:56 +0000213 }
214
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000215 if (!scanphys)
216 return 0;
217
218 /* auto scan for PHYs with empty reg property */
219 for_each_available_child_of_node(np, child) {
220 /* Skip PHYs with reg property set */
Daniel Mack24f28dd2014-05-24 09:34:27 +0200221 paddr = of_get_property(child, "reg", NULL);
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000222 if (paddr)
223 continue;
224
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000225 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
226 /* skip already registered PHYs */
Andrew Lunn7f854422016-01-06 20:11:18 +0100227 if (mdiobus_is_registered_device(mdio, addr))
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000228 continue;
229
230 /* be noisy to encourage people to set reg property */
231 dev_info(&mdio->dev, "scan phy %s at address %i\n",
232 child->name, addr);
233
Andrew Lunn801a8ef2016-01-06 20:11:17 +0100234 if (of_mdiobus_child_is_phy(child))
235 of_mdiobus_register_phy(mdio, child, addr);
Sebastian Hesselbarth779d8352013-04-07 01:09:48 +0000236 }
237 }
238
Grant Likely8bc487d2009-04-25 12:52:56 +0000239 return 0;
240}
241EXPORT_SYMBOL(of_mdiobus_register);
242
Jérôme Pouiller08a79632009-10-15 09:58:27 -0600243/* Helper function for of_phy_find_device */
244static int of_phy_match(struct device *dev, void *phy_np)
245{
Grant Likely61c7a082010-04-13 16:12:29 -0700246 return dev->of_node == phy_np;
Jérôme Pouiller08a79632009-10-15 09:58:27 -0600247}
248
Grant Likely8bc487d2009-04-25 12:52:56 +0000249/**
250 * of_phy_find_device - Give a PHY node, find the phy_device
251 * @phy_np: Pointer to the phy's device tree node
252 *
Russell Kingf018ae72015-09-24 20:36:13 +0100253 * If successful, returns a pointer to the phy_device with the embedded
254 * struct device refcount incremented by one, or NULL on failure.
Grant Likely8bc487d2009-04-25 12:52:56 +0000255 */
256struct phy_device *of_phy_find_device(struct device_node *phy_np)
257{
258 struct device *d;
Grant Likely8bc487d2009-04-25 12:52:56 +0000259 if (!phy_np)
260 return NULL;
261
Jérôme Pouiller08a79632009-10-15 09:58:27 -0600262 d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
Grant Likely8bc487d2009-04-25 12:52:56 +0000263 return d ? to_phy_device(d) : NULL;
264}
265EXPORT_SYMBOL(of_phy_find_device);
266
267/**
268 * of_phy_connect - Connect to the phy described in the device tree
269 * @dev: pointer to net_device claiming the phy
270 * @phy_np: Pointer to device tree node for the PHY
271 * @hndlr: Link state callback for the network device
272 * @iface: PHY data interface type
273 *
Russell Kingf018ae72015-09-24 20:36:13 +0100274 * If successful, returns a pointer to the phy_device with the embedded
275 * struct device refcount incremented by one, or NULL on failure. The
276 * refcount must be dropped by calling phy_disconnect() or phy_detach().
Grant Likely8bc487d2009-04-25 12:52:56 +0000277 */
278struct phy_device *of_phy_connect(struct net_device *dev,
279 struct device_node *phy_np,
280 void (*hndlr)(struct net_device *), u32 flags,
281 phy_interface_t iface)
282{
283 struct phy_device *phy = of_phy_find_device(phy_np);
Russell Kingf018ae72015-09-24 20:36:13 +0100284 int ret;
Grant Likely8bc487d2009-04-25 12:52:56 +0000285
286 if (!phy)
287 return NULL;
288
Florian Fainelli2f637152014-09-19 13:07:49 -0700289 phy->dev_flags = flags;
290
Russell Kingf018ae72015-09-24 20:36:13 +0100291 ret = phy_connect_direct(dev, phy, hndlr, iface);
292
293 /* refcount is held by phy_connect_direct() on success */
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100294 put_device(&phy->mdio.dev);
Russell Kingf018ae72015-09-24 20:36:13 +0100295
296 return ret ? NULL : phy;
Grant Likely8bc487d2009-04-25 12:52:56 +0000297}
298EXPORT_SYMBOL(of_phy_connect);
Anton Vorontsov24c30db2009-07-16 21:31:31 +0000299
300/**
Andy Fleming7614aba2014-01-10 14:28:11 +0800301 * of_phy_attach - Attach to a PHY without starting the state machine
302 * @dev: pointer to net_device claiming the phy
303 * @phy_np: Node pointer for the PHY
304 * @flags: flags to pass to the PHY
305 * @iface: PHY data interface type
Russell Kingf018ae72015-09-24 20:36:13 +0100306 *
307 * If successful, returns a pointer to the phy_device with the embedded
308 * struct device refcount incremented by one, or NULL on failure. The
309 * refcount must be dropped by calling phy_disconnect() or phy_detach().
Andy Fleming7614aba2014-01-10 14:28:11 +0800310 */
311struct phy_device *of_phy_attach(struct net_device *dev,
312 struct device_node *phy_np, u32 flags,
313 phy_interface_t iface)
314{
315 struct phy_device *phy = of_phy_find_device(phy_np);
Russell Kingf018ae72015-09-24 20:36:13 +0100316 int ret;
Andy Fleming7614aba2014-01-10 14:28:11 +0800317
318 if (!phy)
319 return NULL;
320
Russell Kingf018ae72015-09-24 20:36:13 +0100321 ret = phy_attach_direct(dev, phy, flags, iface);
322
323 /* refcount is held by phy_attach_direct() on success */
Andrew Lunne5a03bf2016-01-06 20:11:16 +0100324 put_device(&phy->mdio.dev);
Russell Kingf018ae72015-09-24 20:36:13 +0100325
326 return ret ? NULL : phy;
Andy Fleming7614aba2014-01-10 14:28:11 +0800327}
328EXPORT_SYMBOL(of_phy_attach);
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200329
330#if defined(CONFIG_FIXED_PHY)
331/*
332 * of_phy_is_fixed_link() and of_phy_register_fixed_link() must
333 * support two DT bindings:
334 * - the old DT binding, where 'fixed-link' was a property with 5
335 * cells encoding various informations about the fixed PHY
336 * - the new DT binding, where 'fixed-link' is a sub-node of the
337 * Ethernet device.
338 */
339bool of_phy_is_fixed_link(struct device_node *np)
340{
341 struct device_node *dn;
Stas Sergeev4cba5c22015-07-20 17:49:57 -0700342 int len, err;
343 const char *managed;
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200344
345 /* New binding */
346 dn = of_get_child_by_name(np, "fixed-link");
347 if (dn) {
348 of_node_put(dn);
349 return true;
350 }
351
Stas Sergeev4cba5c22015-07-20 17:49:57 -0700352 err = of_property_read_string(np, "managed", &managed);
353 if (err == 0 && strcmp(managed, "auto") != 0)
354 return true;
355
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200356 /* Old binding */
357 if (of_get_property(np, "fixed-link", &len) &&
358 len == (5 * sizeof(__be32)))
359 return true;
360
361 return false;
362}
363EXPORT_SYMBOL(of_phy_is_fixed_link);
364
365int of_phy_register_fixed_link(struct device_node *np)
366{
367 struct fixed_phy_status status = {};
368 struct device_node *fixed_link_node;
369 const __be32 *fixed_link_prop;
Andrew Lunna5597002015-08-31 15:56:53 +0200370 int link_gpio;
Stas Sergeev4cba5c22015-07-20 17:49:57 -0700371 int len, err;
Petri Gyntherfd2ef0b2014-10-06 11:38:30 -0700372 struct phy_device *phy;
Stas Sergeev4cba5c22015-07-20 17:49:57 -0700373 const char *managed;
374
375 err = of_property_read_string(np, "managed", &managed);
376 if (err == 0) {
377 if (strcmp(managed, "in-band-status") == 0) {
378 /* status is zeroed, namely its .link member */
Andrew Lunna5597002015-08-31 15:56:53 +0200379 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
Stas Sergeev4cba5c22015-07-20 17:49:57 -0700380 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
381 }
382 }
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200383
384 /* New binding */
385 fixed_link_node = of_get_child_by_name(np, "fixed-link");
386 if (fixed_link_node) {
387 status.link = 1;
Richard Retanubuna72e1542014-06-20 10:11:07 -0400388 status.duplex = of_property_read_bool(fixed_link_node,
389 "full-duplex");
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200390 if (of_property_read_u32(fixed_link_node, "speed", &status.speed))
391 return -EINVAL;
Richard Retanubuna72e1542014-06-20 10:11:07 -0400392 status.pause = of_property_read_bool(fixed_link_node, "pause");
393 status.asym_pause = of_property_read_bool(fixed_link_node,
394 "asym-pause");
Andrew Lunna5597002015-08-31 15:56:53 +0200395 link_gpio = of_get_named_gpio_flags(fixed_link_node,
396 "link-gpios", 0, NULL);
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200397 of_node_put(fixed_link_node);
Andrew Lunna5597002015-08-31 15:56:53 +0200398 if (link_gpio == -EPROBE_DEFER)
399 return -EPROBE_DEFER;
400
401 phy = fixed_phy_register(PHY_POLL, &status, link_gpio, np);
Petri Gyntherfd2ef0b2014-10-06 11:38:30 -0700402 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200403 }
404
405 /* Old binding */
406 fixed_link_prop = of_get_property(np, "fixed-link", &len);
407 if (fixed_link_prop && len == (5 * sizeof(__be32))) {
408 status.link = 1;
409 status.duplex = be32_to_cpu(fixed_link_prop[1]);
410 status.speed = be32_to_cpu(fixed_link_prop[2]);
411 status.pause = be32_to_cpu(fixed_link_prop[3]);
412 status.asym_pause = be32_to_cpu(fixed_link_prop[4]);
Andrew Lunna5597002015-08-31 15:56:53 +0200413 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
Petri Gyntherfd2ef0b2014-10-06 11:38:30 -0700414 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
Thomas Petazzoni3be2a492014-05-16 16:14:05 +0200415 }
416
417 return -ENODEV;
418}
419EXPORT_SYMBOL(of_phy_register_fixed_link);
420#endif