of_mdio.c 13.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/*
 * OF helpers for the MDIO (Ethernet PHY) API
 *
 * Copyright (c) 2009 Secret Lab Technologies, Ltd.
 *
 * This file is released under the GPLv2
 *
 * This file provides helper functions for extracting PHY device information
 * out of the OpenFirmware device tree and using it to populate an mii_bus.
 */

12
13
14
15
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/netdevice.h>
#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
24
#include <linux/module.h>

25
26
#define DEFAULT_GPIO_RESET_DELAY	10	/* in microseconds */

27
28
29
MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
MODULE_LICENSE("GPL");

30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/* Extract the clause 22 phy ID from the compatible string of the form
 * ethernet-phy-idAAAA.BBBB */
static int of_get_phy_id(struct device_node *device, u32 *phy_id)
{
	struct property *prop;
	const char *cp;
	unsigned int upper, lower;

	of_property_for_each_string(device, "compatible", prop, cp) {
		if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) == 2) {
			*phy_id = ((upper & 0xFFFF) << 16) | (lower & 0xFFFF);
			return 0;
		}
	}
	return -EINVAL;
}

47
48
static void of_mdiobus_register_phy(struct mii_bus *mdio,
				    struct device_node *child, u32 addr)
49
50
51
{
	struct phy_device *phy;
	bool is_c45;
Ben Dooks's avatar
Ben Dooks committed
52
	int rc;
53
	u32 phy_id;
54
55
56
57

	is_c45 = of_device_is_compatible(child,
					 "ethernet-phy-ieee802.3-c45");

58
59
60
61
	if (!is_c45 && !of_get_phy_id(child, &phy_id))
		phy = phy_device_create(mdio, addr, phy_id, 0, NULL);
	else
		phy = get_phy_device(mdio, addr, is_c45);
62
	if (IS_ERR(phy))
63
		return;
64

Ben Dooks's avatar
Ben Dooks committed
65
66
67
	rc = irq_of_parse_and_map(child, 0);
	if (rc > 0) {
		phy->irq = rc;
68
		mdio->irq[addr] = rc;
Ben Dooks's avatar
Ben Dooks committed
69
	} else {
70
		phy->irq = mdio->irq[addr];
71
72
	}

73
74
75
	if (of_property_read_bool(child, "broken-turn-around"))
		mdio->phy_ignore_ta_mask |= 1 << addr;

76
77
78
	/* Associate the OF node with the device structure so it
	 * can be looked up later */
	of_node_get(child);
79
	phy->mdio.dev.of_node = child;
80
81
82
83
84
85
86

	/* All data is now stored in the phy struct;
	 * register it */
	rc = phy_device_register(phy);
	if (rc) {
		phy_device_free(phy);
		of_node_put(child);
87
		return;
88
89
90
	}

	dev_dbg(&mdio->dev, "registered phy %s at address %i\n",
91
		child->name, addr);
92
93
}

94
95
static void of_mdiobus_register_device(struct mii_bus *mdio,
				       struct device_node *child, u32 addr)
96
97
98
99
100
{
	struct mdio_device *mdiodev;
	int rc;

	mdiodev = mdio_device_create(mdio, addr);
101
	if (IS_ERR(mdiodev))
102
		return;
103
104
105
106
107
108
109
110
111
112
113
114

	/* Associate the OF node with the device structure so it
	 * can be looked up later.
	 */
	of_node_get(child);
	mdiodev->dev.of_node = child;

	/* All data is now stored in the mdiodev struct; register it. */
	rc = mdio_device_register(mdiodev);
	if (rc) {
		mdio_device_free(mdiodev);
		of_node_put(child);
115
		return;
116
117
118
119
120
121
	}

	dev_dbg(&mdio->dev, "registered mdio device %s at address %i\n",
		child->name, addr);
}

122
int of_mdio_parse_addr(struct device *dev, const struct device_node *np)
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
{
	u32 addr;
	int ret;

	ret = of_property_read_u32(np, "reg", &addr);
	if (ret < 0) {
		dev_err(dev, "%s has invalid PHY address\n", np->full_name);
		return ret;
	}

	/* A PHY must have a reg property in the range [0-31] */
	if (addr >= PHY_MAX_ADDR) {
		dev_err(dev, "%s PHY address %i is too large\n",
			np->full_name, addr);
		return -EINVAL;
	}

	return addr;
}
142
EXPORT_SYMBOL(of_mdio_parse_addr);
143

