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/module.h>
23
24MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
25MODULE_LICENSE("GPL");
26
27
28
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
44static 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
76
77 of_node_get(child);
78 phy->dev.of_node = child;
79
80
81
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
95int 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
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}
115EXPORT_SYMBOL(of_mdio_parse_addr);
116
117
118
119
120
121
122
123
124
125int 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
133
134 mdio->phy_mask = ~0;
135
136
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
144 rc = mdiobus_register(mdio);
145 if (rc)
146 return rc;
147
148
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
165 for_each_available_child_of_node(np, child) {
166
167 paddr = of_get_property(child, "reg", NULL);
168 if (paddr)
169 continue;
170
171 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
172
173 if (mdio->phy_map[addr])
174 continue;
175
176
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}
188EXPORT_SYMBOL(of_mdiobus_register);
189
190
191static int of_phy_match(struct device *dev, void *phy_np)
192{
193 return dev->of_node == phy_np;
194}
195
196
197
198
199
200
201
202
203struct 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}
212EXPORT_SYMBOL(of_phy_find_device);
213
214
215
216
217
218
219
220
221
222
223
224
225struct 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
241 put_device(&phy->dev);
242
243 return ret ? NULL : phy;
244}
245EXPORT_SYMBOL(of_phy_connect);
246
247
248
249
250
251
252
253
254
255
256
257
258struct 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
271 put_device(&phy->dev);
272
273 return ret ? NULL : phy;
274}
275EXPORT_SYMBOL(of_phy_attach);
276
277#if defined(CONFIG_FIXED_PHY)
278
279
280
281
282
283
284
285
286bool 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
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
304 if (of_get_property(np, "fixed-link", &len) &&
305 len == (5 * sizeof(__be32)))
306 return true;
307
308 return false;
309}
310EXPORT_SYMBOL(of_phy_is_fixed_link);
311
312int 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
326 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
327 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
328 }
329 }
330
331
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", &status.speed))
338 return -EINVAL;
339 status.pause = of_property_read_bool(fixed_link_node, "pause");
340 status.asym_pause = of_property_read_bool(fixed_link_node,
341 "asym-pause");
342 link_gpio = of_get_named_gpio_flags(fixed_link_node,
343 "link-gpios", 0, NULL);
344 of_node_put(fixed_link_node);
345 if (link_gpio == -EPROBE_DEFER)
346 return -EPROBE_DEFER;
347
348 phy = fixed_phy_register(PHY_POLL, &status, link_gpio, np);
349 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
350 }
351
352
353 fixed_link_prop = of_get_property(np, "fixed-link", &len);
354 if (fixed_link_prop && len == (5 * sizeof(__be32))) {
355 status.link = 1;
356 status.duplex = be32_to_cpu(fixed_link_prop[1]);
357 status.speed = be32_to_cpu(fixed_link_prop[2]);
358 status.pause = be32_to_cpu(fixed_link_prop[3]);
359 status.asym_pause = be32_to_cpu(fixed_link_prop[4]);
360 phy = fixed_phy_register(PHY_POLL, &status, -1, np);
361 return IS_ERR(phy) ? PTR_ERR(phy) : 0;
362 }
363
364 return -ENODEV;
365}
366EXPORT_SYMBOL(of_phy_register_fixed_link);
367#endif
368