xref: /openbmc/linux/drivers/net/phy/phy_device.c (revision b732539e)
1 /* Framework for finding and configuring PHYs.
2  * Also contains generic PHY driver
3  *
4  * Author: Andy Fleming
5  *
6  * Copyright (c) 2004 Freescale Semiconductor, Inc.
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under  the terms of  the GNU General  Public License as published by the
10  * Free Software Foundation;  either version 2 of the  License, or (at your
11  * option) any later version.
12  *
13  */
14 
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/errno.h>
20 #include <linux/unistd.h>
21 #include <linux/slab.h>
22 #include <linux/interrupt.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/skbuff.h>
28 #include <linux/mm.h>
29 #include <linux/module.h>
30 #include <linux/mii.h>
31 #include <linux/ethtool.h>
32 #include <linux/phy.h>
33 #include <linux/phy_led_triggers.h>
34 #include <linux/mdio.h>
35 #include <linux/io.h>
36 #include <linux/uaccess.h>
37 #include <linux/of.h>
38 
39 #include <asm/irq.h>
40 
41 MODULE_DESCRIPTION("PHY library");
42 MODULE_AUTHOR("Andy Fleming");
43 MODULE_LICENSE("GPL");
44 
45 void phy_device_free(struct phy_device *phydev)
46 {
47 	put_device(&phydev->mdio.dev);
48 }
49 EXPORT_SYMBOL(phy_device_free);
50 
51 static void phy_mdio_device_free(struct mdio_device *mdiodev)
52 {
53 	struct phy_device *phydev;
54 
55 	phydev = container_of(mdiodev, struct phy_device, mdio);
56 	phy_device_free(phydev);
57 }
58 
59 static void phy_device_release(struct device *dev)
60 {
61 	kfree(to_phy_device(dev));
62 }
63 
64 static void phy_mdio_device_remove(struct mdio_device *mdiodev)
65 {
66 	struct phy_device *phydev;
67 
68 	phydev = container_of(mdiodev, struct phy_device, mdio);
69 	phy_device_remove(phydev);
70 }
71 
72 static struct phy_driver genphy_driver;
73 extern struct phy_driver genphy_10g_driver;
74 
75 static LIST_HEAD(phy_fixup_list);
76 static DEFINE_MUTEX(phy_fixup_lock);
77 
78 #ifdef CONFIG_PM
79 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
80 {
81 	struct device_driver *drv = phydev->mdio.dev.driver;
82 	struct phy_driver *phydrv = to_phy_driver(drv);
83 	struct net_device *netdev = phydev->attached_dev;
84 
85 	if (!drv || !phydrv->suspend)
86 		return false;
87 
88 	/* PHY not attached? May suspend if the PHY has not already been
89 	 * suspended as part of a prior call to phy_disconnect() ->
90 	 * phy_detach() -> phy_suspend() because the parent netdev might be the
91 	 * MDIO bus driver and clock gated at this point.
92 	 */
93 	if (!netdev)
94 		return !phydev->suspended;
95 
96 	/* Don't suspend PHY if the attached netdev parent may wakeup.
97 	 * The parent may point to a PCI device, as in tg3 driver.
98 	 */
99 	if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
100 		return false;
101 
102 	/* Also don't suspend PHY if the netdev itself may wakeup. This
103 	 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
104 	 * e.g. SoC devices.
105 	 */
106 	if (device_may_wakeup(&netdev->dev))
107 		return false;
108 
109 	return true;
110 }
111 
112 static int mdio_bus_phy_suspend(struct device *dev)
113 {
114 	struct phy_device *phydev = to_phy_device(dev);
115 
116 	/* We must stop the state machine manually, otherwise it stops out of
117 	 * control, possibly with the phydev->lock held. Upon resume, netdev
118 	 * may call phy routines that try to grab the same lock, and that may
119 	 * lead to a deadlock.
120 	 */
121 	if (phydev->attached_dev && phydev->adjust_link)
122 		phy_stop_machine(phydev);
123 
124 	if (!mdio_bus_phy_may_suspend(phydev))
125 		return 0;
126 
127 	return phy_suspend(phydev);
128 }
129 
130 static int mdio_bus_phy_resume(struct device *dev)
131 {
132 	struct phy_device *phydev = to_phy_device(dev);
133 	int ret;
134 
135 	if (!mdio_bus_phy_may_suspend(phydev))
136 		goto no_resume;
137 
138 	ret = phy_resume(phydev);
139 	if (ret < 0)
140 		return ret;
141 
142 no_resume:
143 	if (phydev->attached_dev && phydev->adjust_link)
144 		phy_start_machine(phydev);
145 
146 	return 0;
147 }
148 
149 static int mdio_bus_phy_restore(struct device *dev)
150 {
151 	struct phy_device *phydev = to_phy_device(dev);
152 	struct net_device *netdev = phydev->attached_dev;
153 	int ret;
154 
155 	if (!netdev)
156 		return 0;
157 
158 	ret = phy_init_hw(phydev);
159 	if (ret < 0)
160 		return ret;
161 
162 	/* The PHY needs to renegotiate. */
163 	phydev->link = 0;
164 	phydev->state = PHY_UP;
165 
166 	phy_start_machine(phydev);
167 
168 	return 0;
169 }
170 
171 static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
172 	.suspend = mdio_bus_phy_suspend,
173 	.resume = mdio_bus_phy_resume,
174 	.freeze = mdio_bus_phy_suspend,
175 	.thaw = mdio_bus_phy_resume,
176 	.restore = mdio_bus_phy_restore,
177 };
178 
179 #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
180 
181 #else
182 
183 #define MDIO_BUS_PHY_PM_OPS NULL
184 
185 #endif /* CONFIG_PM */
186 
187 /**
188  * phy_register_fixup - creates a new phy_fixup and adds it to the list
189  * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
190  * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
191  *	It can also be PHY_ANY_UID
192  * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
193  *	comparison
194  * @run: The actual code to be run when a matching PHY is found
195  */
196 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
197 		       int (*run)(struct phy_device *))
198 {
199 	struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
200 
201 	if (!fixup)
202 		return -ENOMEM;
203 
204 	strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
205 	fixup->phy_uid = phy_uid;
206 	fixup->phy_uid_mask = phy_uid_mask;
207 	fixup->run = run;
208 
209 	mutex_lock(&phy_fixup_lock);
210 	list_add_tail(&fixup->list, &phy_fixup_list);
211 	mutex_unlock(&phy_fixup_lock);
212 
213 	return 0;
214 }
215 EXPORT_SYMBOL(phy_register_fixup);
216 
217 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
218 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
219 			       int (*run)(struct phy_device *))
220 {
221 	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
222 }
223 EXPORT_SYMBOL(phy_register_fixup_for_uid);
224 
225 /* Registers a fixup to be run on the PHY with id string bus_id */
226 int phy_register_fixup_for_id(const char *bus_id,
227 			      int (*run)(struct phy_device *))
228 {
229 	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
230 }
231 EXPORT_SYMBOL(phy_register_fixup_for_id);
232 
233 /**
234  * phy_unregister_fixup - remove a phy_fixup from the list
235  * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
236  * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
237  * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
238  */
239 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
240 {
241 	struct list_head *pos, *n;
242 	struct phy_fixup *fixup;
243 	int ret;
244 
245 	ret = -ENODEV;
246 
247 	mutex_lock(&phy_fixup_lock);
248 	list_for_each_safe(pos, n, &phy_fixup_list) {
249 		fixup = list_entry(pos, struct phy_fixup, list);
250 
251 		if ((!strcmp(fixup->bus_id, bus_id)) &&
252 		    ((fixup->phy_uid & phy_uid_mask) ==
253 		     (phy_uid & phy_uid_mask))) {
254 			list_del(&fixup->list);
255 			kfree(fixup);
256 			ret = 0;
257 			break;
258 		}
259 	}
260 	mutex_unlock(&phy_fixup_lock);
261 
262 	return ret;
263 }
264 EXPORT_SYMBOL(phy_unregister_fixup);
265 
266 /* Unregisters a fixup of any PHY with the UID in phy_uid */
267 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
268 {
269 	return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
270 }
271 EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
272 
273 /* Unregisters a fixup of the PHY with id string bus_id */
274 int phy_unregister_fixup_for_id(const char *bus_id)
275 {
276 	return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
277 }
278 EXPORT_SYMBOL(phy_unregister_fixup_for_id);
279 
280 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
281  * Fixups can be set to match any in one or more fields.
282  */
283 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
284 {
285 	if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
286 		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
287 			return 0;
288 
289 	if ((fixup->phy_uid & fixup->phy_uid_mask) !=
290 	    (phydev->phy_id & fixup->phy_uid_mask))
291 		if (fixup->phy_uid != PHY_ANY_UID)
292 			return 0;
293 
294 	return 1;
295 }
296 
297 /* Runs any matching fixups for this phydev */
298 static int phy_scan_fixups(struct phy_device *phydev)
299 {
300 	struct phy_fixup *fixup;
301 
302 	mutex_lock(&phy_fixup_lock);
303 	list_for_each_entry(fixup, &phy_fixup_list, list) {
304 		if (phy_needs_fixup(phydev, fixup)) {
305 			int err = fixup->run(phydev);
306 
307 			if (err < 0) {
308 				mutex_unlock(&phy_fixup_lock);
309 				return err;
310 			}
311 			phydev->has_fixups = true;
312 		}
313 	}
314 	mutex_unlock(&phy_fixup_lock);
315 
316 	return 0;
317 }
318 
319 static int phy_bus_match(struct device *dev, struct device_driver *drv)
320 {
321 	struct phy_device *phydev = to_phy_device(dev);
322 	struct phy_driver *phydrv = to_phy_driver(drv);
323 	const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
324 	int i;
325 
326 	if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
327 		return 0;
328 
329 	if (phydrv->match_phy_device)
330 		return phydrv->match_phy_device(phydev);
331 
332 	if (phydev->is_c45) {
333 		for (i = 1; i < num_ids; i++) {
334 			if (!(phydev->c45_ids.devices_in_package & (1 << i)))
335 				continue;
336 
337 			if ((phydrv->phy_id & phydrv->phy_id_mask) ==
338 			    (phydev->c45_ids.device_ids[i] &
339 			     phydrv->phy_id_mask))
340 				return 1;
341 		}
342 		return 0;
343 	} else {
344 		return (phydrv->phy_id & phydrv->phy_id_mask) ==
345 			(phydev->phy_id & phydrv->phy_id_mask);
346 	}
347 }
348 
349 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
350 				     bool is_c45,
351 				     struct phy_c45_device_ids *c45_ids)
352 {
353 	struct phy_device *dev;
354 	struct mdio_device *mdiodev;
355 
356 	/* We allocate the device, and initialize the default values */
357 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
358 	if (!dev)
359 		return ERR_PTR(-ENOMEM);
360 
361 	mdiodev = &dev->mdio;
362 	mdiodev->dev.release = phy_device_release;
363 	mdiodev->dev.parent = &bus->dev;
364 	mdiodev->dev.bus = &mdio_bus_type;
365 	mdiodev->bus = bus;
366 	mdiodev->pm_ops = MDIO_BUS_PHY_PM_OPS;
367 	mdiodev->bus_match = phy_bus_match;
368 	mdiodev->addr = addr;
369 	mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
370 	mdiodev->device_free = phy_mdio_device_free;
371 	mdiodev->device_remove = phy_mdio_device_remove;
372 
373 	dev->speed = 0;
374 	dev->duplex = -1;
375 	dev->pause = 0;
376 	dev->asym_pause = 0;
377 	dev->link = 0;
378 	dev->interface = PHY_INTERFACE_MODE_GMII;
379 
380 	dev->autoneg = AUTONEG_ENABLE;
381 
382 	dev->is_c45 = is_c45;
383 	dev->phy_id = phy_id;
384 	if (c45_ids)
385 		dev->c45_ids = *c45_ids;
386 	dev->irq = bus->irq[addr];
387 	dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
388 
389 	dev->state = PHY_DOWN;
390 
391 	mutex_init(&dev->lock);
392 	INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
393 	INIT_WORK(&dev->phy_queue, phy_change_work);
394 
395 	/* Request the appropriate module unconditionally; don't
396 	 * bother trying to do so only if it isn't already loaded,
397 	 * because that gets complicated. A hotplug event would have
398 	 * done an unconditional modprobe anyway.
399 	 * We don't do normal hotplug because it won't work for MDIO
400 	 * -- because it relies on the device staying around for long
401 	 * enough for the driver to get loaded. With MDIO, the NIC
402 	 * driver will get bored and give up as soon as it finds that
403 	 * there's no driver _already_ loaded.
404 	 */
405 	request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
406 
407 	device_initialize(&mdiodev->dev);
408 
409 	return dev;
410 }
411 EXPORT_SYMBOL(phy_device_create);
412 
413 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
414  * @bus: the target MII bus
415  * @addr: PHY address on the MII bus
416  * @dev_addr: MMD address in the PHY.
417  * @devices_in_package: where to store the devices in package information.
418  *
419  * Description: reads devices in package registers of a MMD at @dev_addr
420  * from PHY at @addr on @bus.
421  *
422  * Returns: 0 on success, -EIO on failure.
423  */
424 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
425 				   u32 *devices_in_package)
426 {
427 	int phy_reg, reg_addr;
428 
429 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
430 	phy_reg = mdiobus_read(bus, addr, reg_addr);
431 	if (phy_reg < 0)
432 		return -EIO;
433 	*devices_in_package = (phy_reg & 0xffff) << 16;
434 
435 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
436 	phy_reg = mdiobus_read(bus, addr, reg_addr);
437 	if (phy_reg < 0)
438 		return -EIO;
439 	*devices_in_package |= (phy_reg & 0xffff);
440 
441 	return 0;
442 }
443 
444 /**
445  * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
446  * @bus: the target MII bus
447  * @addr: PHY address on the MII bus
448  * @phy_id: where to store the ID retrieved.
449  * @c45_ids: where to store the c45 ID information.
450  *
451  *   If the PHY devices-in-package appears to be valid, it and the
452  *   corresponding identifiers are stored in @c45_ids, zero is stored
453  *   in @phy_id.  Otherwise 0xffffffff is stored in @phy_id.  Returns
454  *   zero on success.
455  *
456  */
457 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
458 			   struct phy_c45_device_ids *c45_ids) {
459 	int phy_reg;
460 	int i, reg_addr;
461 	const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
462 	u32 *devs = &c45_ids->devices_in_package;
463 
464 	/* Find first non-zero Devices In package. Device zero is reserved
465 	 * for 802.3 c45 complied PHYs, so don't probe it at first.
466 	 */
467 	for (i = 1; i < num_ids && *devs == 0; i++) {
468 		phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
469 		if (phy_reg < 0)
470 			return -EIO;
471 
472 		if ((*devs & 0x1fffffff) == 0x1fffffff) {
473 			/*  If mostly Fs, there is no device there,
474 			 *  then let's continue to probe more, as some
475 			 *  10G PHYs have zero Devices In package,
476 			 *  e.g. Cortina CS4315/CS4340 PHY.
477 			 */
478 			phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
479 			if (phy_reg < 0)
480 				return -EIO;
481 			/* no device there, let's get out of here */
482 			if ((*devs & 0x1fffffff) == 0x1fffffff) {
483 				*phy_id = 0xffffffff;
484 				return 0;
485 			} else {
486 				break;
487 			}
488 		}
489 	}
490 
491 	/* Now probe Device Identifiers for each device present. */
492 	for (i = 1; i < num_ids; i++) {
493 		if (!(c45_ids->devices_in_package & (1 << i)))
494 			continue;
495 
496 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
497 		phy_reg = mdiobus_read(bus, addr, reg_addr);
498 		if (phy_reg < 0)
499 			return -EIO;
500 		c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
501 
502 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
503 		phy_reg = mdiobus_read(bus, addr, reg_addr);
504 		if (phy_reg < 0)
505 			return -EIO;
506 		c45_ids->device_ids[i] |= (phy_reg & 0xffff);
507 	}
508 	*phy_id = 0;
509 	return 0;
510 }
511 
512 /**
513  * get_phy_id - reads the specified addr for its ID.
514  * @bus: the target MII bus
515  * @addr: PHY address on the MII bus
516  * @phy_id: where to store the ID retrieved.
517  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
518  * @c45_ids: where to store the c45 ID information.
519  *
520  * Description: In the case of a 802.3-c22 PHY, reads the ID registers
521  *   of the PHY at @addr on the @bus, stores it in @phy_id and returns
522  *   zero on success.
523  *
524  *   In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
525  *   its return value is in turn returned.
526  *
527  */
528 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
529 		      bool is_c45, struct phy_c45_device_ids *c45_ids)
530 {
531 	int phy_reg;
532 
533 	if (is_c45)
534 		return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
535 
536 	/* Grab the bits from PHYIR1, and put them in the upper half */
537 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
538 	if (phy_reg < 0)
539 		return -EIO;
540 
541 	*phy_id = (phy_reg & 0xffff) << 16;
542 
543 	/* Grab the bits from PHYIR2, and put them in the lower half */
544 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
545 	if (phy_reg < 0)
546 		return -EIO;
547 
548 	*phy_id |= (phy_reg & 0xffff);
549 
550 	return 0;
551 }
552 
553 /**
554  * get_phy_device - reads the specified PHY device and returns its @phy_device
555  *		    struct
556  * @bus: the target MII bus
557  * @addr: PHY address on the MII bus
558  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
559  *
560  * Description: Reads the ID registers of the PHY at @addr on the
561  *   @bus, then allocates and returns the phy_device to represent it.
562  */
563 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
564 {
565 	struct phy_c45_device_ids c45_ids = {0};
566 	u32 phy_id = 0;
567 	int r;
568 
569 	r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
570 	if (r)
571 		return ERR_PTR(r);
572 
573 	/* If the phy_id is mostly Fs, there is no device there */
574 	if ((phy_id & 0x1fffffff) == 0x1fffffff)
575 		return ERR_PTR(-ENODEV);
576 
577 	return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
578 }
579 EXPORT_SYMBOL(get_phy_device);
580 
581 static ssize_t
582 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
583 {
584 	struct phy_device *phydev = to_phy_device(dev);
585 
586 	return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
587 }
588 static DEVICE_ATTR_RO(phy_id);
589 
590 static ssize_t
591 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
592 {
593 	struct phy_device *phydev = to_phy_device(dev);
594 	const char *mode = NULL;
595 
596 	if (phy_is_internal(phydev))
597 		mode = "internal";
598 	else
599 		mode = phy_modes(phydev->interface);
600 
601 	return sprintf(buf, "%s\n", mode);
602 }
603 static DEVICE_ATTR_RO(phy_interface);
604 
605 static ssize_t
606 phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
607 		    char *buf)
608 {
609 	struct phy_device *phydev = to_phy_device(dev);
610 
611 	return sprintf(buf, "%d\n", phydev->has_fixups);
612 }
613 static DEVICE_ATTR_RO(phy_has_fixups);
614 
615 static struct attribute *phy_dev_attrs[] = {
616 	&dev_attr_phy_id.attr,
617 	&dev_attr_phy_interface.attr,
618 	&dev_attr_phy_has_fixups.attr,
619 	NULL,
620 };
621 ATTRIBUTE_GROUPS(phy_dev);
622 
623 /**
624  * phy_device_register - Register the phy device on the MDIO bus
625  * @phydev: phy_device structure to be added to the MDIO bus
626  */
627 int phy_device_register(struct phy_device *phydev)
628 {
629 	int err;
630 
631 	err = mdiobus_register_device(&phydev->mdio);
632 	if (err)
633 		return err;
634 
635 	/* Deassert the reset signal */
636 	phy_device_reset(phydev, 0);
637 
638 	/* Run all of the fixups for this PHY */
639 	err = phy_scan_fixups(phydev);
640 	if (err) {
641 		pr_err("PHY %d failed to initialize\n", phydev->mdio.addr);
642 		goto out;
643 	}
644 
645 	phydev->mdio.dev.groups = phy_dev_groups;
646 
647 	err = device_add(&phydev->mdio.dev);
648 	if (err) {
649 		pr_err("PHY %d failed to add\n", phydev->mdio.addr);
650 		goto out;
651 	}
652 
653 	return 0;
654 
655  out:
656 	/* Assert the reset signal */
657 	phy_device_reset(phydev, 1);
658 
659 	mdiobus_unregister_device(&phydev->mdio);
660 	return err;
661 }
662 EXPORT_SYMBOL(phy_device_register);
663 
664 /**
665  * phy_device_remove - Remove a previously registered phy device from the MDIO bus
666  * @phydev: phy_device structure to remove
667  *
668  * This doesn't free the phy_device itself, it merely reverses the effects
669  * of phy_device_register(). Use phy_device_free() to free the device
670  * after calling this function.
671  */
672 void phy_device_remove(struct phy_device *phydev)
673 {
674 	device_del(&phydev->mdio.dev);
675 
676 	/* Assert the reset signal */
677 	phy_device_reset(phydev, 1);
678 
679 	mdiobus_unregister_device(&phydev->mdio);
680 }
681 EXPORT_SYMBOL(phy_device_remove);
682 
683 /**
684  * phy_find_first - finds the first PHY device on the bus
685  * @bus: the target MII bus
686  */
687 struct phy_device *phy_find_first(struct mii_bus *bus)
688 {
689 	struct phy_device *phydev;
690 	int addr;
691 
692 	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
693 		phydev = mdiobus_get_phy(bus, addr);
694 		if (phydev)
695 			return phydev;
696 	}
697 	return NULL;
698 }
699 EXPORT_SYMBOL(phy_find_first);
700 
701 static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
702 {
703 	struct net_device *netdev = phydev->attached_dev;
704 
705 	if (do_carrier) {
706 		if (up)
707 			netif_carrier_on(netdev);
708 		else
709 			netif_carrier_off(netdev);
710 	}
711 	phydev->adjust_link(netdev);
712 }
713 
714 /**
715  * phy_prepare_link - prepares the PHY layer to monitor link status
716  * @phydev: target phy_device struct
717  * @handler: callback function for link status change notifications
718  *
719  * Description: Tells the PHY infrastructure to handle the
720  *   gory details on monitoring link status (whether through
721  *   polling or an interrupt), and to call back to the
722  *   connected device driver when the link status changes.
723  *   If you want to monitor your own link state, don't call
724  *   this function.
725  */
726 static void phy_prepare_link(struct phy_device *phydev,
727 			     void (*handler)(struct net_device *))
728 {
729 	phydev->adjust_link = handler;
730 }
731 
732 /**
733  * phy_connect_direct - connect an ethernet device to a specific phy_device
734  * @dev: the network device to connect
735  * @phydev: the pointer to the phy device
736  * @handler: callback function for state change notifications
737  * @interface: PHY device's interface
738  */
739 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
740 		       void (*handler)(struct net_device *),
741 		       phy_interface_t interface)
742 {
743 	int rc;
744 
745 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
746 	if (rc)
747 		return rc;
748 
749 	phy_prepare_link(phydev, handler);
750 	phy_start_machine(phydev);
751 	if (phydev->irq > 0)
752 		phy_start_interrupts(phydev);
753 
754 	return 0;
755 }
756 EXPORT_SYMBOL(phy_connect_direct);
757 
758 /**
759  * phy_connect - connect an ethernet device to a PHY device
760  * @dev: the network device to connect
761  * @bus_id: the id string of the PHY device to connect
762  * @handler: callback function for state change notifications
763  * @interface: PHY device's interface
764  *
765  * Description: Convenience function for connecting ethernet
766  *   devices to PHY devices.  The default behavior is for
767  *   the PHY infrastructure to handle everything, and only notify
768  *   the connected driver when the link status changes.  If you
769  *   don't want, or can't use the provided functionality, you may
770  *   choose to call only the subset of functions which provide
771  *   the desired functionality.
772  */
773 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
774 			       void (*handler)(struct net_device *),
775 			       phy_interface_t interface)
776 {
777 	struct phy_device *phydev;
778 	struct device *d;
779 	int rc;
780 
781 	/* Search the list of PHY devices on the mdio bus for the
782 	 * PHY with the requested name
783 	 */
784 	d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
785 	if (!d) {
786 		pr_err("PHY %s not found\n", bus_id);
787 		return ERR_PTR(-ENODEV);
788 	}
789 	phydev = to_phy_device(d);
790 
791 	rc = phy_connect_direct(dev, phydev, handler, interface);
792 	put_device(d);
793 	if (rc)
794 		return ERR_PTR(rc);
795 
796 	return phydev;
797 }
798 EXPORT_SYMBOL(phy_connect);
799 
800 /**
801  * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
802  *		    device
803  * @phydev: target phy_device struct
804  */
805 void phy_disconnect(struct phy_device *phydev)
806 {
807 	if (phydev->irq > 0)
808 		phy_stop_interrupts(phydev);
809 
810 	phy_stop_machine(phydev);
811 
812 	phydev->adjust_link = NULL;
813 
814 	phy_detach(phydev);
815 }
816 EXPORT_SYMBOL(phy_disconnect);
817 
818 /**
819  * phy_poll_reset - Safely wait until a PHY reset has properly completed
820  * @phydev: The PHY device to poll
821  *
822  * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
823  *   published in 2008, a PHY reset may take up to 0.5 seconds.  The MII BMCR
824  *   register must be polled until the BMCR_RESET bit clears.
825  *
826  *   Furthermore, any attempts to write to PHY registers may have no effect
827  *   or even generate MDIO bus errors until this is complete.
828  *
829  *   Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
830  *   standard and do not fully reset after the BMCR_RESET bit is set, and may
831  *   even *REQUIRE* a soft-reset to properly restart autonegotiation.  In an
832  *   effort to support such broken PHYs, this function is separate from the
833  *   standard phy_init_hw() which will zero all the other bits in the BMCR
834  *   and reapply all driver-specific and board-specific fixups.
835  */
836 static int phy_poll_reset(struct phy_device *phydev)
837 {
838 	/* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
839 	unsigned int retries = 12;
840 	int ret;
841 
842 	do {
843 		msleep(50);
844 		ret = phy_read(phydev, MII_BMCR);
845 		if (ret < 0)
846 			return ret;
847 	} while (ret & BMCR_RESET && --retries);
848 	if (ret & BMCR_RESET)
849 		return -ETIMEDOUT;
850 
851 	/* Some chips (smsc911x) may still need up to another 1ms after the
852 	 * BMCR_RESET bit is cleared before they are usable.
853 	 */
854 	msleep(1);
855 	return 0;
856 }
857 
858 int phy_init_hw(struct phy_device *phydev)
859 {
860 	int ret = 0;
861 
862 	/* Deassert the reset signal */
863 	phy_device_reset(phydev, 0);
864 
865 	if (!phydev->drv || !phydev->drv->config_init)
866 		return 0;
867 
868 	if (phydev->drv->soft_reset)
869 		ret = phydev->drv->soft_reset(phydev);
870 	else
871 		ret = genphy_soft_reset(phydev);
872 
873 	if (ret < 0)
874 		return ret;
875 
876 	ret = phy_scan_fixups(phydev);
877 	if (ret < 0)
878 		return ret;
879 
880 	return phydev->drv->config_init(phydev);
881 }
882 EXPORT_SYMBOL(phy_init_hw);
883 
884 void phy_attached_info(struct phy_device *phydev)
885 {
886 	phy_attached_print(phydev, NULL);
887 }
888 EXPORT_SYMBOL(phy_attached_info);
889 
890 #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
891 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
892 {
893 	const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
894 	char *irq_str;
895 	char irq_num[8];
896 
897 	switch(phydev->irq) {
898 	case PHY_POLL:
899 		irq_str = "POLL";
900 		break;
901 	case PHY_IGNORE_INTERRUPT:
902 		irq_str = "IGNORE";
903 		break;
904 	default:
905 		snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
906 		irq_str = irq_num;
907 		break;
908 	}
909 
910 
911 	if (!fmt) {
912 		dev_info(&phydev->mdio.dev, ATTACHED_FMT "\n",
913 			 drv_name, phydev_name(phydev),
914 			 irq_str);
915 	} else {
916 		va_list ap;
917 
918 		dev_info(&phydev->mdio.dev, ATTACHED_FMT,
919 			 drv_name, phydev_name(phydev),
920 			 irq_str);
921 
922 		va_start(ap, fmt);
923 		vprintk(fmt, ap);
924 		va_end(ap);
925 	}
926 }
927 EXPORT_SYMBOL(phy_attached_print);
928 
929 /**
930  * phy_attach_direct - attach a network device to a given PHY device pointer
931  * @dev: network device to attach
932  * @phydev: Pointer to phy_device to attach
933  * @flags: PHY device's dev_flags
934  * @interface: PHY device's interface
935  *
936  * Description: Called by drivers to attach to a particular PHY
937  *     device. The phy_device is found, and properly hooked up
938  *     to the phy_driver.  If no driver is attached, then a
939  *     generic driver is used.  The phy_device is given a ptr to
940  *     the attaching device, and given a callback for link status
941  *     change.  The phy_device is returned to the attaching driver.
942  *     This function takes a reference on the phy device.
943  */
944 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
945 		      u32 flags, phy_interface_t interface)
946 {
947 	struct module *ndev_owner = dev->dev.parent->driver->owner;
948 	struct mii_bus *bus = phydev->mdio.bus;
949 	struct device *d = &phydev->mdio.dev;
950 	bool using_genphy = false;
951 	int err;
952 
953 	/* For Ethernet device drivers that register their own MDIO bus, we
954 	 * will have bus->owner match ndev_mod, so we do not want to increment
955 	 * our own module->refcnt here, otherwise we would not be able to
956 	 * unload later on.
957 	 */
958 	if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
959 		dev_err(&dev->dev, "failed to get the bus module\n");
960 		return -EIO;
961 	}
962 
963 	get_device(d);
964 
965 	/* Assume that if there is no driver, that it doesn't
966 	 * exist, and we should use the genphy driver.
967 	 */
968 	if (!d->driver) {
969 		if (phydev->is_c45)
970 			d->driver = &genphy_10g_driver.mdiodrv.driver;
971 		else
972 			d->driver = &genphy_driver.mdiodrv.driver;
973 
974 		using_genphy = true;
975 	}
976 
977 	if (!try_module_get(d->driver->owner)) {
978 		dev_err(&dev->dev, "failed to get the device driver module\n");
979 		err = -EIO;
980 		goto error_put_device;
981 	}
982 
983 	if (using_genphy) {
984 		err = d->driver->probe(d);
985 		if (err >= 0)
986 			err = device_bind_driver(d);
987 
988 		if (err)
989 			goto error_module_put;
990 	}
991 
992 	if (phydev->attached_dev) {
993 		dev_err(&dev->dev, "PHY already attached\n");
994 		err = -EBUSY;
995 		goto error;
996 	}
997 
998 	phydev->phy_link_change = phy_link_change;
999 	phydev->attached_dev = dev;
1000 	dev->phydev = phydev;
1001 
1002 	/* Some Ethernet drivers try to connect to a PHY device before
1003 	 * calling register_netdevice() -> netdev_register_kobject() and
1004 	 * does the dev->dev.kobj initialization. Here we only check for
1005 	 * success which indicates that the network device kobject is
1006 	 * ready. Once we do that we still need to keep track of whether
1007 	 * links were successfully set up or not for phy_detach() to
1008 	 * remove them accordingly.
1009 	 */
1010 	phydev->sysfs_links = false;
1011 
1012 	err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1013 				"attached_dev");
1014 	if (!err) {
1015 		err = sysfs_create_link_nowarn(&dev->dev.kobj,
1016 					       &phydev->mdio.dev.kobj,
1017 					       "phydev");
1018 		if (err) {
1019 			dev_err(&dev->dev, "could not add device link to %s err %d\n",
1020 				kobject_name(&phydev->mdio.dev.kobj),
1021 				err);
1022 			/* non-fatal - some net drivers can use one netdevice
1023 			 * with more then one phy
1024 			 */
1025 		}
1026 
1027 		phydev->sysfs_links = true;
1028 	}
1029 
1030 	phydev->dev_flags = flags;
1031 
1032 	phydev->interface = interface;
1033 
1034 	phydev->state = PHY_READY;
1035 
1036 	/* Initial carrier state is off as the phy is about to be
1037 	 * (re)initialized.
1038 	 */
1039 	netif_carrier_off(phydev->attached_dev);
1040 
1041 	/* Do initial configuration here, now that
1042 	 * we have certain key parameters
1043 	 * (dev_flags and interface)
1044 	 */
1045 	err = phy_init_hw(phydev);
1046 	if (err)
1047 		goto error;
1048 
1049 	phy_resume(phydev);
1050 	phy_led_triggers_register(phydev);
1051 
1052 	return err;
1053 
1054 error:
1055 	/* phy_detach() does all of the cleanup below */
1056 	phy_detach(phydev);
1057 	return err;
1058 
1059 error_module_put:
1060 	module_put(d->driver->owner);
1061 error_put_device:
1062 	put_device(d);
1063 	if (ndev_owner != bus->owner)
1064 		module_put(bus->owner);
1065 	return err;
1066 }
1067 EXPORT_SYMBOL(phy_attach_direct);
1068 
1069 /**
1070  * phy_attach - attach a network device to a particular PHY device
1071  * @dev: network device to attach
1072  * @bus_id: Bus ID of PHY device to attach
1073  * @interface: PHY device's interface
1074  *
1075  * Description: Same as phy_attach_direct() except that a PHY bus_id
1076  *     string is passed instead of a pointer to a struct phy_device.
1077  */
1078 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1079 			      phy_interface_t interface)
1080 {
1081 	struct bus_type *bus = &mdio_bus_type;
1082 	struct phy_device *phydev;
1083 	struct device *d;
1084 	int rc;
1085 
1086 	/* Search the list of PHY devices on the mdio bus for the
1087 	 * PHY with the requested name
1088 	 */
1089 	d = bus_find_device_by_name(bus, NULL, bus_id);
1090 	if (!d) {
1091 		pr_err("PHY %s not found\n", bus_id);
1092 		return ERR_PTR(-ENODEV);
1093 	}
1094 	phydev = to_phy_device(d);
1095 
1096 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1097 	put_device(d);
1098 	if (rc)
1099 		return ERR_PTR(rc);
1100 
1101 	return phydev;
1102 }
1103 EXPORT_SYMBOL(phy_attach);
1104 
1105 /**
1106  * phy_detach - detach a PHY device from its network device
1107  * @phydev: target phy_device struct
1108  *
1109  * This detaches the phy device from its network device and the phy
1110  * driver, and drops the reference count taken in phy_attach_direct().
1111  */
1112 void phy_detach(struct phy_device *phydev)
1113 {
1114 	struct net_device *dev = phydev->attached_dev;
1115 	struct module *ndev_owner = dev->dev.parent->driver->owner;
1116 	struct mii_bus *bus;
1117 
1118 	if (phydev->sysfs_links) {
1119 		sysfs_remove_link(&dev->dev.kobj, "phydev");
1120 		sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1121 	}
1122 	phydev->attached_dev->phydev = NULL;
1123 	phydev->attached_dev = NULL;
1124 	phy_suspend(phydev);
1125 	phydev->phylink = NULL;
1126 
1127 	phy_led_triggers_unregister(phydev);
1128 
1129 	module_put(phydev->mdio.dev.driver->owner);
1130 
1131 	/* If the device had no specific driver before (i.e. - it
1132 	 * was using the generic driver), we unbind the device
1133 	 * from the generic driver so that there's a chance a
1134 	 * real driver could be loaded
1135 	 */
1136 	if (phydev->mdio.dev.driver == &genphy_10g_driver.mdiodrv.driver ||
1137 	    phydev->mdio.dev.driver == &genphy_driver.mdiodrv.driver)
1138 		device_release_driver(&phydev->mdio.dev);
1139 
1140 	/*
1141 	 * The phydev might go away on the put_device() below, so avoid
1142 	 * a use-after-free bug by reading the underlying bus first.
1143 	 */
1144 	bus = phydev->mdio.bus;
1145 
1146 	put_device(&phydev->mdio.dev);
1147 	if (ndev_owner != bus->owner)
1148 		module_put(bus->owner);
1149 
1150 	/* Assert the reset signal */
1151 	phy_device_reset(phydev, 1);
1152 }
1153 EXPORT_SYMBOL(phy_detach);
1154 
1155 int phy_suspend(struct phy_device *phydev)
1156 {
1157 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1158 	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1159 	int ret = 0;
1160 
1161 	/* If the device has WOL enabled, we cannot suspend the PHY */
1162 	phy_ethtool_get_wol(phydev, &wol);
1163 	if (wol.wolopts)
1164 		return -EBUSY;
1165 
1166 	if (phydev->drv && phydrv->suspend)
1167 		ret = phydrv->suspend(phydev);
1168 
1169 	if (ret)
1170 		return ret;
1171 
1172 	phydev->suspended = true;
1173 
1174 	return ret;
1175 }
1176 EXPORT_SYMBOL(phy_suspend);
1177 
1178 int __phy_resume(struct phy_device *phydev)
1179 {
1180 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1181 	int ret = 0;
1182 
1183 	WARN_ON(!mutex_is_locked(&phydev->lock));
1184 
1185 	if (phydev->drv && phydrv->resume)
1186 		ret = phydrv->resume(phydev);
1187 
1188 	if (ret)
1189 		return ret;
1190 
1191 	phydev->suspended = false;
1192 
1193 	return ret;
1194 }
1195 EXPORT_SYMBOL(__phy_resume);
1196 
1197 int phy_resume(struct phy_device *phydev)
1198 {
1199 	int ret;
1200 
1201 	mutex_lock(&phydev->lock);
1202 	ret = __phy_resume(phydev);
1203 	mutex_unlock(&phydev->lock);
1204 
1205 	return ret;
1206 }
1207 EXPORT_SYMBOL(phy_resume);
1208 
1209 int phy_loopback(struct phy_device *phydev, bool enable)
1210 {
1211 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1212 	int ret = 0;
1213 
1214 	mutex_lock(&phydev->lock);
1215 
1216 	if (enable && phydev->loopback_enabled) {
1217 		ret = -EBUSY;
1218 		goto out;
1219 	}
1220 
1221 	if (!enable && !phydev->loopback_enabled) {
1222 		ret = -EINVAL;
1223 		goto out;
1224 	}
1225 
1226 	if (phydev->drv && phydrv->set_loopback)
1227 		ret = phydrv->set_loopback(phydev, enable);
1228 	else
1229 		ret = -EOPNOTSUPP;
1230 
1231 	if (ret)
1232 		goto out;
1233 
1234 	phydev->loopback_enabled = enable;
1235 
1236 out:
1237 	mutex_unlock(&phydev->lock);
1238 	return ret;
1239 }
1240 EXPORT_SYMBOL(phy_loopback);
1241 
1242 /**
1243  * phy_reset_after_clk_enable - perform a PHY reset if needed
1244  * @phydev: target phy_device struct
1245  *
1246  * Description: Some PHYs are known to need a reset after their refclk was
1247  *   enabled. This function evaluates the flags and perform the reset if it's
1248  *   needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1249  *   was reset.
1250  */
1251 int phy_reset_after_clk_enable(struct phy_device *phydev)
1252 {
1253 	if (!phydev || !phydev->drv)
1254 		return -ENODEV;
1255 
1256 	if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1257 		phy_device_reset(phydev, 1);
1258 		phy_device_reset(phydev, 0);
1259 		return 1;
1260 	}
1261 
1262 	return 0;
1263 }
1264 EXPORT_SYMBOL(phy_reset_after_clk_enable);
1265 
1266 /* Generic PHY support and helper functions */
1267 
1268 /**
1269  * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1270  * @phydev: target phy_device struct
1271  *
1272  * Description: Writes MII_ADVERTISE with the appropriate values,
1273  *   after sanitizing the values to make sure we only advertise
1274  *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
1275  *   hasn't changed, and > 0 if it has changed.
1276  */
1277 static int genphy_config_advert(struct phy_device *phydev)
1278 {
1279 	u32 advertise;
1280 	int oldadv, adv, bmsr;
1281 	int err, changed = 0;
1282 
1283 	/* Only allow advertising what this PHY supports */
1284 	phydev->advertising &= phydev->supported;
1285 	advertise = phydev->advertising;
1286 
1287 	/* Setup standard advertisement */
1288 	adv = phy_read(phydev, MII_ADVERTISE);
1289 	if (adv < 0)
1290 		return adv;
1291 
1292 	oldadv = adv;
1293 	adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
1294 		 ADVERTISE_PAUSE_ASYM);
1295 	adv |= ethtool_adv_to_mii_adv_t(advertise);
1296 
1297 	if (adv != oldadv) {
1298 		err = phy_write(phydev, MII_ADVERTISE, adv);
1299 
1300 		if (err < 0)
1301 			return err;
1302 		changed = 1;
1303 	}
1304 
1305 	bmsr = phy_read(phydev, MII_BMSR);
1306 	if (bmsr < 0)
1307 		return bmsr;
1308 
1309 	/* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1310 	 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1311 	 * logical 1.
1312 	 */
1313 	if (!(bmsr & BMSR_ESTATEN))
1314 		return changed;
1315 
1316 	/* Configure gigabit if it's supported */
1317 	adv = phy_read(phydev, MII_CTRL1000);
1318 	if (adv < 0)
1319 		return adv;
1320 
1321 	oldadv = adv;
1322 	adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
1323 
1324 	if (phydev->supported & (SUPPORTED_1000baseT_Half |
1325 				 SUPPORTED_1000baseT_Full)) {
1326 		adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
1327 	}
1328 
1329 	if (adv != oldadv)
1330 		changed = 1;
1331 
1332 	err = phy_write(phydev, MII_CTRL1000, adv);
1333 	if (err < 0)
1334 		return err;
1335 
1336 	return changed;
1337 }
1338 
1339 /**
1340  * genphy_config_eee_advert - disable unwanted eee mode advertisement
1341  * @phydev: target phy_device struct
1342  *
1343  * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1344  *   efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1345  *   changed, and 1 if it has changed.
1346  */
1347 static int genphy_config_eee_advert(struct phy_device *phydev)
1348 {
1349 	int broken = phydev->eee_broken_modes;
1350 	int old_adv, adv;
1351 
1352 	/* Nothing to disable */
1353 	if (!broken)
1354 		return 0;
1355 
1356 	/* If the following call fails, we assume that EEE is not
1357 	 * supported by the phy. If we read 0, EEE is not advertised
1358 	 * In both case, we don't need to continue
1359 	 */
1360 	adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1361 	if (adv <= 0)
1362 		return 0;
1363 
1364 	old_adv = adv;
1365 	adv &= ~broken;
1366 
1367 	/* Advertising remains unchanged with the broken mask */
1368 	if (old_adv == adv)
1369 		return 0;
1370 
1371 	phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1372 
1373 	return 1;
1374 }
1375 
1376 /**
1377  * genphy_setup_forced - configures/forces speed/duplex from @phydev
1378  * @phydev: target phy_device struct
1379  *
1380  * Description: Configures MII_BMCR to force speed/duplex
1381  *   to the values in phydev. Assumes that the values are valid.
1382  *   Please see phy_sanitize_settings().
1383  */
1384 int genphy_setup_forced(struct phy_device *phydev)
1385 {
1386 	u16 ctl = 0;
1387 
1388 	phydev->pause = 0;
1389 	phydev->asym_pause = 0;
1390 
1391 	if (SPEED_1000 == phydev->speed)
1392 		ctl |= BMCR_SPEED1000;
1393 	else if (SPEED_100 == phydev->speed)
1394 		ctl |= BMCR_SPEED100;
1395 
1396 	if (DUPLEX_FULL == phydev->duplex)
1397 		ctl |= BMCR_FULLDPLX;
1398 
1399 	return phy_modify(phydev, MII_BMCR,
1400 			  ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
1401 }
1402 EXPORT_SYMBOL(genphy_setup_forced);
1403 
1404 /**
1405  * genphy_restart_aneg - Enable and Restart Autonegotiation
1406  * @phydev: target phy_device struct
1407  */
1408 int genphy_restart_aneg(struct phy_device *phydev)
1409 {
1410 	/* Don't isolate the PHY if we're negotiating */
1411 	return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1412 			  BMCR_ANENABLE | BMCR_ANRESTART);
1413 }
1414 EXPORT_SYMBOL(genphy_restart_aneg);
1415 
1416 /**
1417  * genphy_config_aneg - restart auto-negotiation or write BMCR
1418  * @phydev: target phy_device struct
1419  *
1420  * Description: If auto-negotiation is enabled, we configure the
1421  *   advertising, and then restart auto-negotiation.  If it is not
1422  *   enabled, then we write the BMCR.
1423  */
1424 int genphy_config_aneg(struct phy_device *phydev)
1425 {
1426 	int err, changed;
1427 
1428 	changed = genphy_config_eee_advert(phydev);
1429 
1430 	if (AUTONEG_ENABLE != phydev->autoneg)
1431 		return genphy_setup_forced(phydev);
1432 
1433 	err = genphy_config_advert(phydev);
1434 	if (err < 0) /* error */
1435 		return err;
1436 
1437 	changed |= err;
1438 
1439 	if (changed == 0) {
1440 		/* Advertisement hasn't changed, but maybe aneg was never on to
1441 		 * begin with?  Or maybe phy was isolated?
1442 		 */
1443 		int ctl = phy_read(phydev, MII_BMCR);
1444 
1445 		if (ctl < 0)
1446 			return ctl;
1447 
1448 		if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1449 			changed = 1; /* do restart aneg */
1450 	}
1451 
1452 	/* Only restart aneg if we are advertising something different
1453 	 * than we were before.
1454 	 */
1455 	if (changed > 0)
1456 		return genphy_restart_aneg(phydev);
1457 
1458 	return 0;
1459 }
1460 EXPORT_SYMBOL(genphy_config_aneg);
1461 
1462 /**
1463  * genphy_aneg_done - return auto-negotiation status
1464  * @phydev: target phy_device struct
1465  *
1466  * Description: Reads the status register and returns 0 either if
1467  *   auto-negotiation is incomplete, or if there was an error.
1468  *   Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1469  */
1470 int genphy_aneg_done(struct phy_device *phydev)
1471 {
1472 	int retval = phy_read(phydev, MII_BMSR);
1473 
1474 	return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1475 }
1476 EXPORT_SYMBOL(genphy_aneg_done);
1477 
1478 /**
1479  * genphy_update_link - update link status in @phydev
1480  * @phydev: target phy_device struct
1481  *
1482  * Description: Update the value in phydev->link to reflect the
1483  *   current link value.  In order to do this, we need to read
1484  *   the status register twice, keeping the second value.
1485  */
1486 int genphy_update_link(struct phy_device *phydev)
1487 {
1488 	int status;
1489 
1490 	/* Do a fake read */
1491 	status = phy_read(phydev, MII_BMSR);
1492 	if (status < 0)
1493 		return status;
1494 
1495 	/* Read link and autonegotiation status */
1496 	status = phy_read(phydev, MII_BMSR);
1497 	if (status < 0)
1498 		return status;
1499 
1500 	if ((status & BMSR_LSTATUS) == 0)
1501 		phydev->link = 0;
1502 	else
1503 		phydev->link = 1;
1504 
1505 	return 0;
1506 }
1507 EXPORT_SYMBOL(genphy_update_link);
1508 
1509 /**
1510  * genphy_read_status - check the link status and update current link state
1511  * @phydev: target phy_device struct
1512  *
1513  * Description: Check the link, then figure out the current state
1514  *   by comparing what we advertise with what the link partner
1515  *   advertises.  Start by checking the gigabit possibilities,
1516  *   then move on to 10/100.
1517  */
1518 int genphy_read_status(struct phy_device *phydev)
1519 {
1520 	int adv;
1521 	int err;
1522 	int lpa;
1523 	int lpagb = 0;
1524 	int common_adv;
1525 	int common_adv_gb = 0;
1526 
1527 	/* Update the link, but return if there was an error */
1528 	err = genphy_update_link(phydev);
1529 	if (err)
1530 		return err;
1531 
1532 	phydev->lp_advertising = 0;
1533 
1534 	if (AUTONEG_ENABLE == phydev->autoneg) {
1535 		if (phydev->supported & (SUPPORTED_1000baseT_Half
1536 					| SUPPORTED_1000baseT_Full)) {
1537 			lpagb = phy_read(phydev, MII_STAT1000);
1538 			if (lpagb < 0)
1539 				return lpagb;
1540 
1541 			adv = phy_read(phydev, MII_CTRL1000);
1542 			if (adv < 0)
1543 				return adv;
1544 
1545 			phydev->lp_advertising =
1546 				mii_stat1000_to_ethtool_lpa_t(lpagb);
1547 			common_adv_gb = lpagb & adv << 2;
1548 		}
1549 
1550 		lpa = phy_read(phydev, MII_LPA);
1551 		if (lpa < 0)
1552 			return lpa;
1553 
1554 		phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
1555 
1556 		adv = phy_read(phydev, MII_ADVERTISE);
1557 		if (adv < 0)
1558 			return adv;
1559 
1560 		common_adv = lpa & adv;
1561 
1562 		phydev->speed = SPEED_10;
1563 		phydev->duplex = DUPLEX_HALF;
1564 		phydev->pause = 0;
1565 		phydev->asym_pause = 0;
1566 
1567 		if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) {
1568 			phydev->speed = SPEED_1000;
1569 
1570 			if (common_adv_gb & LPA_1000FULL)
1571 				phydev->duplex = DUPLEX_FULL;
1572 		} else if (common_adv & (LPA_100FULL | LPA_100HALF)) {
1573 			phydev->speed = SPEED_100;
1574 
1575 			if (common_adv & LPA_100FULL)
1576 				phydev->duplex = DUPLEX_FULL;
1577 		} else
1578 			if (common_adv & LPA_10FULL)
1579 				phydev->duplex = DUPLEX_FULL;
1580 
1581 		if (phydev->duplex == DUPLEX_FULL) {
1582 			phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
1583 			phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
1584 		}
1585 	} else {
1586 		int bmcr = phy_read(phydev, MII_BMCR);
1587 
1588 		if (bmcr < 0)
1589 			return bmcr;
1590 
1591 		if (bmcr & BMCR_FULLDPLX)
1592 			phydev->duplex = DUPLEX_FULL;
1593 		else
1594 			phydev->duplex = DUPLEX_HALF;
1595 
1596 		if (bmcr & BMCR_SPEED1000)
1597 			phydev->speed = SPEED_1000;
1598 		else if (bmcr & BMCR_SPEED100)
1599 			phydev->speed = SPEED_100;
1600 		else
1601 			phydev->speed = SPEED_10;
1602 
1603 		phydev->pause = 0;
1604 		phydev->asym_pause = 0;
1605 	}
1606 
1607 	return 0;
1608 }
1609 EXPORT_SYMBOL(genphy_read_status);
1610 
1611 /**
1612  * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
1613  * @phydev: target phy_device struct
1614  *
1615  * Description: Perform a software PHY reset using the standard
1616  * BMCR_RESET bit and poll for the reset bit to be cleared.
1617  *
1618  * Returns: 0 on success, < 0 on failure
1619  */
1620 int genphy_soft_reset(struct phy_device *phydev)
1621 {
1622 	int ret;
1623 
1624 	ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
1625 	if (ret < 0)
1626 		return ret;
1627 
1628 	return phy_poll_reset(phydev);
1629 }
1630 EXPORT_SYMBOL(genphy_soft_reset);
1631 
1632 int genphy_config_init(struct phy_device *phydev)
1633 {
1634 	int val;
1635 	u32 features;
1636 
1637 	features = (SUPPORTED_TP | SUPPORTED_MII
1638 			| SUPPORTED_AUI | SUPPORTED_FIBRE |
1639 			SUPPORTED_BNC | SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1640 
1641 	/* Do we support autonegotiation? */
1642 	val = phy_read(phydev, MII_BMSR);
1643 	if (val < 0)
1644 		return val;
1645 
1646 	if (val & BMSR_ANEGCAPABLE)
1647 		features |= SUPPORTED_Autoneg;
1648 
1649 	if (val & BMSR_100FULL)
1650 		features |= SUPPORTED_100baseT_Full;
1651 	if (val & BMSR_100HALF)
1652 		features |= SUPPORTED_100baseT_Half;
1653 	if (val & BMSR_10FULL)
1654 		features |= SUPPORTED_10baseT_Full;
1655 	if (val & BMSR_10HALF)
1656 		features |= SUPPORTED_10baseT_Half;
1657 
1658 	if (val & BMSR_ESTATEN) {
1659 		val = phy_read(phydev, MII_ESTATUS);
1660 		if (val < 0)
1661 			return val;
1662 
1663 		if (val & ESTATUS_1000_TFULL)
1664 			features |= SUPPORTED_1000baseT_Full;
1665 		if (val & ESTATUS_1000_THALF)
1666 			features |= SUPPORTED_1000baseT_Half;
1667 	}
1668 
1669 	phydev->supported &= features;
1670 	phydev->advertising &= features;
1671 
1672 	return 0;
1673 }
1674 EXPORT_SYMBOL(genphy_config_init);
1675 
1676 /* This is used for the phy device which doesn't support the MMD extended
1677  * register access, but it does have side effect when we are trying to access
1678  * the MMD register via indirect method.
1679  */
1680 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
1681 {
1682 	return -EOPNOTSUPP;
1683 }
1684 EXPORT_SYMBOL(genphy_read_mmd_unsupported);
1685 
1686 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
1687 				 u16 regnum, u16 val)
1688 {
1689 	return -EOPNOTSUPP;
1690 }
1691 EXPORT_SYMBOL(genphy_write_mmd_unsupported);
1692 
1693 int genphy_suspend(struct phy_device *phydev)
1694 {
1695 	return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
1696 }
1697 EXPORT_SYMBOL(genphy_suspend);
1698 
1699 int genphy_resume(struct phy_device *phydev)
1700 {
1701 	return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
1702 }
1703 EXPORT_SYMBOL(genphy_resume);
1704 
1705 int genphy_loopback(struct phy_device *phydev, bool enable)
1706 {
1707 	return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
1708 			  enable ? BMCR_LOOPBACK : 0);
1709 }
1710 EXPORT_SYMBOL(genphy_loopback);
1711 
1712 static int __set_phy_supported(struct phy_device *phydev, u32 max_speed)
1713 {
1714 	/* The default values for phydev->supported are provided by the PHY
1715 	 * driver "features" member, we want to reset to sane defaults first
1716 	 * before supporting higher speeds.
1717 	 */
1718 	phydev->supported &= PHY_DEFAULT_FEATURES;
1719 
1720 	switch (max_speed) {
1721 	default:
1722 		return -ENOTSUPP;
1723 	case SPEED_1000:
1724 		phydev->supported |= PHY_1000BT_FEATURES;
1725 		/* fall through */
1726 	case SPEED_100:
1727 		phydev->supported |= PHY_100BT_FEATURES;
1728 		/* fall through */
1729 	case SPEED_10:
1730 		phydev->supported |= PHY_10BT_FEATURES;
1731 	}
1732 
1733 	return 0;
1734 }
1735 
1736 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
1737 {
1738 	int err;
1739 
1740 	err = __set_phy_supported(phydev, max_speed);
1741 	if (err)
1742 		return err;
1743 
1744 	phydev->advertising = phydev->supported;
1745 
1746 	return 0;
1747 }
1748 EXPORT_SYMBOL(phy_set_max_speed);
1749 
1750 static void of_set_phy_supported(struct phy_device *phydev)
1751 {
1752 	struct device_node *node = phydev->mdio.dev.of_node;
1753 	u32 max_speed;
1754 
1755 	if (!IS_ENABLED(CONFIG_OF_MDIO))
1756 		return;
1757 
1758 	if (!node)
1759 		return;
1760 
1761 	if (!of_property_read_u32(node, "max-speed", &max_speed))
1762 		__set_phy_supported(phydev, max_speed);
1763 }
1764 
1765 static void of_set_phy_eee_broken(struct phy_device *phydev)
1766 {
1767 	struct device_node *node = phydev->mdio.dev.of_node;
1768 	u32 broken = 0;
1769 
1770 	if (!IS_ENABLED(CONFIG_OF_MDIO))
1771 		return;
1772 
1773 	if (!node)
1774 		return;
1775 
1776 	if (of_property_read_bool(node, "eee-broken-100tx"))
1777 		broken |= MDIO_EEE_100TX;
1778 	if (of_property_read_bool(node, "eee-broken-1000t"))
1779 		broken |= MDIO_EEE_1000T;
1780 	if (of_property_read_bool(node, "eee-broken-10gt"))
1781 		broken |= MDIO_EEE_10GT;
1782 	if (of_property_read_bool(node, "eee-broken-1000kx"))
1783 		broken |= MDIO_EEE_1000KX;
1784 	if (of_property_read_bool(node, "eee-broken-10gkx4"))
1785 		broken |= MDIO_EEE_10GKX4;
1786 	if (of_property_read_bool(node, "eee-broken-10gkr"))
1787 		broken |= MDIO_EEE_10GKR;
1788 
1789 	phydev->eee_broken_modes = broken;
1790 }
1791 
1792 /**
1793  * phy_probe - probe and init a PHY device
1794  * @dev: device to probe and init
1795  *
1796  * Description: Take care of setting up the phy_device structure,
1797  *   set the state to READY (the driver's init function should
1798  *   set it to STARTING if needed).
1799  */
1800 static int phy_probe(struct device *dev)
1801 {
1802 	struct phy_device *phydev = to_phy_device(dev);
1803 	struct device_driver *drv = phydev->mdio.dev.driver;
1804 	struct phy_driver *phydrv = to_phy_driver(drv);
1805 	int err = 0;
1806 
1807 	phydev->drv = phydrv;
1808 
1809 	/* Disable the interrupt if the PHY doesn't support it
1810 	 * but the interrupt is still a valid one
1811 	 */
1812 	if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1813 	    phy_interrupt_is_valid(phydev))
1814 		phydev->irq = PHY_POLL;
1815 
1816 	if (phydrv->flags & PHY_IS_INTERNAL)
1817 		phydev->is_internal = true;
1818 
1819 	mutex_lock(&phydev->lock);
1820 
1821 	/* Start out supporting everything. Eventually,
1822 	 * a controller will attach, and may modify one
1823 	 * or both of these values
1824 	 */
1825 	phydev->supported = phydrv->features;
1826 	of_set_phy_supported(phydev);
1827 	phydev->advertising = phydev->supported;
1828 
1829 	/* Get the EEE modes we want to prohibit. We will ask
1830 	 * the PHY stop advertising these mode later on
1831 	 */
1832 	of_set_phy_eee_broken(phydev);
1833 
1834 	/* The Pause Frame bits indicate that the PHY can support passing
1835 	 * pause frames. During autonegotiation, the PHYs will determine if
1836 	 * they should allow pause frames to pass.  The MAC driver should then
1837 	 * use that result to determine whether to enable flow control via
1838 	 * pause frames.
1839 	 *
1840 	 * Normally, PHY drivers should not set the Pause bits, and instead
1841 	 * allow phylib to do that.  However, there may be some situations
1842 	 * (e.g. hardware erratum) where the driver wants to set only one
1843 	 * of these bits.
1844 	 */
1845 	if (phydrv->features & (SUPPORTED_Pause | SUPPORTED_Asym_Pause)) {
1846 		phydev->supported &= ~(SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1847 		phydev->supported |= phydrv->features &
1848 				     (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1849 	} else {
1850 		phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1851 	}
1852 
1853 	/* Set the state to READY by default */
1854 	phydev->state = PHY_READY;
1855 
1856 	if (phydev->drv->probe) {
1857 		/* Deassert the reset signal */
1858 		phy_device_reset(phydev, 0);
1859 
1860 		err = phydev->drv->probe(phydev);
1861 		if (err) {
1862 			/* Assert the reset signal */
1863 			phy_device_reset(phydev, 1);
1864 		}
1865 	}
1866 
1867 	mutex_unlock(&phydev->lock);
1868 
1869 	return err;
1870 }
1871 
1872 static int phy_remove(struct device *dev)
1873 {
1874 	struct phy_device *phydev = to_phy_device(dev);
1875 
1876 	cancel_delayed_work_sync(&phydev->state_queue);
1877 
1878 	mutex_lock(&phydev->lock);
1879 	phydev->state = PHY_DOWN;
1880 	mutex_unlock(&phydev->lock);
1881 
1882 	if (phydev->drv && phydev->drv->remove) {
1883 		phydev->drv->remove(phydev);
1884 
1885 		/* Assert the reset signal */
1886 		phy_device_reset(phydev, 1);
1887 	}
1888 	phydev->drv = NULL;
1889 
1890 	return 0;
1891 }
1892 
1893 /**
1894  * phy_driver_register - register a phy_driver with the PHY layer
1895  * @new_driver: new phy_driver to register
1896  * @owner: module owning this PHY
1897  */
1898 int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
1899 {
1900 	int retval;
1901 
1902 	new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
1903 	new_driver->mdiodrv.driver.name = new_driver->name;
1904 	new_driver->mdiodrv.driver.bus = &mdio_bus_type;
1905 	new_driver->mdiodrv.driver.probe = phy_probe;
1906 	new_driver->mdiodrv.driver.remove = phy_remove;
1907 	new_driver->mdiodrv.driver.owner = owner;
1908 
1909 	retval = driver_register(&new_driver->mdiodrv.driver);
1910 	if (retval) {
1911 		pr_err("%s: Error %d in registering driver\n",
1912 		       new_driver->name, retval);
1913 
1914 		return retval;
1915 	}
1916 
1917 	pr_debug("%s: Registered new driver\n", new_driver->name);
1918 
1919 	return 0;
1920 }
1921 EXPORT_SYMBOL(phy_driver_register);
1922 
1923 int phy_drivers_register(struct phy_driver *new_driver, int n,
1924 			 struct module *owner)
1925 {
1926 	int i, ret = 0;
1927 
1928 	for (i = 0; i < n; i++) {
1929 		ret = phy_driver_register(new_driver + i, owner);
1930 		if (ret) {
1931 			while (i-- > 0)
1932 				phy_driver_unregister(new_driver + i);
1933 			break;
1934 		}
1935 	}
1936 	return ret;
1937 }
1938 EXPORT_SYMBOL(phy_drivers_register);
1939 
1940 void phy_driver_unregister(struct phy_driver *drv)
1941 {
1942 	driver_unregister(&drv->mdiodrv.driver);
1943 }
1944 EXPORT_SYMBOL(phy_driver_unregister);
1945 
1946 void phy_drivers_unregister(struct phy_driver *drv, int n)
1947 {
1948 	int i;
1949 
1950 	for (i = 0; i < n; i++)
1951 		phy_driver_unregister(drv + i);
1952 }
1953 EXPORT_SYMBOL(phy_drivers_unregister);
1954 
1955 static struct phy_driver genphy_driver = {
1956 	.phy_id		= 0xffffffff,
1957 	.phy_id_mask	= 0xffffffff,
1958 	.name		= "Generic PHY",
1959 	.soft_reset	= genphy_no_soft_reset,
1960 	.config_init	= genphy_config_init,
1961 	.features	= PHY_GBIT_FEATURES | SUPPORTED_MII |
1962 			  SUPPORTED_AUI | SUPPORTED_FIBRE |
1963 			  SUPPORTED_BNC,
1964 	.aneg_done	= genphy_aneg_done,
1965 	.suspend	= genphy_suspend,
1966 	.resume		= genphy_resume,
1967 	.set_loopback   = genphy_loopback,
1968 };
1969 
1970 static int __init phy_init(void)
1971 {
1972 	int rc;
1973 
1974 	rc = mdio_bus_init();
1975 	if (rc)
1976 		return rc;
1977 
1978 	rc = phy_driver_register(&genphy_10g_driver, THIS_MODULE);
1979 	if (rc)
1980 		goto err_10g;
1981 
1982 	rc = phy_driver_register(&genphy_driver, THIS_MODULE);
1983 	if (rc) {
1984 		phy_driver_unregister(&genphy_10g_driver);
1985 err_10g:
1986 		mdio_bus_exit();
1987 	}
1988 
1989 	return rc;
1990 }
1991 
1992 static void __exit phy_exit(void)
1993 {
1994 	phy_driver_unregister(&genphy_10g_driver);
1995 	phy_driver_unregister(&genphy_driver);
1996 	mdio_bus_exit();
1997 }
1998 
1999 subsys_initcall(phy_init);
2000 module_exit(phy_exit);
2001