144
145
146
147
148
149
150
151
/* The following is a list of PHY compatible strings which appear in
 * some DTBs. The compatible string is never matched against a PHY
 * driver, so is pointless. We only expect devices which are not PHYs
 * to have a compatible string, so they can be matched to an MDIO
 * driver.  Encourage users to upgrade their DT blobs to remove these.
 */
static const struct of_device_id whitelist_phys[] = {
	{ .compatible = "brcm,40nm-ephy" },
152
	{ .compatible = "broadcom,bcm5241" },
153
154
155
	{ .compatible = "marvell,88E1111", },
	{ .compatible = "marvell,88e1116", },
	{ .compatible = "marvell,88e1118", },
156
	{ .compatible = "marvell,88e1145", },
157
158
159
160
161
162
163
164
	{ .compatible = "marvell,88e1149r", },
	{ .compatible = "marvell,88e1310", },
	{ .compatible = "marvell,88E1510", },
	{ .compatible = "marvell,88E1514", },
	{ .compatible = "moxa,moxart-rtl8201cp", },
	{}
};

165
166
167
168
169
/*
 * Return true if the child node is for a phy. It must either:
 * o Compatible string of "ethernet-phy-idX.X"
 * o Compatible string of "ethernet-phy-ieee802.3-c45"
 * o Compatible string of "ethernet-phy-ieee802.3-c22"
170
 * o In the white list above (and issue a warning)
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 * o No compatibility string
 *
 * A device which is not a phy is expected to have a compatible string
 * indicating what sort of device it is.
 */
static bool of_mdiobus_child_is_phy(struct device_node *child)
{
	u32 phy_id;

	if (of_get_phy_id(child, &phy_id) != -EINVAL)
		return true;

	if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c45"))
		return true;

	if (of_device_is_compatible(child, "ethernet-phy-ieee802.3-c22"))
		return true;

189
190
191
192
193
194
195
	if (of_match_node(whitelist_phys, child)) {
		pr_warn(FW_WARN
			"%s: Whitelisted compatible string. Please remove\n",
			child->full_name);
		return true;
	}

196
197
198
199
200
201
	if (!of_find_property(child, "compatible", NULL))
		return true;

	return false;
}

202
203
204
205
206
207
208
209
210
211
212
/**
 * of_mdiobus_register - Register mii_bus and create PHYs from the device tree
 * @mdio: pointer to mii_bus structure
 * @np: pointer to device_node of MDIO bus.
 *
 * This function registers the mii_bus structure and registers a phy_device
 * for each child node of @np.
 */
int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
{
	struct device_node *child;
213
	bool scanphys = false;
214
	int addr, rc;
215

216
217
218
219
	/* Do not continue if the node is disabled */
	if (!of_device_is_available(np))
		return -ENODEV;

220
221
222
223
	/* Mask out all PHYs from auto probing.  Instead the PHYs listed in
	 * the device tree are populated after the bus has been registered */
	mdio->phy_mask = ~0;

224
225
	mdio->dev.of_node = np;

226
227
228
229
230
	/* Get bus level PHY reset GPIO details */
	mdio->reset_delay_us = DEFAULT_GPIO_RESET_DELAY;
	of_property_read_u32(np, "reset-delay-us", &mdio->reset_delay_us);
	mdio->num_reset_gpios = of_gpio_named_count(np, "reset-gpios");

231
232
233
234
235
	/* Register the MDIO bus */
	rc = mdiobus_register(mdio);
	if (rc)
		return rc;

236
	/* Loop over the child nodes and register a phy_device for each phy */
237
	for_each_available_child_of_node(np, child) {
238
239
		addr = of_mdio_parse_addr(&mdio->dev, child);
		if (addr < 0) {
240
			scanphys = true;
241
242
243
			continue;
		}

244
245
		if (of_mdiobus_child_is_phy(child))
			of_mdiobus_register_phy(mdio, child, addr);
246
247
		else
			of_mdiobus_register_device(mdio, child, addr);
248
249
	}

250
251
252
253
254
255
	if (!scanphys)
		return 0;

	/* auto scan for PHYs with empty reg property */
	for_each_available_child_of_node(np, child) {
		/* Skip PHYs with reg property set */
256
		if (of_find_property(child, "reg", NULL))
257
258
259
260
			continue;

		for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
			/* skip already registered PHYs */
261
			if (mdiobus_is_registered_device(mdio, addr))
262
263
264
265
266
267
				continue;

			/* be noisy to encourage people to set reg property */
			dev_info(&mdio->dev, "scan phy %s at address %i\n",
				 child->name, addr);

268
269
			if (of_mdiobus_child_is_phy(child))
				of_mdiobus_register_phy(mdio, child, addr);
270
271
272
		}
	}

