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