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/module.h>
23
24 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
25 MODULE_LICENSE("GPL");
26
27 /* Extract the clause 22 phy ID from the compatible string of the form
28 * ethernet-phy-idAAAA.BBBB */
of_get_phy_id(struct device_node * device,u32 * phy_id)29 static 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
of_mdiobus_register_phy(struct mii_bus * mdio,struct device_node * child,u32 addr)44 static 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;
49 int rc;
50 u32 phy_id;
51
52 is_c45 = of_device_is_compatible(child,
53 "ethernet-phy-ieee802.3-c45");
54
55 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);
59 if (!phy || IS_ERR(phy))
60 return 1;
61
62 rc = irq_of_parse_and_map(child, 0);
63 if (rc > 0) {
64 phy->irq = rc;
65 if (mdio->irq)
66 mdio->irq[addr] = rc;
67 } else {
68 if (mdio->irq)
69 phy->irq = mdio->irq[addr];
70 }
71
72 if (of_property_read_bool(child, "broken-turn-around"))
73 mdio->phy_ignore_ta_mask |= 1 << addr;
74
75 /* Associate the OF node with the device structure so it
76 * can be looked up later */
77 of_node_get(child);
78 phy->dev.of_node = child;
79
80 /* All data is now stored in the phy struct;
81 * register it */
82 rc = phy_device_register(phy);
83 if (rc) {
84 phy_device_free(phy);
85 of_node_put(child);
86 return 1;
87 }
88
89 dev_dbg(&mdio->dev, "registered phy %s at address %i\n",
90 child->name, addr);
91
92 return 0;
93 }
94
of_mdio_parse_addr(struct device * dev,const struct device_node * np)95 int of_mdio_parse_addr(struct device *dev, const struct device_node *np)
96 {
97 u32 addr;
98 int ret;
99
100 ret = of_property_read_u32(np, "reg", &addr);
101 if (ret < 0) {
102 dev_err(dev, "%s has invalid PHY address\n", np->full_name);
103 return ret;
104 }
105
106 /* A PHY must have a reg property in the range [0-31] */
107 if (addr >= PHY_MAX_ADDR) {
108 dev_err(dev, "%s PHY address %i is too large\n",
109 np->full_name, addr);
110 return -EINVAL;
111 }
112
113 return addr;
114 }
115 EXPORT_SYMBOL(of_mdio_parse_addr);
116
117 /**
118 * of_mdiobus_register - Register mii_bus and create PHYs from the device tree
119 * @mdio: pointer to mii_bus structure
120 * @np: pointer to device_node of MDIO bus.
121 *
122 * This function registers the mii_bus structure and registers a phy_device
123 * for each child node of @np.
124 */
of_mdiobus_register(struct mii_bus * mdio,struct device_node * np)125 int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
126 {
127 struct device_node *child;
128 const __be32 *paddr;
129 bool scanphys = false;
130 int addr, rc, i;
131
132 /* Mask out all PHYs from auto probing. Instead the PHYs listed in
133 * the device tree are populated after the bus has been registered */
134 mdio->phy_mask = ~0;
135
136 /* Clear all the IRQ properties */
137 if (mdio->irq)
138 for (i=0; i<PHY_MAX_ADDR; i++)
139 mdio->irq[i] = PHY_POLL;
140
141 mdio->dev.of_node = np;
142
143 /* Register the MDIO bus */
144 rc = mdiobus_register(mdio);
145 if (rc)
146 return rc;
147
148 /* Loop over the child nodes and register a phy_device for each one */
149 for_each_available_child_of_node(np, child) {
150 addr = of_mdio_parse_addr(&mdio->dev, child);
151 if (addr < 0) {
152 scanphys = true;
153 continue;
154 }
155
156 rc = of_mdiobus_register_phy(mdio, child, addr);
157 if (rc)
158 continue;
159 }
160
161 if (!scanphys)
162 return 0;
163
164 /* auto scan for PHYs with empty reg property */
165 for_each_available_child_of_node(np, child) {
166 /* Skip PHYs with reg property set */
167 paddr = of_get_property(child, "reg", NULL);
168 if (paddr)
169 continue;
170
171 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
172 /* skip already registered PHYs */
173 if (mdio->phy_map[addr])
174 continue;
175
176 /* be noisy to encourage people to set reg property */
177 dev_info(&mdio->dev, "scan phy %s at address %i\n",
178 child->name, addr);
179
180 rc = of_mdiobus_register_phy(mdio, child, addr);
181 if (rc)
182 continue;
183 }
184 }
185
186 return 0;
187 }
188 EXPORT_SYMBOL(of_mdiobus_register);
189
190 /* Helper function for of_phy_find_device */
of_phy_match(struct device * dev,void * phy_np)191 static int of_phy_match(struct device *dev, void *phy_np)
192 {
193 return dev->of_node == phy_np;
194 }
195
196 /**
197 * of_phy_find_device - Give a PHY node, find the phy_device
198 * @phy_np: Pointer to the phy's device tree node
199 *
200 * If successful, returns a pointer to the phy_device with the embedded
201 * struct device refcount incremented by one, or NULL on failure.
202 */
of_phy_find_device(struct device_node * phy_np)203 struct phy_device *of_phy_find_device(struct device_node *phy_np)
204 {
205 struct device *d;
206 if (!phy_np)
207 return NULL;
208
209 d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
210 return d ? to_phy_device(d) : NULL;
211 }
212 EXPORT_SYMBOL(of_phy_find_device);
213
214 /**
215 * of_phy_connect - Connect to the phy described in the device tree
216 * @dev: pointer to net_device claiming the phy
217 * @phy_np: Pointer to device tree node for the PHY
218 * @hndlr: Link state callback for the network device
219 * @iface: PHY data interface type
220 *
221 * If successful, returns a pointer to the phy_device with the embedded
222 * struct device refcount incremented by one, or NULL on failure. The
223 * refcount must be dropped by calling phy_disconnect() or phy_detach().
224 */
of_phy_connect(struct net_device * dev,struct device_node * phy_np,void (* hndlr)(struct net_device *),u32 flags,phy_interface_t iface)225 struct phy_device *of_phy_connect(struct net_device *dev,
226 struct device_node *phy_np,
227 void (*hndlr)(struct net_device *), u32 flags,
228 phy_interface_t iface)
229 {
230 struct phy_device *phy = of_phy_find_device(phy_np);
231 int ret;
232
233 if (!phy)
234 return NULL;
235
236 phy->dev_flags = flags;
237
238 ret = phy_connect_direct(dev, phy, hndlr, iface);
239
240 /* refcount is held by phy_connect_direct() on success */
241 put_device(&phy->dev);
242
243 return ret ? NULL : phy;
244 }
245 EXPORT_SYMBOL(of_phy_connect);
246
247 /**
248 * of_phy_attach - Attach to a PHY without starting the state machine
249 * @dev: pointer to net_device claiming the phy
250 * @phy_np: Node pointer for the PHY
251 * @flags: flags to pass to the PHY
252 * @iface: PHY data interface type
253 *
254 * If successful, returns a pointer to the phy_device with the embedded
255 * struct device refcount incremented by one, or NULL on failure. The
256 * refcount must be dropped by calling phy_disconnect() or phy_detach().
257 */
of_phy_attach(struct net_device * dev,struct device_node * phy_np,u32 flags,phy_interface_t iface)258 struct phy_device *of_phy_attach(struct net_device *dev,
259 struct device_node *phy_np, u32 flags,
260 phy_interface_t iface)
261 {
262 struct phy_device *phy = of_phy_find_device(phy_np);
263 int ret;
264
265 if (!phy)
266 return NULL;
267
268 ret = phy_attach_direct(dev, phy, flags, iface);
269
270 /* refcount is held by phy_attach_direct() on success */
271 put_device(&phy->dev);
272
273 return ret ? NULL : phy;
274 }
275 EXPORT_SYMBOL(of_phy_attach);
276
277 #if defined(CONFIG_FIXED_PHY)
278 /*
279 * of_phy_is_fixed_link() and of_phy_register_fixed_link() must
280 * support two DT bindings:
281 * - the old DT binding, where 'fixed-link' was a property with 5
282 * cells encoding various informations about the fixed PHY
283 * - the new DT binding, where 'fixed-link' is a sub-node of the
284 * Ethernet device.
285 */
of_phy_is_fixed_link(struct device_node * np)286 bool of_phy_is_fixed_link(struct device_node *np)
287 {
288 struct device_node *dn;
289 int len, err;
290 const char *managed;
291
292 /* New binding */
293 dn = of_get_child_by_name(np, "fixed-link");
294 if (dn) {
295 of_node_put(dn);
296 return true;
297 }
298
299 err = of_property_read_string(np, "managed", &managed);
300 if (err == 0 && strcmp(managed, "auto") != 0)
301 return true;
302
303 /* Old binding */
304 if (of_get_property(np, "fixed-link", &len) &&
305 len == (5 * sizeof(__be32)))
306 return true;
307
308 return false;
309 }
310 EXPORT_SYMBOL(of_phy_is_fixed_link);
311
of_phy_register_fixed_link(struct device_node * np)312 int of_phy_register_fixed_link(struct device_node *np)
313 {
314 struct fixed_phy_status status = {};
315 struct device_node *fixed_link_node;
316 const __be32 *fixed_link_prop;
317 int link_gpio;
318 int len, err;
319 struct phy_device *phy;
320 const char *managed;
321
322 err = of_property_read_string(np, "managed", &managed);
323 if (err == 0) {
324 if (strcmp(managed, "in-band-status") == 0) {
325 /* status is zeroed, namely its .link member */
326 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
327 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
328 }
329 }
330
331 /* New binding */
332 fixed_link_node = of_get_child_by_name(np, "fixed-link");
333 if (fixed_link_node) {
334 status.link = 1;
335 status.duplex = of_property_read_bool(fixed_link_node,
336 "full-duplex");
337 if (of_property_read_u32(fixed_link_node, "speed",
338 &status.speed)) {
339 of_node_put(fixed_link_node);
340 return -EINVAL;
341 }
342 status.pause = of_property_read_bool(fixed_link_node, "pause");
343 status.asym_pause = of_property_read_bool(fixed_link_node,
344 "asym-pause");
345 link_gpio = of_get_named_gpio_flags(fixed_link_node,
346 "link-gpios", 0, NULL);
347 of_node_put(fixed_link_node);
348 if (link_gpio == -EPROBE_DEFER)
349 return -EPROBE_DEFER;
350
351 phy = fixed_phy_register(PHY_POLL, &status, link_gpio, np);
352 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
353 }
354
355 /* Old binding */
356 fixed_link_prop = of_get_property(np, "fixed-link", &len);
357 if (fixed_link_prop && len == (5 * sizeof(__be32))) {
358 status.link = 1;
359 status.duplex = be32_to_cpu(fixed_link_prop[1]);
360 status.speed = be32_to_cpu(fixed_link_prop[2]);
361 status.pause = be32_to_cpu(fixed_link_prop[3]);
362 status.asym_pause = be32_to_cpu(fixed_link_prop[4]);
363 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
364 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
365 }
366
367 return -ENODEV;
368 }
369 EXPORT_SYMBOL(of_phy_register_fixed_link);
370 #endif
371