273
274
275
276
	return 0;
}
EXPORT_SYMBOL(of_mdiobus_register);

Jérôme Pouiller's avatar
Jérôme Pouiller committed
277
278
279
/* Helper function for of_phy_find_device */
static int of_phy_match(struct device *dev, void *phy_np)
{
280
	return dev->of_node == phy_np;
Jérôme Pouiller's avatar
Jérôme Pouiller committed
281
282
}

283
284
285
286
/**
 * of_phy_find_device - Give a PHY node, find the phy_device
 * @phy_np: Pointer to the phy's device tree node
 *
287
288
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure.
289
290
291
292
 */
struct phy_device *of_phy_find_device(struct device_node *phy_np)
{
	struct device *d;
293
294
	struct mdio_device *mdiodev;

295
296
297
	if (!phy_np)
		return NULL;

Jérôme Pouiller's avatar
Jérôme Pouiller committed
298
	d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
299
300
301
302
	if (d) {
		mdiodev = to_mdio_device(d);
		if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
			return to_phy_device(d);
303
		put_device(d);
304
305
306
	}

	return NULL;
307
308
309
310
311
312
313
314
}
EXPORT_SYMBOL(of_phy_find_device);

/**
 * of_phy_connect - Connect to the phy described in the device tree
 * @dev: pointer to net_device claiming the phy
 * @phy_np: Pointer to device tree node for the PHY
 * @hndlr: Link state callback for the network device
315
 * @flags: flags to pass to the PHY
316
317
 * @iface: PHY data interface type
 *
318
319
320
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure. The
 * refcount must be dropped by calling phy_disconnect() or phy_detach().
321
322
323
324
325
326
327
 */
struct phy_device *of_phy_connect(struct net_device *dev,
				  struct device_node *phy_np,
				  void (*hndlr)(struct net_device *), u32 flags,
				  phy_interface_t iface)
{
	struct phy_device *phy = of_phy_find_device(phy_np);
328
	int ret;
329
330
331
332

	if (!phy)
		return NULL;

333
334
	phy->dev_flags = flags;

335
336
337
	ret = phy_connect_direct(dev, phy, hndlr, iface);

	/* refcount is held by phy_connect_direct() on success */
338
	put_device(&phy->mdio.dev);
339
340

	return ret ? NULL : phy;
341
342
}
EXPORT_SYMBOL(of_phy_connect);
343

344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
/**
 * of_phy_get_and_connect
 * - Get phy node and connect to the phy described in the device tree
 * @dev: pointer to net_device claiming the phy
 * @np: Pointer to device tree node for the net_device claiming the phy
 * @hndlr: Link state callback for the network device
 *
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure. The
 * refcount must be dropped by calling phy_disconnect() or phy_detach().
 */
struct phy_device *of_phy_get_and_connect(struct net_device *dev,
					  struct device_node *np,
					  void (*hndlr)(struct net_device *))
{
	phy_interface_t iface;
	struct device_node *phy_np;
	struct phy_device *phy;

	iface = of_get_phy_mode(np);
	if (iface < 0)
		return NULL;

	phy_np = of_parse_phandle(np, "phy-handle", 0);
	if (!phy_np)
		return NULL;

	phy = of_phy_connect(dev, phy_np, hndlr, 0, iface);

	of_node_put(phy_np);

	return phy;
}
EXPORT_SYMBOL(of_phy_get_and_connect);

Andy Fleming's avatar
Andy Fleming committed
379
380
381
382
383
384
/**
 * of_phy_attach - Attach to a PHY without starting the state machine
 * @dev: pointer to net_device claiming the phy
 * @phy_np: Node pointer for the PHY
 * @flags: flags to pass to the PHY
 * @iface: PHY data interface type
385
386
387
388
 *
 * If successful, returns a pointer to the phy_device with the embedded
 * struct device refcount incremented by one, or NULL on failure. The
 * refcount must be dropped by calling phy_disconnect() or phy_detach().
Andy Fleming's avatar
Andy Fleming committed
389
390
391
392
393
394
 */
struct phy_device *of_phy_attach(struct net_device *dev,
				 struct device_node *phy_np, u32 flags,
				 phy_interface_t iface)
{
	struct phy_device *phy = of_phy_find_device(phy_np);
395
	int ret;
Andy Fleming's avatar
Andy Fleming committed
396
397
398
399

	if (!phy)
		return NULL;

400
401
402
	ret = phy_attach_direct(dev, phy, flags, iface);

	/* refcount is held by phy_attach_direct() on success */
403
	put_device(&phy->mdio.dev);
404
405

	return ret ? NULL : phy;
Andy Fleming's avatar
Andy Fleming committed
406
407
}
EXPORT_SYMBOL(of_phy_attach);
408
409
410
411
412
413
414
415
416
417
418
419

/*
 * of_phy_is_fixed_link() and of_phy_register_fixed_link() must
 * support two DT bindings:
 * - the old DT binding, where 'fixed-link' was a property with 5
 *   cells encoding various informations about the fixed PHY
 * - the new DT binding, where 'fixed-link' is a sub-node of the
 *   Ethernet device.
 */
bool of_phy_is_fixed_link(struct device_node *np)
{
	struct device_node *dn;
420
421
	int len, err;
	const char *managed;
422
423
424
425
426
427
428
429

	/* New binding */
	dn = of_get_child_by_name(np, "fixed-link");
	if (dn) {
		of_node_put(dn);
		return true;
	}

430
431
432
433
	err = of_property_read_string(np, "managed", &managed);
	if (err == 0 && strcmp(managed, "auto") != 0)
		return true;

434
435
436
437
438
439
440
441
442
443
444
445
446
447
	/* Old binding */
	if (of_get_property(np, "fixed-link", &len) &&
	    len == (5 * sizeof(__be32)))
		return true;

	return false;
}
EXPORT_SYMBOL(of_phy_is_fixed_link);

int of_phy_register_fixed_link(struct device_node *np)
{
	struct fixed_phy_status status = {};
	struct device_node *fixed_link_node;
	const __be32 *fixed_link_prop;
448
	int link_gpio;
449
	int len, err;
450
	struct phy_device *phy;
451
452
453
454
455
456
	const char *managed;

	err = of_property_read_string(np, "managed", &managed);
	if (err == 0) {
		if (strcmp(managed, "in-band-status") == 0) {
			/* status is zeroed, namely its .link member */
457
			phy = fixed_phy_register(PHY_POLL, &status, -1, np);
458
			return PTR_ERR_OR_ZERO(phy);
459
460
		}
	}
461
462
463
464
465

	/* New binding */
	fixed_link_node = of_get_child_by_name(np, "fixed-link");
	if (fixed_link_node) {
		status.link = 1;
466
467
		status.duplex = of_property_read_bool(fixed_link_node,
						      "full-duplex");
468
469
470
		if (of_property_read_u32(fixed_link_node, "speed",
					 &status.speed)) {
			of_node_put(fixed_link_node);
471
			return -EINVAL;
472
		}
473
474
475
		status.pause = of_property_read_bool(fixed_link_node, "pause");
		status.asym_pause = of_property_read_bool(fixed_link_node,
							  "asym-pause");
476
477
		link_gpio = of_get_named_gpio_flags(fixed_link_node,
						    "link-gpios", 0, NULL);
478
		of_node_put(fixed_link_node);
479
480
481
482
		if (link_gpio == -EPROBE_DEFER)
			return -EPROBE_DEFER;

		phy = fixed_phy_register(PHY_POLL, &status, link_gpio, np);
483
		return PTR_ERR_OR_ZERO(phy);
484
485
486
487
488
489
490
491
492
493
	}

	/* Old binding */
	fixed_link_prop = of_get_property(np, "fixed-link", &len);
	if (fixed_link_prop && len == (5 * sizeof(__be32))) {
		status.link = 1;
		status.duplex = be32_to_cpu(fixed_link_prop[1]);
		status.speed = be32_to_cpu(fixed_link_prop[2]);
		status.pause = be32_to_cpu(fixed_link_prop[3]);
		status.asym_pause = be32_to_cpu(fixed_link_prop[4]);
494
		phy = fixed_phy_register(PHY_POLL, &status, -1, np);
495
		return PTR_ERR_OR_ZERO(phy);
496
497
498
499
500
	}

	return -ENODEV;
}
EXPORT_SYMBOL(of_phy_register_fixed_link);
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515

void of_phy_deregister_fixed_link(struct device_node *np)
{
	struct phy_device *phydev;

	phydev = of_phy_find_device(np);
	if (!phydev)
		return;

	fixed_phy_unregister(phydev);

	put_device(&phydev->mdio.dev);	/* of_phy_find_device() */
	phy_device_free(phydev);	/* fixed_phy_register() */
}
EXPORT_SYMBOL(of_phy_deregister_fixed_link);