xref: /openbmc/linux/drivers/net/phy/phy_device.c (revision 6c33a6f4)
1 // SPDX-License-Identifier: GPL-2.0+
2 /* Framework for finding and configuring PHYs.
3  * Also contains generic PHY driver
4  *
5  * Author: Andy Fleming
6  *
7  * Copyright (c) 2004 Freescale Semiconductor, Inc.
8  */
9 
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 
12 #include <linux/kernel.h>
13 #include <linux/string.h>
14 #include <linux/errno.h>
15 #include <linux/unistd.h>
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/init.h>
19 #include <linux/delay.h>
20 #include <linux/netdevice.h>
21 #include <linux/etherdevice.h>
22 #include <linux/skbuff.h>
23 #include <linux/mm.h>
24 #include <linux/module.h>
25 #include <linux/mii.h>
26 #include <linux/ethtool.h>
27 #include <linux/bitmap.h>
28 #include <linux/phy.h>
29 #include <linux/phy_led_triggers.h>
30 #include <linux/sfp.h>
31 #include <linux/mdio.h>
32 #include <linux/io.h>
33 #include <linux/uaccess.h>
34 
35 MODULE_DESCRIPTION("PHY library");
36 MODULE_AUTHOR("Andy Fleming");
37 MODULE_LICENSE("GPL");
38 
39 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
40 EXPORT_SYMBOL_GPL(phy_basic_features);
41 
42 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
43 EXPORT_SYMBOL_GPL(phy_basic_t1_features);
44 
45 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
46 EXPORT_SYMBOL_GPL(phy_gbit_features);
47 
48 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
49 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
50 
51 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
52 EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
53 
54 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
55 EXPORT_SYMBOL_GPL(phy_10gbit_features);
56 
57 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
58 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
59 
60 const int phy_basic_ports_array[3] = {
61 	ETHTOOL_LINK_MODE_Autoneg_BIT,
62 	ETHTOOL_LINK_MODE_TP_BIT,
63 	ETHTOOL_LINK_MODE_MII_BIT,
64 };
65 EXPORT_SYMBOL_GPL(phy_basic_ports_array);
66 
67 const int phy_fibre_port_array[1] = {
68 	ETHTOOL_LINK_MODE_FIBRE_BIT,
69 };
70 EXPORT_SYMBOL_GPL(phy_fibre_port_array);
71 
72 const int phy_all_ports_features_array[7] = {
73 	ETHTOOL_LINK_MODE_Autoneg_BIT,
74 	ETHTOOL_LINK_MODE_TP_BIT,
75 	ETHTOOL_LINK_MODE_MII_BIT,
76 	ETHTOOL_LINK_MODE_FIBRE_BIT,
77 	ETHTOOL_LINK_MODE_AUI_BIT,
78 	ETHTOOL_LINK_MODE_BNC_BIT,
79 	ETHTOOL_LINK_MODE_Backplane_BIT,
80 };
81 EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
82 
83 const int phy_10_100_features_array[4] = {
84 	ETHTOOL_LINK_MODE_10baseT_Half_BIT,
85 	ETHTOOL_LINK_MODE_10baseT_Full_BIT,
86 	ETHTOOL_LINK_MODE_100baseT_Half_BIT,
87 	ETHTOOL_LINK_MODE_100baseT_Full_BIT,
88 };
89 EXPORT_SYMBOL_GPL(phy_10_100_features_array);
90 
91 const int phy_basic_t1_features_array[2] = {
92 	ETHTOOL_LINK_MODE_TP_BIT,
93 	ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
94 };
95 EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
96 
97 const int phy_gbit_features_array[2] = {
98 	ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
99 	ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
100 };
101 EXPORT_SYMBOL_GPL(phy_gbit_features_array);
102 
103 const int phy_10gbit_features_array[1] = {
104 	ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
105 };
106 EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
107 
108 const int phy_10gbit_fec_features_array[1] = {
109 	ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
110 };
111 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
112 
113 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
114 EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
115 
116 static const int phy_10gbit_full_features_array[] = {
117 	ETHTOOL_LINK_MODE_10baseT_Full_BIT,
118 	ETHTOOL_LINK_MODE_100baseT_Full_BIT,
119 	ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
120 	ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
121 };
122 
123 static void features_init(void)
124 {
125 	/* 10/100 half/full*/
126 	linkmode_set_bit_array(phy_basic_ports_array,
127 			       ARRAY_SIZE(phy_basic_ports_array),
128 			       phy_basic_features);
129 	linkmode_set_bit_array(phy_10_100_features_array,
130 			       ARRAY_SIZE(phy_10_100_features_array),
131 			       phy_basic_features);
132 
133 	/* 100 full, TP */
134 	linkmode_set_bit_array(phy_basic_t1_features_array,
135 			       ARRAY_SIZE(phy_basic_t1_features_array),
136 			       phy_basic_t1_features);
137 
138 	/* 10/100 half/full + 1000 half/full */
139 	linkmode_set_bit_array(phy_basic_ports_array,
140 			       ARRAY_SIZE(phy_basic_ports_array),
141 			       phy_gbit_features);
142 	linkmode_set_bit_array(phy_10_100_features_array,
143 			       ARRAY_SIZE(phy_10_100_features_array),
144 			       phy_gbit_features);
145 	linkmode_set_bit_array(phy_gbit_features_array,
146 			       ARRAY_SIZE(phy_gbit_features_array),
147 			       phy_gbit_features);
148 
149 	/* 10/100 half/full + 1000 half/full + fibre*/
150 	linkmode_set_bit_array(phy_basic_ports_array,
151 			       ARRAY_SIZE(phy_basic_ports_array),
152 			       phy_gbit_fibre_features);
153 	linkmode_set_bit_array(phy_10_100_features_array,
154 			       ARRAY_SIZE(phy_10_100_features_array),
155 			       phy_gbit_fibre_features);
156 	linkmode_set_bit_array(phy_gbit_features_array,
157 			       ARRAY_SIZE(phy_gbit_features_array),
158 			       phy_gbit_fibre_features);
159 	linkmode_set_bit_array(phy_fibre_port_array,
160 			       ARRAY_SIZE(phy_fibre_port_array),
161 			       phy_gbit_fibre_features);
162 
163 	/* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
164 	linkmode_set_bit_array(phy_all_ports_features_array,
165 			       ARRAY_SIZE(phy_all_ports_features_array),
166 			       phy_gbit_all_ports_features);
167 	linkmode_set_bit_array(phy_10_100_features_array,
168 			       ARRAY_SIZE(phy_10_100_features_array),
169 			       phy_gbit_all_ports_features);
170 	linkmode_set_bit_array(phy_gbit_features_array,
171 			       ARRAY_SIZE(phy_gbit_features_array),
172 			       phy_gbit_all_ports_features);
173 
174 	/* 10/100 half/full + 1000 half/full + 10G full*/
175 	linkmode_set_bit_array(phy_all_ports_features_array,
176 			       ARRAY_SIZE(phy_all_ports_features_array),
177 			       phy_10gbit_features);
178 	linkmode_set_bit_array(phy_10_100_features_array,
179 			       ARRAY_SIZE(phy_10_100_features_array),
180 			       phy_10gbit_features);
181 	linkmode_set_bit_array(phy_gbit_features_array,
182 			       ARRAY_SIZE(phy_gbit_features_array),
183 			       phy_10gbit_features);
184 	linkmode_set_bit_array(phy_10gbit_features_array,
185 			       ARRAY_SIZE(phy_10gbit_features_array),
186 			       phy_10gbit_features);
187 
188 	/* 10/100/1000/10G full */
189 	linkmode_set_bit_array(phy_all_ports_features_array,
190 			       ARRAY_SIZE(phy_all_ports_features_array),
191 			       phy_10gbit_full_features);
192 	linkmode_set_bit_array(phy_10gbit_full_features_array,
193 			       ARRAY_SIZE(phy_10gbit_full_features_array),
194 			       phy_10gbit_full_features);
195 	/* 10G FEC only */
196 	linkmode_set_bit_array(phy_10gbit_fec_features_array,
197 			       ARRAY_SIZE(phy_10gbit_fec_features_array),
198 			       phy_10gbit_fec_features);
199 }
200 
201 void phy_device_free(struct phy_device *phydev)
202 {
203 	put_device(&phydev->mdio.dev);
204 }
205 EXPORT_SYMBOL(phy_device_free);
206 
207 static void phy_mdio_device_free(struct mdio_device *mdiodev)
208 {
209 	struct phy_device *phydev;
210 
211 	phydev = container_of(mdiodev, struct phy_device, mdio);
212 	phy_device_free(phydev);
213 }
214 
215 static void phy_device_release(struct device *dev)
216 {
217 	kfree(to_phy_device(dev));
218 }
219 
220 static void phy_mdio_device_remove(struct mdio_device *mdiodev)
221 {
222 	struct phy_device *phydev;
223 
224 	phydev = container_of(mdiodev, struct phy_device, mdio);
225 	phy_device_remove(phydev);
226 }
227 
228 static struct phy_driver genphy_driver;
229 extern struct phy_driver genphy_c45_driver;
230 
231 static LIST_HEAD(phy_fixup_list);
232 static DEFINE_MUTEX(phy_fixup_lock);
233 
234 #ifdef CONFIG_PM
235 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
236 {
237 	struct device_driver *drv = phydev->mdio.dev.driver;
238 	struct phy_driver *phydrv = to_phy_driver(drv);
239 	struct net_device *netdev = phydev->attached_dev;
240 
241 	if (!drv || !phydrv->suspend)
242 		return false;
243 
244 	/* PHY not attached? May suspend if the PHY has not already been
245 	 * suspended as part of a prior call to phy_disconnect() ->
246 	 * phy_detach() -> phy_suspend() because the parent netdev might be the
247 	 * MDIO bus driver and clock gated at this point.
248 	 */
249 	if (!netdev)
250 		goto out;
251 
252 	if (netdev->wol_enabled)
253 		return false;
254 
255 	/* As long as not all affected network drivers support the
256 	 * wol_enabled flag, let's check for hints that WoL is enabled.
257 	 * Don't suspend PHY if the attached netdev parent may wake up.
258 	 * The parent may point to a PCI device, as in tg3 driver.
259 	 */
260 	if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
261 		return false;
262 
263 	/* Also don't suspend PHY if the netdev itself may wakeup. This
264 	 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
265 	 * e.g. SoC devices.
266 	 */
267 	if (device_may_wakeup(&netdev->dev))
268 		return false;
269 
270 out:
271 	return !phydev->suspended;
272 }
273 
274 static int mdio_bus_phy_suspend(struct device *dev)
275 {
276 	struct phy_device *phydev = to_phy_device(dev);
277 
278 	/* We must stop the state machine manually, otherwise it stops out of
279 	 * control, possibly with the phydev->lock held. Upon resume, netdev
280 	 * may call phy routines that try to grab the same lock, and that may
281 	 * lead to a deadlock.
282 	 */
283 	if (phydev->attached_dev && phydev->adjust_link)
284 		phy_stop_machine(phydev);
285 
286 	if (!mdio_bus_phy_may_suspend(phydev))
287 		return 0;
288 
289 	phydev->suspended_by_mdio_bus = 1;
290 
291 	return phy_suspend(phydev);
292 }
293 
294 static int mdio_bus_phy_resume(struct device *dev)
295 {
296 	struct phy_device *phydev = to_phy_device(dev);
297 	int ret;
298 
299 	if (!phydev->suspended_by_mdio_bus)
300 		goto no_resume;
301 
302 	phydev->suspended_by_mdio_bus = 0;
303 
304 	ret = phy_resume(phydev);
305 	if (ret < 0)
306 		return ret;
307 
308 no_resume:
309 	if (phydev->attached_dev && phydev->adjust_link)
310 		phy_start_machine(phydev);
311 
312 	return 0;
313 }
314 
315 static int mdio_bus_phy_restore(struct device *dev)
316 {
317 	struct phy_device *phydev = to_phy_device(dev);
318 	struct net_device *netdev = phydev->attached_dev;
319 	int ret;
320 
321 	if (!netdev)
322 		return 0;
323 
324 	ret = phy_init_hw(phydev);
325 	if (ret < 0)
326 		return ret;
327 
328 	if (phydev->attached_dev && phydev->adjust_link)
329 		phy_start_machine(phydev);
330 
331 	return 0;
332 }
333 
334 static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
335 	.suspend = mdio_bus_phy_suspend,
336 	.resume = mdio_bus_phy_resume,
337 	.freeze = mdio_bus_phy_suspend,
338 	.thaw = mdio_bus_phy_resume,
339 	.restore = mdio_bus_phy_restore,
340 };
341 
342 #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
343 
344 #else
345 
346 #define MDIO_BUS_PHY_PM_OPS NULL
347 
348 #endif /* CONFIG_PM */
349 
350 /**
351  * phy_register_fixup - creates a new phy_fixup and adds it to the list
352  * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
353  * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
354  *	It can also be PHY_ANY_UID
355  * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
356  *	comparison
357  * @run: The actual code to be run when a matching PHY is found
358  */
359 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
360 		       int (*run)(struct phy_device *))
361 {
362 	struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
363 
364 	if (!fixup)
365 		return -ENOMEM;
366 
367 	strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
368 	fixup->phy_uid = phy_uid;
369 	fixup->phy_uid_mask = phy_uid_mask;
370 	fixup->run = run;
371 
372 	mutex_lock(&phy_fixup_lock);
373 	list_add_tail(&fixup->list, &phy_fixup_list);
374 	mutex_unlock(&phy_fixup_lock);
375 
376 	return 0;
377 }
378 EXPORT_SYMBOL(phy_register_fixup);
379 
380 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
381 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
382 			       int (*run)(struct phy_device *))
383 {
384 	return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
385 }
386 EXPORT_SYMBOL(phy_register_fixup_for_uid);
387 
388 /* Registers a fixup to be run on the PHY with id string bus_id */
389 int phy_register_fixup_for_id(const char *bus_id,
390 			      int (*run)(struct phy_device *))
391 {
392 	return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
393 }
394 EXPORT_SYMBOL(phy_register_fixup_for_id);
395 
396 /**
397  * phy_unregister_fixup - remove a phy_fixup from the list
398  * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
399  * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
400  * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
401  */
402 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
403 {
404 	struct list_head *pos, *n;
405 	struct phy_fixup *fixup;
406 	int ret;
407 
408 	ret = -ENODEV;
409 
410 	mutex_lock(&phy_fixup_lock);
411 	list_for_each_safe(pos, n, &phy_fixup_list) {
412 		fixup = list_entry(pos, struct phy_fixup, list);
413 
414 		if ((!strcmp(fixup->bus_id, bus_id)) &&
415 		    ((fixup->phy_uid & phy_uid_mask) ==
416 		     (phy_uid & phy_uid_mask))) {
417 			list_del(&fixup->list);
418 			kfree(fixup);
419 			ret = 0;
420 			break;
421 		}
422 	}
423 	mutex_unlock(&phy_fixup_lock);
424 
425 	return ret;
426 }
427 EXPORT_SYMBOL(phy_unregister_fixup);
428 
429 /* Unregisters a fixup of any PHY with the UID in phy_uid */
430 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
431 {
432 	return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
433 }
434 EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
435 
436 /* Unregisters a fixup of the PHY with id string bus_id */
437 int phy_unregister_fixup_for_id(const char *bus_id)
438 {
439 	return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
440 }
441 EXPORT_SYMBOL(phy_unregister_fixup_for_id);
442 
443 /* Returns 1 if fixup matches phydev in bus_id and phy_uid.
444  * Fixups can be set to match any in one or more fields.
445  */
446 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
447 {
448 	if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
449 		if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
450 			return 0;
451 
452 	if ((fixup->phy_uid & fixup->phy_uid_mask) !=
453 	    (phydev->phy_id & fixup->phy_uid_mask))
454 		if (fixup->phy_uid != PHY_ANY_UID)
455 			return 0;
456 
457 	return 1;
458 }
459 
460 /* Runs any matching fixups for this phydev */
461 static int phy_scan_fixups(struct phy_device *phydev)
462 {
463 	struct phy_fixup *fixup;
464 
465 	mutex_lock(&phy_fixup_lock);
466 	list_for_each_entry(fixup, &phy_fixup_list, list) {
467 		if (phy_needs_fixup(phydev, fixup)) {
468 			int err = fixup->run(phydev);
469 
470 			if (err < 0) {
471 				mutex_unlock(&phy_fixup_lock);
472 				return err;
473 			}
474 			phydev->has_fixups = true;
475 		}
476 	}
477 	mutex_unlock(&phy_fixup_lock);
478 
479 	return 0;
480 }
481 
482 static int phy_bus_match(struct device *dev, struct device_driver *drv)
483 {
484 	struct phy_device *phydev = to_phy_device(dev);
485 	struct phy_driver *phydrv = to_phy_driver(drv);
486 	const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
487 	int i;
488 
489 	if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
490 		return 0;
491 
492 	if (phydrv->match_phy_device)
493 		return phydrv->match_phy_device(phydev);
494 
495 	if (phydev->is_c45) {
496 		for (i = 1; i < num_ids; i++) {
497 			if (phydev->c45_ids.device_ids[i] == 0xffffffff)
498 				continue;
499 
500 			if ((phydrv->phy_id & phydrv->phy_id_mask) ==
501 			    (phydev->c45_ids.device_ids[i] &
502 			     phydrv->phy_id_mask))
503 				return 1;
504 		}
505 		return 0;
506 	} else {
507 		return (phydrv->phy_id & phydrv->phy_id_mask) ==
508 			(phydev->phy_id & phydrv->phy_id_mask);
509 	}
510 }
511 
512 static ssize_t
513 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
514 {
515 	struct phy_device *phydev = to_phy_device(dev);
516 
517 	return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
518 }
519 static DEVICE_ATTR_RO(phy_id);
520 
521 static ssize_t
522 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
523 {
524 	struct phy_device *phydev = to_phy_device(dev);
525 	const char *mode = NULL;
526 
527 	if (phy_is_internal(phydev))
528 		mode = "internal";
529 	else
530 		mode = phy_modes(phydev->interface);
531 
532 	return sprintf(buf, "%s\n", mode);
533 }
534 static DEVICE_ATTR_RO(phy_interface);
535 
536 static ssize_t
537 phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
538 		    char *buf)
539 {
540 	struct phy_device *phydev = to_phy_device(dev);
541 
542 	return sprintf(buf, "%d\n", phydev->has_fixups);
543 }
544 static DEVICE_ATTR_RO(phy_has_fixups);
545 
546 static struct attribute *phy_dev_attrs[] = {
547 	&dev_attr_phy_id.attr,
548 	&dev_attr_phy_interface.attr,
549 	&dev_attr_phy_has_fixups.attr,
550 	NULL,
551 };
552 ATTRIBUTE_GROUPS(phy_dev);
553 
554 static const struct device_type mdio_bus_phy_type = {
555 	.name = "PHY",
556 	.groups = phy_dev_groups,
557 	.release = phy_device_release,
558 	.pm = MDIO_BUS_PHY_PM_OPS,
559 };
560 
561 static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
562 {
563 	int ret;
564 
565 	ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
566 			     MDIO_ID_ARGS(phy_id));
567 	/* We only check for failures in executing the usermode binary,
568 	 * not whether a PHY driver module exists for the PHY ID.
569 	 * Accept -ENOENT because this may occur in case no initramfs exists,
570 	 * then modprobe isn't available.
571 	 */
572 	if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
573 		phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
574 			   ret, (unsigned long)phy_id);
575 		return ret;
576 	}
577 
578 	return 0;
579 }
580 
581 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
582 				     bool is_c45,
583 				     struct phy_c45_device_ids *c45_ids)
584 {
585 	struct phy_device *dev;
586 	struct mdio_device *mdiodev;
587 	int ret = 0;
588 
589 	/* We allocate the device, and initialize the default values */
590 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
591 	if (!dev)
592 		return ERR_PTR(-ENOMEM);
593 
594 	mdiodev = &dev->mdio;
595 	mdiodev->dev.parent = &bus->dev;
596 	mdiodev->dev.bus = &mdio_bus_type;
597 	mdiodev->dev.type = &mdio_bus_phy_type;
598 	mdiodev->bus = bus;
599 	mdiodev->bus_match = phy_bus_match;
600 	mdiodev->addr = addr;
601 	mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
602 	mdiodev->device_free = phy_mdio_device_free;
603 	mdiodev->device_remove = phy_mdio_device_remove;
604 
605 	dev->speed = SPEED_UNKNOWN;
606 	dev->duplex = DUPLEX_UNKNOWN;
607 	dev->pause = 0;
608 	dev->asym_pause = 0;
609 	dev->link = 0;
610 	dev->interface = PHY_INTERFACE_MODE_GMII;
611 
612 	dev->autoneg = AUTONEG_ENABLE;
613 
614 	dev->is_c45 = is_c45;
615 	dev->phy_id = phy_id;
616 	if (c45_ids)
617 		dev->c45_ids = *c45_ids;
618 	dev->irq = bus->irq[addr];
619 	dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
620 
621 	dev->state = PHY_DOWN;
622 
623 	mutex_init(&dev->lock);
624 	INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
625 
626 	/* Request the appropriate module unconditionally; don't
627 	 * bother trying to do so only if it isn't already loaded,
628 	 * because that gets complicated. A hotplug event would have
629 	 * done an unconditional modprobe anyway.
630 	 * We don't do normal hotplug because it won't work for MDIO
631 	 * -- because it relies on the device staying around for long
632 	 * enough for the driver to get loaded. With MDIO, the NIC
633 	 * driver will get bored and give up as soon as it finds that
634 	 * there's no driver _already_ loaded.
635 	 */
636 	if (is_c45 && c45_ids) {
637 		const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
638 		int i;
639 
640 		for (i = 1; i < num_ids; i++) {
641 			if (c45_ids->device_ids[i] == 0xffffffff)
642 				continue;
643 
644 			ret = phy_request_driver_module(dev,
645 						c45_ids->device_ids[i]);
646 			if (ret)
647 				break;
648 		}
649 	} else {
650 		ret = phy_request_driver_module(dev, phy_id);
651 	}
652 
653 	if (!ret) {
654 		device_initialize(&mdiodev->dev);
655 	} else {
656 		kfree(dev);
657 		dev = ERR_PTR(ret);
658 	}
659 
660 	return dev;
661 }
662 EXPORT_SYMBOL(phy_device_create);
663 
664 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
665  * @bus: the target MII bus
666  * @addr: PHY address on the MII bus
667  * @dev_addr: MMD address in the PHY.
668  * @devices_in_package: where to store the devices in package information.
669  *
670  * Description: reads devices in package registers of a MMD at @dev_addr
671  * from PHY at @addr on @bus.
672  *
673  * Returns: 0 on success, -EIO on failure.
674  */
675 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
676 				   u32 *devices_in_package)
677 {
678 	int phy_reg, reg_addr;
679 
680 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
681 	phy_reg = mdiobus_read(bus, addr, reg_addr);
682 	if (phy_reg < 0)
683 		return -EIO;
684 	*devices_in_package = phy_reg << 16;
685 
686 	reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
687 	phy_reg = mdiobus_read(bus, addr, reg_addr);
688 	if (phy_reg < 0)
689 		return -EIO;
690 	*devices_in_package |= phy_reg;
691 
692 	/* Bit 0 doesn't represent a device, it indicates c22 regs presence */
693 	*devices_in_package &= ~BIT(0);
694 
695 	return 0;
696 }
697 
698 /**
699  * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
700  * @bus: the target MII bus
701  * @addr: PHY address on the MII bus
702  * @phy_id: where to store the ID retrieved.
703  * @c45_ids: where to store the c45 ID information.
704  *
705  *   If the PHY devices-in-package appears to be valid, it and the
706  *   corresponding identifiers are stored in @c45_ids, zero is stored
707  *   in @phy_id.  Otherwise 0xffffffff is stored in @phy_id.  Returns
708  *   zero on success.
709  *
710  */
711 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
712 			   struct phy_c45_device_ids *c45_ids) {
713 	int phy_reg;
714 	int i, reg_addr;
715 	const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
716 	u32 *devs = &c45_ids->devices_in_package;
717 
718 	/* Find first non-zero Devices In package. Device zero is reserved
719 	 * for 802.3 c45 complied PHYs, so don't probe it at first.
720 	 */
721 	for (i = 1; i < num_ids && *devs == 0; i++) {
722 		phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
723 		if (phy_reg < 0)
724 			return -EIO;
725 
726 		if ((*devs & 0x1fffffff) == 0x1fffffff) {
727 			/*  If mostly Fs, there is no device there,
728 			 *  then let's continue to probe more, as some
729 			 *  10G PHYs have zero Devices In package,
730 			 *  e.g. Cortina CS4315/CS4340 PHY.
731 			 */
732 			phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
733 			if (phy_reg < 0)
734 				return -EIO;
735 			/* no device there, let's get out of here */
736 			if ((*devs & 0x1fffffff) == 0x1fffffff) {
737 				*phy_id = 0xffffffff;
738 				return 0;
739 			} else {
740 				break;
741 			}
742 		}
743 	}
744 
745 	/* Now probe Device Identifiers for each device present. */
746 	for (i = 1; i < num_ids; i++) {
747 		if (!(c45_ids->devices_in_package & (1 << i)))
748 			continue;
749 
750 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
751 		phy_reg = mdiobus_read(bus, addr, reg_addr);
752 		if (phy_reg < 0)
753 			return -EIO;
754 		c45_ids->device_ids[i] = phy_reg << 16;
755 
756 		reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
757 		phy_reg = mdiobus_read(bus, addr, reg_addr);
758 		if (phy_reg < 0)
759 			return -EIO;
760 		c45_ids->device_ids[i] |= phy_reg;
761 	}
762 	*phy_id = 0;
763 	return 0;
764 }
765 
766 /**
767  * get_phy_id - reads the specified addr for its ID.
768  * @bus: the target MII bus
769  * @addr: PHY address on the MII bus
770  * @phy_id: where to store the ID retrieved.
771  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
772  * @c45_ids: where to store the c45 ID information.
773  *
774  * Description: In the case of a 802.3-c22 PHY, reads the ID registers
775  *   of the PHY at @addr on the @bus, stores it in @phy_id and returns
776  *   zero on success.
777  *
778  *   In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
779  *   its return value is in turn returned.
780  *
781  */
782 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
783 		      bool is_c45, struct phy_c45_device_ids *c45_ids)
784 {
785 	int phy_reg;
786 
787 	if (is_c45)
788 		return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
789 
790 	/* Grab the bits from PHYIR1, and put them in the upper half */
791 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
792 	if (phy_reg < 0) {
793 		/* returning -ENODEV doesn't stop bus scanning */
794 		return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
795 	}
796 
797 	*phy_id = phy_reg << 16;
798 
799 	/* Grab the bits from PHYIR2, and put them in the lower half */
800 	phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
801 	if (phy_reg < 0)
802 		return -EIO;
803 
804 	*phy_id |= phy_reg;
805 
806 	return 0;
807 }
808 
809 /**
810  * get_phy_device - reads the specified PHY device and returns its @phy_device
811  *		    struct
812  * @bus: the target MII bus
813  * @addr: PHY address on the MII bus
814  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
815  *
816  * Description: Reads the ID registers of the PHY at @addr on the
817  *   @bus, then allocates and returns the phy_device to represent it.
818  */
819 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
820 {
821 	struct phy_c45_device_ids c45_ids;
822 	u32 phy_id = 0;
823 	int r;
824 
825 	c45_ids.devices_in_package = 0;
826 	memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
827 
828 	r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
829 	if (r)
830 		return ERR_PTR(r);
831 
832 	/* If the phy_id is mostly Fs, there is no device there */
833 	if ((phy_id & 0x1fffffff) == 0x1fffffff)
834 		return ERR_PTR(-ENODEV);
835 
836 	return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
837 }
838 EXPORT_SYMBOL(get_phy_device);
839 
840 /**
841  * phy_device_register - Register the phy device on the MDIO bus
842  * @phydev: phy_device structure to be added to the MDIO bus
843  */
844 int phy_device_register(struct phy_device *phydev)
845 {
846 	int err;
847 
848 	err = mdiobus_register_device(&phydev->mdio);
849 	if (err)
850 		return err;
851 
852 	/* Deassert the reset signal */
853 	phy_device_reset(phydev, 0);
854 
855 	/* Run all of the fixups for this PHY */
856 	err = phy_scan_fixups(phydev);
857 	if (err) {
858 		phydev_err(phydev, "failed to initialize\n");
859 		goto out;
860 	}
861 
862 	err = device_add(&phydev->mdio.dev);
863 	if (err) {
864 		phydev_err(phydev, "failed to add\n");
865 		goto out;
866 	}
867 
868 	return 0;
869 
870  out:
871 	/* Assert the reset signal */
872 	phy_device_reset(phydev, 1);
873 
874 	mdiobus_unregister_device(&phydev->mdio);
875 	return err;
876 }
877 EXPORT_SYMBOL(phy_device_register);
878 
879 /**
880  * phy_device_remove - Remove a previously registered phy device from the MDIO bus
881  * @phydev: phy_device structure to remove
882  *
883  * This doesn't free the phy_device itself, it merely reverses the effects
884  * of phy_device_register(). Use phy_device_free() to free the device
885  * after calling this function.
886  */
887 void phy_device_remove(struct phy_device *phydev)
888 {
889 	if (phydev->mii_ts)
890 		unregister_mii_timestamper(phydev->mii_ts);
891 
892 	device_del(&phydev->mdio.dev);
893 
894 	/* Assert the reset signal */
895 	phy_device_reset(phydev, 1);
896 
897 	mdiobus_unregister_device(&phydev->mdio);
898 }
899 EXPORT_SYMBOL(phy_device_remove);
900 
901 /**
902  * phy_find_first - finds the first PHY device on the bus
903  * @bus: the target MII bus
904  */
905 struct phy_device *phy_find_first(struct mii_bus *bus)
906 {
907 	struct phy_device *phydev;
908 	int addr;
909 
910 	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
911 		phydev = mdiobus_get_phy(bus, addr);
912 		if (phydev)
913 			return phydev;
914 	}
915 	return NULL;
916 }
917 EXPORT_SYMBOL(phy_find_first);
918 
919 static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
920 {
921 	struct net_device *netdev = phydev->attached_dev;
922 
923 	if (do_carrier) {
924 		if (up)
925 			netif_carrier_on(netdev);
926 		else
927 			netif_carrier_off(netdev);
928 	}
929 	phydev->adjust_link(netdev);
930 	if (phydev->mii_ts && phydev->mii_ts->link_state)
931 		phydev->mii_ts->link_state(phydev->mii_ts, phydev);
932 }
933 
934 /**
935  * phy_prepare_link - prepares the PHY layer to monitor link status
936  * @phydev: target phy_device struct
937  * @handler: callback function for link status change notifications
938  *
939  * Description: Tells the PHY infrastructure to handle the
940  *   gory details on monitoring link status (whether through
941  *   polling or an interrupt), and to call back to the
942  *   connected device driver when the link status changes.
943  *   If you want to monitor your own link state, don't call
944  *   this function.
945  */
946 static void phy_prepare_link(struct phy_device *phydev,
947 			     void (*handler)(struct net_device *))
948 {
949 	phydev->adjust_link = handler;
950 }
951 
952 /**
953  * phy_connect_direct - connect an ethernet device to a specific phy_device
954  * @dev: the network device to connect
955  * @phydev: the pointer to the phy device
956  * @handler: callback function for state change notifications
957  * @interface: PHY device's interface
958  */
959 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
960 		       void (*handler)(struct net_device *),
961 		       phy_interface_t interface)
962 {
963 	int rc;
964 
965 	if (!dev)
966 		return -EINVAL;
967 
968 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
969 	if (rc)
970 		return rc;
971 
972 	phy_prepare_link(phydev, handler);
973 	if (phy_interrupt_is_valid(phydev))
974 		phy_request_interrupt(phydev);
975 
976 	return 0;
977 }
978 EXPORT_SYMBOL(phy_connect_direct);
979 
980 /**
981  * phy_connect - connect an ethernet device to a PHY device
982  * @dev: the network device to connect
983  * @bus_id: the id string of the PHY device to connect
984  * @handler: callback function for state change notifications
985  * @interface: PHY device's interface
986  *
987  * Description: Convenience function for connecting ethernet
988  *   devices to PHY devices.  The default behavior is for
989  *   the PHY infrastructure to handle everything, and only notify
990  *   the connected driver when the link status changes.  If you
991  *   don't want, or can't use the provided functionality, you may
992  *   choose to call only the subset of functions which provide
993  *   the desired functionality.
994  */
995 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
996 			       void (*handler)(struct net_device *),
997 			       phy_interface_t interface)
998 {
999 	struct phy_device *phydev;
1000 	struct device *d;
1001 	int rc;
1002 
1003 	/* Search the list of PHY devices on the mdio bus for the
1004 	 * PHY with the requested name
1005 	 */
1006 	d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1007 	if (!d) {
1008 		pr_err("PHY %s not found\n", bus_id);
1009 		return ERR_PTR(-ENODEV);
1010 	}
1011 	phydev = to_phy_device(d);
1012 
1013 	rc = phy_connect_direct(dev, phydev, handler, interface);
1014 	put_device(d);
1015 	if (rc)
1016 		return ERR_PTR(rc);
1017 
1018 	return phydev;
1019 }
1020 EXPORT_SYMBOL(phy_connect);
1021 
1022 /**
1023  * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1024  *		    device
1025  * @phydev: target phy_device struct
1026  */
1027 void phy_disconnect(struct phy_device *phydev)
1028 {
1029 	if (phy_is_started(phydev))
1030 		phy_stop(phydev);
1031 
1032 	if (phy_interrupt_is_valid(phydev))
1033 		phy_free_interrupt(phydev);
1034 
1035 	phydev->adjust_link = NULL;
1036 
1037 	phy_detach(phydev);
1038 }
1039 EXPORT_SYMBOL(phy_disconnect);
1040 
1041 /**
1042  * phy_poll_reset - Safely wait until a PHY reset has properly completed
1043  * @phydev: The PHY device to poll
1044  *
1045  * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1046  *   published in 2008, a PHY reset may take up to 0.5 seconds.  The MII BMCR
1047  *   register must be polled until the BMCR_RESET bit clears.
1048  *
1049  *   Furthermore, any attempts to write to PHY registers may have no effect
1050  *   or even generate MDIO bus errors until this is complete.
1051  *
1052  *   Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1053  *   standard and do not fully reset after the BMCR_RESET bit is set, and may
1054  *   even *REQUIRE* a soft-reset to properly restart autonegotiation.  In an
1055  *   effort to support such broken PHYs, this function is separate from the
1056  *   standard phy_init_hw() which will zero all the other bits in the BMCR
1057  *   and reapply all driver-specific and board-specific fixups.
1058  */
1059 static int phy_poll_reset(struct phy_device *phydev)
1060 {
1061 	/* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1062 	unsigned int retries = 12;
1063 	int ret;
1064 
1065 	do {
1066 		msleep(50);
1067 		ret = phy_read(phydev, MII_BMCR);
1068 		if (ret < 0)
1069 			return ret;
1070 	} while (ret & BMCR_RESET && --retries);
1071 	if (ret & BMCR_RESET)
1072 		return -ETIMEDOUT;
1073 
1074 	/* Some chips (smsc911x) may still need up to another 1ms after the
1075 	 * BMCR_RESET bit is cleared before they are usable.
1076 	 */
1077 	msleep(1);
1078 	return 0;
1079 }
1080 
1081 int phy_init_hw(struct phy_device *phydev)
1082 {
1083 	int ret = 0;
1084 
1085 	/* Deassert the reset signal */
1086 	phy_device_reset(phydev, 0);
1087 
1088 	if (!phydev->drv)
1089 		return 0;
1090 
1091 	if (phydev->drv->soft_reset)
1092 		ret = phydev->drv->soft_reset(phydev);
1093 
1094 	if (ret < 0)
1095 		return ret;
1096 
1097 	ret = phy_scan_fixups(phydev);
1098 	if (ret < 0)
1099 		return ret;
1100 
1101 	if (phydev->drv->config_init)
1102 		ret = phydev->drv->config_init(phydev);
1103 
1104 	return ret;
1105 }
1106 EXPORT_SYMBOL(phy_init_hw);
1107 
1108 void phy_attached_info(struct phy_device *phydev)
1109 {
1110 	phy_attached_print(phydev, NULL);
1111 }
1112 EXPORT_SYMBOL(phy_attached_info);
1113 
1114 #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
1115 char *phy_attached_info_irq(struct phy_device *phydev)
1116 {
1117 	char *irq_str;
1118 	char irq_num[8];
1119 
1120 	switch(phydev->irq) {
1121 	case PHY_POLL:
1122 		irq_str = "POLL";
1123 		break;
1124 	case PHY_IGNORE_INTERRUPT:
1125 		irq_str = "IGNORE";
1126 		break;
1127 	default:
1128 		snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1129 		irq_str = irq_num;
1130 		break;
1131 	}
1132 
1133 	return kasprintf(GFP_KERNEL, "%s", irq_str);
1134 }
1135 EXPORT_SYMBOL(phy_attached_info_irq);
1136 
1137 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1138 {
1139 	const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
1140 	char *irq_str = phy_attached_info_irq(phydev);
1141 
1142 	if (!fmt) {
1143 		phydev_info(phydev, ATTACHED_FMT "\n",
1144 			 drv_name, phydev_name(phydev),
1145 			 irq_str);
1146 	} else {
1147 		va_list ap;
1148 
1149 		phydev_info(phydev, ATTACHED_FMT,
1150 			 drv_name, phydev_name(phydev),
1151 			 irq_str);
1152 
1153 		va_start(ap, fmt);
1154 		vprintk(fmt, ap);
1155 		va_end(ap);
1156 	}
1157 	kfree(irq_str);
1158 }
1159 EXPORT_SYMBOL(phy_attached_print);
1160 
1161 static void phy_sysfs_create_links(struct phy_device *phydev)
1162 {
1163 	struct net_device *dev = phydev->attached_dev;
1164 	int err;
1165 
1166 	if (!dev)
1167 		return;
1168 
1169 	err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1170 				"attached_dev");
1171 	if (err)
1172 		return;
1173 
1174 	err = sysfs_create_link_nowarn(&dev->dev.kobj,
1175 				       &phydev->mdio.dev.kobj,
1176 				       "phydev");
1177 	if (err) {
1178 		dev_err(&dev->dev, "could not add device link to %s err %d\n",
1179 			kobject_name(&phydev->mdio.dev.kobj),
1180 			err);
1181 		/* non-fatal - some net drivers can use one netdevice
1182 		 * with more then one phy
1183 		 */
1184 	}
1185 
1186 	phydev->sysfs_links = true;
1187 }
1188 
1189 static ssize_t
1190 phy_standalone_show(struct device *dev, struct device_attribute *attr,
1191 		    char *buf)
1192 {
1193 	struct phy_device *phydev = to_phy_device(dev);
1194 
1195 	return sprintf(buf, "%d\n", !phydev->attached_dev);
1196 }
1197 static DEVICE_ATTR_RO(phy_standalone);
1198 
1199 /**
1200  * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1201  * @upstream: pointer to the phy device
1202  * @bus: sfp bus representing cage being attached
1203  *
1204  * This is used to fill in the sfp_upstream_ops .attach member.
1205  */
1206 void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1207 {
1208 	struct phy_device *phydev = upstream;
1209 
1210 	if (phydev->attached_dev)
1211 		phydev->attached_dev->sfp_bus = bus;
1212 	phydev->sfp_bus_attached = true;
1213 }
1214 EXPORT_SYMBOL(phy_sfp_attach);
1215 
1216 /**
1217  * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1218  * @upstream: pointer to the phy device
1219  * @bus: sfp bus representing cage being attached
1220  *
1221  * This is used to fill in the sfp_upstream_ops .detach member.
1222  */
1223 void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1224 {
1225 	struct phy_device *phydev = upstream;
1226 
1227 	if (phydev->attached_dev)
1228 		phydev->attached_dev->sfp_bus = NULL;
1229 	phydev->sfp_bus_attached = false;
1230 }
1231 EXPORT_SYMBOL(phy_sfp_detach);
1232 
1233 /**
1234  * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1235  * @phydev: Pointer to phy_device
1236  * @ops: SFP's upstream operations
1237  */
1238 int phy_sfp_probe(struct phy_device *phydev,
1239 		  const struct sfp_upstream_ops *ops)
1240 {
1241 	struct sfp_bus *bus;
1242 	int ret;
1243 
1244 	if (phydev->mdio.dev.fwnode) {
1245 		bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1246 		if (IS_ERR(bus))
1247 			return PTR_ERR(bus);
1248 
1249 		phydev->sfp_bus = bus;
1250 
1251 		ret = sfp_bus_add_upstream(bus, phydev, ops);
1252 		sfp_bus_put(bus);
1253 	}
1254 	return 0;
1255 }
1256 EXPORT_SYMBOL(phy_sfp_probe);
1257 
1258 /**
1259  * phy_attach_direct - attach a network device to a given PHY device pointer
1260  * @dev: network device to attach
1261  * @phydev: Pointer to phy_device to attach
1262  * @flags: PHY device's dev_flags
1263  * @interface: PHY device's interface
1264  *
1265  * Description: Called by drivers to attach to a particular PHY
1266  *     device. The phy_device is found, and properly hooked up
1267  *     to the phy_driver.  If no driver is attached, then a
1268  *     generic driver is used.  The phy_device is given a ptr to
1269  *     the attaching device, and given a callback for link status
1270  *     change.  The phy_device is returned to the attaching driver.
1271  *     This function takes a reference on the phy device.
1272  */
1273 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1274 		      u32 flags, phy_interface_t interface)
1275 {
1276 	struct mii_bus *bus = phydev->mdio.bus;
1277 	struct device *d = &phydev->mdio.dev;
1278 	struct module *ndev_owner = NULL;
1279 	bool using_genphy = false;
1280 	int err;
1281 
1282 	/* For Ethernet device drivers that register their own MDIO bus, we
1283 	 * will have bus->owner match ndev_mod, so we do not want to increment
1284 	 * our own module->refcnt here, otherwise we would not be able to
1285 	 * unload later on.
1286 	 */
1287 	if (dev)
1288 		ndev_owner = dev->dev.parent->driver->owner;
1289 	if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1290 		phydev_err(phydev, "failed to get the bus module\n");
1291 		return -EIO;
1292 	}
1293 
1294 	get_device(d);
1295 
1296 	/* Assume that if there is no driver, that it doesn't
1297 	 * exist, and we should use the genphy driver.
1298 	 */
1299 	if (!d->driver) {
1300 		if (phydev->is_c45)
1301 			d->driver = &genphy_c45_driver.mdiodrv.driver;
1302 		else
1303 			d->driver = &genphy_driver.mdiodrv.driver;
1304 
1305 		using_genphy = true;
1306 	}
1307 
1308 	if (!try_module_get(d->driver->owner)) {
1309 		phydev_err(phydev, "failed to get the device driver module\n");
1310 		err = -EIO;
1311 		goto error_put_device;
1312 	}
1313 
1314 	if (using_genphy) {
1315 		err = d->driver->probe(d);
1316 		if (err >= 0)
1317 			err = device_bind_driver(d);
1318 
1319 		if (err)
1320 			goto error_module_put;
1321 	}
1322 
1323 	if (phydev->attached_dev) {
1324 		dev_err(&dev->dev, "PHY already attached\n");
1325 		err = -EBUSY;
1326 		goto error;
1327 	}
1328 
1329 	phydev->phy_link_change = phy_link_change;
1330 	if (dev) {
1331 		phydev->attached_dev = dev;
1332 		dev->phydev = phydev;
1333 
1334 		if (phydev->sfp_bus_attached)
1335 			dev->sfp_bus = phydev->sfp_bus;
1336 	}
1337 
1338 	/* Some Ethernet drivers try to connect to a PHY device before
1339 	 * calling register_netdevice() -> netdev_register_kobject() and
1340 	 * does the dev->dev.kobj initialization. Here we only check for
1341 	 * success which indicates that the network device kobject is
1342 	 * ready. Once we do that we still need to keep track of whether
1343 	 * links were successfully set up or not for phy_detach() to
1344 	 * remove them accordingly.
1345 	 */
1346 	phydev->sysfs_links = false;
1347 
1348 	phy_sysfs_create_links(phydev);
1349 
1350 	if (!phydev->attached_dev) {
1351 		err = sysfs_create_file(&phydev->mdio.dev.kobj,
1352 					&dev_attr_phy_standalone.attr);
1353 		if (err)
1354 			phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1355 	}
1356 
1357 	phydev->dev_flags |= flags;
1358 
1359 	phydev->interface = interface;
1360 
1361 	phydev->state = PHY_READY;
1362 
1363 	/* Initial carrier state is off as the phy is about to be
1364 	 * (re)initialized.
1365 	 */
1366 	if (dev)
1367 		netif_carrier_off(phydev->attached_dev);
1368 
1369 	/* Do initial configuration here, now that
1370 	 * we have certain key parameters
1371 	 * (dev_flags and interface)
1372 	 */
1373 	err = phy_init_hw(phydev);
1374 	if (err)
1375 		goto error;
1376 
1377 	phy_resume(phydev);
1378 	phy_led_triggers_register(phydev);
1379 
1380 	return err;
1381 
1382 error:
1383 	/* phy_detach() does all of the cleanup below */
1384 	phy_detach(phydev);
1385 	return err;
1386 
1387 error_module_put:
1388 	module_put(d->driver->owner);
1389 error_put_device:
1390 	put_device(d);
1391 	if (ndev_owner != bus->owner)
1392 		module_put(bus->owner);
1393 	return err;
1394 }
1395 EXPORT_SYMBOL(phy_attach_direct);
1396 
1397 /**
1398  * phy_attach - attach a network device to a particular PHY device
1399  * @dev: network device to attach
1400  * @bus_id: Bus ID of PHY device to attach
1401  * @interface: PHY device's interface
1402  *
1403  * Description: Same as phy_attach_direct() except that a PHY bus_id
1404  *     string is passed instead of a pointer to a struct phy_device.
1405  */
1406 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1407 			      phy_interface_t interface)
1408 {
1409 	struct bus_type *bus = &mdio_bus_type;
1410 	struct phy_device *phydev;
1411 	struct device *d;
1412 	int rc;
1413 
1414 	if (!dev)
1415 		return ERR_PTR(-EINVAL);
1416 
1417 	/* Search the list of PHY devices on the mdio bus for the
1418 	 * PHY with the requested name
1419 	 */
1420 	d = bus_find_device_by_name(bus, NULL, bus_id);
1421 	if (!d) {
1422 		pr_err("PHY %s not found\n", bus_id);
1423 		return ERR_PTR(-ENODEV);
1424 	}
1425 	phydev = to_phy_device(d);
1426 
1427 	rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1428 	put_device(d);
1429 	if (rc)
1430 		return ERR_PTR(rc);
1431 
1432 	return phydev;
1433 }
1434 EXPORT_SYMBOL(phy_attach);
1435 
1436 static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1437 				      struct device_driver *driver)
1438 {
1439 	struct device *d = &phydev->mdio.dev;
1440 	bool ret = false;
1441 
1442 	if (!phydev->drv)
1443 		return ret;
1444 
1445 	get_device(d);
1446 	ret = d->driver == driver;
1447 	put_device(d);
1448 
1449 	return ret;
1450 }
1451 
1452 bool phy_driver_is_genphy(struct phy_device *phydev)
1453 {
1454 	return phy_driver_is_genphy_kind(phydev,
1455 					 &genphy_driver.mdiodrv.driver);
1456 }
1457 EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
1458 
1459 bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1460 {
1461 	return phy_driver_is_genphy_kind(phydev,
1462 					 &genphy_c45_driver.mdiodrv.driver);
1463 }
1464 EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
1465 
1466 /**
1467  * phy_detach - detach a PHY device from its network device
1468  * @phydev: target phy_device struct
1469  *
1470  * This detaches the phy device from its network device and the phy
1471  * driver, and drops the reference count taken in phy_attach_direct().
1472  */
1473 void phy_detach(struct phy_device *phydev)
1474 {
1475 	struct net_device *dev = phydev->attached_dev;
1476 	struct module *ndev_owner = NULL;
1477 	struct mii_bus *bus;
1478 
1479 	if (phydev->sysfs_links) {
1480 		if (dev)
1481 			sysfs_remove_link(&dev->dev.kobj, "phydev");
1482 		sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1483 	}
1484 
1485 	if (!phydev->attached_dev)
1486 		sysfs_remove_file(&phydev->mdio.dev.kobj,
1487 				  &dev_attr_phy_standalone.attr);
1488 
1489 	phy_suspend(phydev);
1490 	if (dev) {
1491 		phydev->attached_dev->phydev = NULL;
1492 		phydev->attached_dev = NULL;
1493 	}
1494 	phydev->phylink = NULL;
1495 
1496 	phy_led_triggers_unregister(phydev);
1497 
1498 	module_put(phydev->mdio.dev.driver->owner);
1499 
1500 	/* If the device had no specific driver before (i.e. - it
1501 	 * was using the generic driver), we unbind the device
1502 	 * from the generic driver so that there's a chance a
1503 	 * real driver could be loaded
1504 	 */
1505 	if (phy_driver_is_genphy(phydev) ||
1506 	    phy_driver_is_genphy_10g(phydev))
1507 		device_release_driver(&phydev->mdio.dev);
1508 
1509 	/*
1510 	 * The phydev might go away on the put_device() below, so avoid
1511 	 * a use-after-free bug by reading the underlying bus first.
1512 	 */
1513 	bus = phydev->mdio.bus;
1514 
1515 	put_device(&phydev->mdio.dev);
1516 	if (dev)
1517 		ndev_owner = dev->dev.parent->driver->owner;
1518 	if (ndev_owner != bus->owner)
1519 		module_put(bus->owner);
1520 
1521 	/* Assert the reset signal */
1522 	phy_device_reset(phydev, 1);
1523 }
1524 EXPORT_SYMBOL(phy_detach);
1525 
1526 int phy_suspend(struct phy_device *phydev)
1527 {
1528 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1529 	struct net_device *netdev = phydev->attached_dev;
1530 	struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1531 	int ret = 0;
1532 
1533 	/* If the device has WOL enabled, we cannot suspend the PHY */
1534 	phy_ethtool_get_wol(phydev, &wol);
1535 	if (wol.wolopts || (netdev && netdev->wol_enabled))
1536 		return -EBUSY;
1537 
1538 	if (phydev->drv && phydrv->suspend)
1539 		ret = phydrv->suspend(phydev);
1540 
1541 	if (ret)
1542 		return ret;
1543 
1544 	phydev->suspended = true;
1545 
1546 	return ret;
1547 }
1548 EXPORT_SYMBOL(phy_suspend);
1549 
1550 int __phy_resume(struct phy_device *phydev)
1551 {
1552 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1553 	int ret = 0;
1554 
1555 	WARN_ON(!mutex_is_locked(&phydev->lock));
1556 
1557 	if (phydev->drv && phydrv->resume)
1558 		ret = phydrv->resume(phydev);
1559 
1560 	if (ret)
1561 		return ret;
1562 
1563 	phydev->suspended = false;
1564 
1565 	return ret;
1566 }
1567 EXPORT_SYMBOL(__phy_resume);
1568 
1569 int phy_resume(struct phy_device *phydev)
1570 {
1571 	int ret;
1572 
1573 	mutex_lock(&phydev->lock);
1574 	ret = __phy_resume(phydev);
1575 	mutex_unlock(&phydev->lock);
1576 
1577 	return ret;
1578 }
1579 EXPORT_SYMBOL(phy_resume);
1580 
1581 int phy_loopback(struct phy_device *phydev, bool enable)
1582 {
1583 	struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1584 	int ret = 0;
1585 
1586 	mutex_lock(&phydev->lock);
1587 
1588 	if (enable && phydev->loopback_enabled) {
1589 		ret = -EBUSY;
1590 		goto out;
1591 	}
1592 
1593 	if (!enable && !phydev->loopback_enabled) {
1594 		ret = -EINVAL;
1595 		goto out;
1596 	}
1597 
1598 	if (phydev->drv && phydrv->set_loopback)
1599 		ret = phydrv->set_loopback(phydev, enable);
1600 	else
1601 		ret = -EOPNOTSUPP;
1602 
1603 	if (ret)
1604 		goto out;
1605 
1606 	phydev->loopback_enabled = enable;
1607 
1608 out:
1609 	mutex_unlock(&phydev->lock);
1610 	return ret;
1611 }
1612 EXPORT_SYMBOL(phy_loopback);
1613 
1614 /**
1615  * phy_reset_after_clk_enable - perform a PHY reset if needed
1616  * @phydev: target phy_device struct
1617  *
1618  * Description: Some PHYs are known to need a reset after their refclk was
1619  *   enabled. This function evaluates the flags and perform the reset if it's
1620  *   needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1621  *   was reset.
1622  */
1623 int phy_reset_after_clk_enable(struct phy_device *phydev)
1624 {
1625 	if (!phydev || !phydev->drv)
1626 		return -ENODEV;
1627 
1628 	if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1629 		phy_device_reset(phydev, 1);
1630 		phy_device_reset(phydev, 0);
1631 		return 1;
1632 	}
1633 
1634 	return 0;
1635 }
1636 EXPORT_SYMBOL(phy_reset_after_clk_enable);
1637 
1638 /* Generic PHY support and helper functions */
1639 
1640 /**
1641  * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1642  * @phydev: target phy_device struct
1643  *
1644  * Description: Writes MII_ADVERTISE with the appropriate values,
1645  *   after sanitizing the values to make sure we only advertise
1646  *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
1647  *   hasn't changed, and > 0 if it has changed.
1648  */
1649 static int genphy_config_advert(struct phy_device *phydev)
1650 {
1651 	int err, bmsr, changed = 0;
1652 	u32 adv;
1653 
1654 	/* Only allow advertising what this PHY supports */
1655 	linkmode_and(phydev->advertising, phydev->advertising,
1656 		     phydev->supported);
1657 
1658 	adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1659 
1660 	/* Setup standard advertisement */
1661 	err = phy_modify_changed(phydev, MII_ADVERTISE,
1662 				 ADVERTISE_ALL | ADVERTISE_100BASE4 |
1663 				 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
1664 				 adv);
1665 	if (err < 0)
1666 		return err;
1667 	if (err > 0)
1668 		changed = 1;
1669 
1670 	bmsr = phy_read(phydev, MII_BMSR);
1671 	if (bmsr < 0)
1672 		return bmsr;
1673 
1674 	/* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1675 	 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1676 	 * logical 1.
1677 	 */
1678 	if (!(bmsr & BMSR_ESTATEN))
1679 		return changed;
1680 
1681 	adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1682 
1683 	err = phy_modify_changed(phydev, MII_CTRL1000,
1684 				 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
1685 				 adv);
1686 	if (err < 0)
1687 		return err;
1688 	if (err > 0)
1689 		changed = 1;
1690 
1691 	return changed;
1692 }
1693 
1694 /**
1695  * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
1696  * @phydev: target phy_device struct
1697  *
1698  * Description: Writes MII_ADVERTISE with the appropriate values,
1699  *   after sanitizing the values to make sure we only advertise
1700  *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
1701  *   hasn't changed, and > 0 if it has changed. This function is intended
1702  *   for Clause 37 1000Base-X mode.
1703  */
1704 static int genphy_c37_config_advert(struct phy_device *phydev)
1705 {
1706 	u16 adv = 0;
1707 
1708 	/* Only allow advertising what this PHY supports */
1709 	linkmode_and(phydev->advertising, phydev->advertising,
1710 		     phydev->supported);
1711 
1712 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
1713 			      phydev->advertising))
1714 		adv |= ADVERTISE_1000XFULL;
1715 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1716 			      phydev->advertising))
1717 		adv |= ADVERTISE_1000XPAUSE;
1718 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1719 			      phydev->advertising))
1720 		adv |= ADVERTISE_1000XPSE_ASYM;
1721 
1722 	return phy_modify_changed(phydev, MII_ADVERTISE,
1723 				  ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
1724 				  ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
1725 				  adv);
1726 }
1727 
1728 /**
1729  * genphy_config_eee_advert - disable unwanted eee mode advertisement
1730  * @phydev: target phy_device struct
1731  *
1732  * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1733  *   efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1734  *   changed, and 1 if it has changed.
1735  */
1736 int genphy_config_eee_advert(struct phy_device *phydev)
1737 {
1738 	int err;
1739 
1740 	/* Nothing to disable */
1741 	if (!phydev->eee_broken_modes)
1742 		return 0;
1743 
1744 	err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
1745 				     phydev->eee_broken_modes, 0);
1746 	/* If the call failed, we assume that EEE is not supported */
1747 	return err < 0 ? 0 : err;
1748 }
1749 EXPORT_SYMBOL(genphy_config_eee_advert);
1750 
1751 /**
1752  * genphy_setup_forced - configures/forces speed/duplex from @phydev
1753  * @phydev: target phy_device struct
1754  *
1755  * Description: Configures MII_BMCR to force speed/duplex
1756  *   to the values in phydev. Assumes that the values are valid.
1757  *   Please see phy_sanitize_settings().
1758  */
1759 int genphy_setup_forced(struct phy_device *phydev)
1760 {
1761 	u16 ctl = 0;
1762 
1763 	phydev->pause = 0;
1764 	phydev->asym_pause = 0;
1765 
1766 	if (SPEED_1000 == phydev->speed)
1767 		ctl |= BMCR_SPEED1000;
1768 	else if (SPEED_100 == phydev->speed)
1769 		ctl |= BMCR_SPEED100;
1770 
1771 	if (DUPLEX_FULL == phydev->duplex)
1772 		ctl |= BMCR_FULLDPLX;
1773 
1774 	return phy_modify(phydev, MII_BMCR,
1775 			  ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
1776 }
1777 EXPORT_SYMBOL(genphy_setup_forced);
1778 
1779 /**
1780  * genphy_restart_aneg - Enable and Restart Autonegotiation
1781  * @phydev: target phy_device struct
1782  */
1783 int genphy_restart_aneg(struct phy_device *phydev)
1784 {
1785 	/* Don't isolate the PHY if we're negotiating */
1786 	return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1787 			  BMCR_ANENABLE | BMCR_ANRESTART);
1788 }
1789 EXPORT_SYMBOL(genphy_restart_aneg);
1790 
1791 /**
1792  * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
1793  * @phydev: target phy_device struct
1794  * @restart: whether aneg restart is requested
1795  *
1796  * Check, and restart auto-negotiation if needed.
1797  */
1798 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
1799 {
1800 	int ret;
1801 
1802 	if (!restart) {
1803 		/* Advertisement hasn't changed, but maybe aneg was never on to
1804 		 * begin with?  Or maybe phy was isolated?
1805 		 */
1806 		ret = phy_read(phydev, MII_BMCR);
1807 		if (ret < 0)
1808 			return ret;
1809 
1810 		if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
1811 			restart = true;
1812 	}
1813 
1814 	if (restart)
1815 		return genphy_restart_aneg(phydev);
1816 
1817 	return 0;
1818 }
1819 EXPORT_SYMBOL(genphy_check_and_restart_aneg);
1820 
1821 /**
1822  * __genphy_config_aneg - restart auto-negotiation or write BMCR
1823  * @phydev: target phy_device struct
1824  * @changed: whether autoneg is requested
1825  *
1826  * Description: If auto-negotiation is enabled, we configure the
1827  *   advertising, and then restart auto-negotiation.  If it is not
1828  *   enabled, then we write the BMCR.
1829  */
1830 int __genphy_config_aneg(struct phy_device *phydev, bool changed)
1831 {
1832 	int err;
1833 
1834 	if (genphy_config_eee_advert(phydev))
1835 		changed = true;
1836 
1837 	if (AUTONEG_ENABLE != phydev->autoneg)
1838 		return genphy_setup_forced(phydev);
1839 
1840 	err = genphy_config_advert(phydev);
1841 	if (err < 0) /* error */
1842 		return err;
1843 	else if (err)
1844 		changed = true;
1845 
1846 	return genphy_check_and_restart_aneg(phydev, changed);
1847 }
1848 EXPORT_SYMBOL(__genphy_config_aneg);
1849 
1850 /**
1851  * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
1852  * @phydev: target phy_device struct
1853  *
1854  * Description: If auto-negotiation is enabled, we configure the
1855  *   advertising, and then restart auto-negotiation.  If it is not
1856  *   enabled, then we write the BMCR. This function is intended
1857  *   for use with Clause 37 1000Base-X mode.
1858  */
1859 int genphy_c37_config_aneg(struct phy_device *phydev)
1860 {
1861 	int err, changed;
1862 
1863 	if (phydev->autoneg != AUTONEG_ENABLE)
1864 		return genphy_setup_forced(phydev);
1865 
1866 	err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
1867 			 BMCR_SPEED1000);
1868 	if (err)
1869 		return err;
1870 
1871 	changed = genphy_c37_config_advert(phydev);
1872 	if (changed < 0) /* error */
1873 		return changed;
1874 
1875 	if (!changed) {
1876 		/* Advertisement hasn't changed, but maybe aneg was never on to
1877 		 * begin with?  Or maybe phy was isolated?
1878 		 */
1879 		int ctl = phy_read(phydev, MII_BMCR);
1880 
1881 		if (ctl < 0)
1882 			return ctl;
1883 
1884 		if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1885 			changed = 1; /* do restart aneg */
1886 	}
1887 
1888 	/* Only restart aneg if we are advertising something different
1889 	 * than we were before.
1890 	 */
1891 	if (changed > 0)
1892 		return genphy_restart_aneg(phydev);
1893 
1894 	return 0;
1895 }
1896 EXPORT_SYMBOL(genphy_c37_config_aneg);
1897 
1898 /**
1899  * genphy_aneg_done - return auto-negotiation status
1900  * @phydev: target phy_device struct
1901  *
1902  * Description: Reads the status register and returns 0 either if
1903  *   auto-negotiation is incomplete, or if there was an error.
1904  *   Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1905  */
1906 int genphy_aneg_done(struct phy_device *phydev)
1907 {
1908 	int retval = phy_read(phydev, MII_BMSR);
1909 
1910 	return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1911 }
1912 EXPORT_SYMBOL(genphy_aneg_done);
1913 
1914 /**
1915  * genphy_update_link - update link status in @phydev
1916  * @phydev: target phy_device struct
1917  *
1918  * Description: Update the value in phydev->link to reflect the
1919  *   current link value.  In order to do this, we need to read
1920  *   the status register twice, keeping the second value.
1921  */
1922 int genphy_update_link(struct phy_device *phydev)
1923 {
1924 	int status = 0, bmcr;
1925 
1926 	bmcr = phy_read(phydev, MII_BMCR);
1927 	if (bmcr < 0)
1928 		return bmcr;
1929 
1930 	/* Autoneg is being started, therefore disregard BMSR value and
1931 	 * report link as down.
1932 	 */
1933 	if (bmcr & BMCR_ANRESTART)
1934 		goto done;
1935 
1936 	/* The link state is latched low so that momentary link
1937 	 * drops can be detected. Do not double-read the status
1938 	 * in polling mode to detect such short link drops.
1939 	 */
1940 	if (!phy_polling_mode(phydev)) {
1941 		status = phy_read(phydev, MII_BMSR);
1942 		if (status < 0)
1943 			return status;
1944 		else if (status & BMSR_LSTATUS)
1945 			goto done;
1946 	}
1947 
1948 	/* Read link and autonegotiation status */
1949 	status = phy_read(phydev, MII_BMSR);
1950 	if (status < 0)
1951 		return status;
1952 done:
1953 	phydev->link = status & BMSR_LSTATUS ? 1 : 0;
1954 	phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
1955 
1956 	/* Consider the case that autoneg was started and "aneg complete"
1957 	 * bit has been reset, but "link up" bit not yet.
1958 	 */
1959 	if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
1960 		phydev->link = 0;
1961 
1962 	return 0;
1963 }
1964 EXPORT_SYMBOL(genphy_update_link);
1965 
1966 int genphy_read_lpa(struct phy_device *phydev)
1967 {
1968 	int lpa, lpagb;
1969 
1970 	if (phydev->autoneg == AUTONEG_ENABLE) {
1971 		if (!phydev->autoneg_complete) {
1972 			mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1973 							0);
1974 			mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
1975 			return 0;
1976 		}
1977 
1978 		if (phydev->is_gigabit_capable) {
1979 			lpagb = phy_read(phydev, MII_STAT1000);
1980 			if (lpagb < 0)
1981 				return lpagb;
1982 
1983 			if (lpagb & LPA_1000MSFAIL) {
1984 				int adv = phy_read(phydev, MII_CTRL1000);
1985 
1986 				if (adv < 0)
1987 					return adv;
1988 
1989 				if (adv & CTL1000_ENABLE_MASTER)
1990 					phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
1991 				else
1992 					phydev_err(phydev, "Master/Slave resolution failed\n");
1993 				return -ENOLINK;
1994 			}
1995 
1996 			mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1997 							lpagb);
1998 		}
1999 
2000 		lpa = phy_read(phydev, MII_LPA);
2001 		if (lpa < 0)
2002 			return lpa;
2003 
2004 		mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2005 	} else {
2006 		linkmode_zero(phydev->lp_advertising);
2007 	}
2008 
2009 	return 0;
2010 }
2011 EXPORT_SYMBOL(genphy_read_lpa);
2012 
2013 /**
2014  * genphy_read_status_fixed - read the link parameters for !aneg mode
2015  * @phydev: target phy_device struct
2016  *
2017  * Read the current duplex and speed state for a PHY operating with
2018  * autonegotiation disabled.
2019  */
2020 int genphy_read_status_fixed(struct phy_device *phydev)
2021 {
2022 	int bmcr = phy_read(phydev, MII_BMCR);
2023 
2024 	if (bmcr < 0)
2025 		return bmcr;
2026 
2027 	if (bmcr & BMCR_FULLDPLX)
2028 		phydev->duplex = DUPLEX_FULL;
2029 	else
2030 		phydev->duplex = DUPLEX_HALF;
2031 
2032 	if (bmcr & BMCR_SPEED1000)
2033 		phydev->speed = SPEED_1000;
2034 	else if (bmcr & BMCR_SPEED100)
2035 		phydev->speed = SPEED_100;
2036 	else
2037 		phydev->speed = SPEED_10;
2038 
2039 	return 0;
2040 }
2041 EXPORT_SYMBOL(genphy_read_status_fixed);
2042 
2043 /**
2044  * genphy_read_status - check the link status and update current link state
2045  * @phydev: target phy_device struct
2046  *
2047  * Description: Check the link, then figure out the current state
2048  *   by comparing what we advertise with what the link partner
2049  *   advertises.  Start by checking the gigabit possibilities,
2050  *   then move on to 10/100.
2051  */
2052 int genphy_read_status(struct phy_device *phydev)
2053 {
2054 	int err, old_link = phydev->link;
2055 
2056 	/* Update the link, but return if there was an error */
2057 	err = genphy_update_link(phydev);
2058 	if (err)
2059 		return err;
2060 
2061 	/* why bother the PHY if nothing can have changed */
2062 	if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2063 		return 0;
2064 
2065 	phydev->speed = SPEED_UNKNOWN;
2066 	phydev->duplex = DUPLEX_UNKNOWN;
2067 	phydev->pause = 0;
2068 	phydev->asym_pause = 0;
2069 
2070 	err = genphy_read_lpa(phydev);
2071 	if (err < 0)
2072 		return err;
2073 
2074 	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2075 		phy_resolve_aneg_linkmode(phydev);
2076 	} else if (phydev->autoneg == AUTONEG_DISABLE) {
2077 		err = genphy_read_status_fixed(phydev);
2078 		if (err < 0)
2079 			return err;
2080 	}
2081 
2082 	return 0;
2083 }
2084 EXPORT_SYMBOL(genphy_read_status);
2085 
2086 /**
2087  * genphy_c37_read_status - check the link status and update current link state
2088  * @phydev: target phy_device struct
2089  *
2090  * Description: Check the link, then figure out the current state
2091  *   by comparing what we advertise with what the link partner
2092  *   advertises. This function is for Clause 37 1000Base-X mode.
2093  */
2094 int genphy_c37_read_status(struct phy_device *phydev)
2095 {
2096 	int lpa, err, old_link = phydev->link;
2097 
2098 	/* Update the link, but return if there was an error */
2099 	err = genphy_update_link(phydev);
2100 	if (err)
2101 		return err;
2102 
2103 	/* why bother the PHY if nothing can have changed */
2104 	if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2105 		return 0;
2106 
2107 	phydev->duplex = DUPLEX_UNKNOWN;
2108 	phydev->pause = 0;
2109 	phydev->asym_pause = 0;
2110 
2111 	if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2112 		lpa = phy_read(phydev, MII_LPA);
2113 		if (lpa < 0)
2114 			return lpa;
2115 
2116 		linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2117 				 phydev->lp_advertising, lpa & LPA_LPACK);
2118 		linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2119 				 phydev->lp_advertising, lpa & LPA_1000XFULL);
2120 		linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2121 				 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2122 		linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2123 				 phydev->lp_advertising,
2124 				 lpa & LPA_1000XPAUSE_ASYM);
2125 
2126 		phy_resolve_aneg_linkmode(phydev);
2127 	} else if (phydev->autoneg == AUTONEG_DISABLE) {
2128 		int bmcr = phy_read(phydev, MII_BMCR);
2129 
2130 		if (bmcr < 0)
2131 			return bmcr;
2132 
2133 		if (bmcr & BMCR_FULLDPLX)
2134 			phydev->duplex = DUPLEX_FULL;
2135 		else
2136 			phydev->duplex = DUPLEX_HALF;
2137 	}
2138 
2139 	return 0;
2140 }
2141 EXPORT_SYMBOL(genphy_c37_read_status);
2142 
2143 /**
2144  * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2145  * @phydev: target phy_device struct
2146  *
2147  * Description: Perform a software PHY reset using the standard
2148  * BMCR_RESET bit and poll for the reset bit to be cleared.
2149  *
2150  * Returns: 0 on success, < 0 on failure
2151  */
2152 int genphy_soft_reset(struct phy_device *phydev)
2153 {
2154 	u16 res = BMCR_RESET;
2155 	int ret;
2156 
2157 	if (phydev->autoneg == AUTONEG_ENABLE)
2158 		res |= BMCR_ANRESTART;
2159 
2160 	ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2161 	if (ret < 0)
2162 		return ret;
2163 
2164 	ret = phy_poll_reset(phydev);
2165 	if (ret)
2166 		return ret;
2167 
2168 	/* BMCR may be reset to defaults */
2169 	if (phydev->autoneg == AUTONEG_DISABLE)
2170 		ret = genphy_setup_forced(phydev);
2171 
2172 	return ret;
2173 }
2174 EXPORT_SYMBOL(genphy_soft_reset);
2175 
2176 /**
2177  * genphy_read_abilities - read PHY abilities from Clause 22 registers
2178  * @phydev: target phy_device struct
2179  *
2180  * Description: Reads the PHY's abilities and populates
2181  * phydev->supported accordingly.
2182  *
2183  * Returns: 0 on success, < 0 on failure
2184  */
2185 int genphy_read_abilities(struct phy_device *phydev)
2186 {
2187 	int val;
2188 
2189 	linkmode_set_bit_array(phy_basic_ports_array,
2190 			       ARRAY_SIZE(phy_basic_ports_array),
2191 			       phydev->supported);
2192 
2193 	val = phy_read(phydev, MII_BMSR);
2194 	if (val < 0)
2195 		return val;
2196 
2197 	linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2198 			 val & BMSR_ANEGCAPABLE);
2199 
2200 	linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2201 			 val & BMSR_100FULL);
2202 	linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2203 			 val & BMSR_100HALF);
2204 	linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2205 			 val & BMSR_10FULL);
2206 	linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2207 			 val & BMSR_10HALF);
2208 
2209 	if (val & BMSR_ESTATEN) {
2210 		val = phy_read(phydev, MII_ESTATUS);
2211 		if (val < 0)
2212 			return val;
2213 
2214 		linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2215 				 phydev->supported, val & ESTATUS_1000_TFULL);
2216 		linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2217 				 phydev->supported, val & ESTATUS_1000_THALF);
2218 		linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2219 				 phydev->supported, val & ESTATUS_1000_XFULL);
2220 	}
2221 
2222 	return 0;
2223 }
2224 EXPORT_SYMBOL(genphy_read_abilities);
2225 
2226 /* This is used for the phy device which doesn't support the MMD extended
2227  * register access, but it does have side effect when we are trying to access
2228  * the MMD register via indirect method.
2229  */
2230 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2231 {
2232 	return -EOPNOTSUPP;
2233 }
2234 EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2235 
2236 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2237 				 u16 regnum, u16 val)
2238 {
2239 	return -EOPNOTSUPP;
2240 }
2241 EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2242 
2243 int genphy_suspend(struct phy_device *phydev)
2244 {
2245 	return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2246 }
2247 EXPORT_SYMBOL(genphy_suspend);
2248 
2249 int genphy_resume(struct phy_device *phydev)
2250 {
2251 	return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2252 }
2253 EXPORT_SYMBOL(genphy_resume);
2254 
2255 int genphy_loopback(struct phy_device *phydev, bool enable)
2256 {
2257 	return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
2258 			  enable ? BMCR_LOOPBACK : 0);
2259 }
2260 EXPORT_SYMBOL(genphy_loopback);
2261 
2262 /**
2263  * phy_remove_link_mode - Remove a supported link mode
2264  * @phydev: phy_device structure to remove link mode from
2265  * @link_mode: Link mode to be removed
2266  *
2267  * Description: Some MACs don't support all link modes which the PHY
2268  * does.  e.g. a 1G MAC often does not support 1000Half. Add a helper
2269  * to remove a link mode.
2270  */
2271 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2272 {
2273 	linkmode_clear_bit(link_mode, phydev->supported);
2274 	phy_advertise_supported(phydev);
2275 }
2276 EXPORT_SYMBOL(phy_remove_link_mode);
2277 
2278 static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2279 {
2280 	linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2281 		linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2282 	linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2283 		linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2284 }
2285 
2286 /**
2287  * phy_advertise_supported - Advertise all supported modes
2288  * @phydev: target phy_device struct
2289  *
2290  * Description: Called to advertise all supported modes, doesn't touch
2291  * pause mode advertising.
2292  */
2293 void phy_advertise_supported(struct phy_device *phydev)
2294 {
2295 	__ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2296 
2297 	linkmode_copy(new, phydev->supported);
2298 	phy_copy_pause_bits(new, phydev->advertising);
2299 	linkmode_copy(phydev->advertising, new);
2300 }
2301 EXPORT_SYMBOL(phy_advertise_supported);
2302 
2303 /**
2304  * phy_support_sym_pause - Enable support of symmetrical pause
2305  * @phydev: target phy_device struct
2306  *
2307  * Description: Called by the MAC to indicate is supports symmetrical
2308  * Pause, but not asym pause.
2309  */
2310 void phy_support_sym_pause(struct phy_device *phydev)
2311 {
2312 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2313 	phy_copy_pause_bits(phydev->advertising, phydev->supported);
2314 }
2315 EXPORT_SYMBOL(phy_support_sym_pause);
2316 
2317 /**
2318  * phy_support_asym_pause - Enable support of asym pause
2319  * @phydev: target phy_device struct
2320  *
2321  * Description: Called by the MAC to indicate is supports Asym Pause.
2322  */
2323 void phy_support_asym_pause(struct phy_device *phydev)
2324 {
2325 	phy_copy_pause_bits(phydev->advertising, phydev->supported);
2326 }
2327 EXPORT_SYMBOL(phy_support_asym_pause);
2328 
2329 /**
2330  * phy_set_sym_pause - Configure symmetric Pause
2331  * @phydev: target phy_device struct
2332  * @rx: Receiver Pause is supported
2333  * @tx: Transmit Pause is supported
2334  * @autoneg: Auto neg should be used
2335  *
2336  * Description: Configure advertised Pause support depending on if
2337  * receiver pause and pause auto neg is supported. Generally called
2338  * from the set_pauseparam .ndo.
2339  */
2340 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2341 		       bool autoneg)
2342 {
2343 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2344 
2345 	if (rx && tx && autoneg)
2346 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2347 				 phydev->supported);
2348 
2349 	linkmode_copy(phydev->advertising, phydev->supported);
2350 }
2351 EXPORT_SYMBOL(phy_set_sym_pause);
2352 
2353 /**
2354  * phy_set_asym_pause - Configure Pause and Asym Pause
2355  * @phydev: target phy_device struct
2356  * @rx: Receiver Pause is supported
2357  * @tx: Transmit Pause is supported
2358  *
2359  * Description: Configure advertised Pause support depending on if
2360  * transmit and receiver pause is supported. If there has been a
2361  * change in adverting, trigger a new autoneg. Generally called from
2362  * the set_pauseparam .ndo.
2363  */
2364 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2365 {
2366 	__ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
2367 
2368 	linkmode_copy(oldadv, phydev->advertising);
2369 
2370 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2371 			   phydev->advertising);
2372 	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2373 			   phydev->advertising);
2374 
2375 	if (rx) {
2376 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2377 				 phydev->advertising);
2378 		linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2379 				 phydev->advertising);
2380 	}
2381 
2382 	if (tx)
2383 		linkmode_change_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2384 				    phydev->advertising);
2385 
2386 	if (!linkmode_equal(oldadv, phydev->advertising) &&
2387 	    phydev->autoneg)
2388 		phy_start_aneg(phydev);
2389 }
2390 EXPORT_SYMBOL(phy_set_asym_pause);
2391 
2392 /**
2393  * phy_validate_pause - Test if the PHY/MAC support the pause configuration
2394  * @phydev: phy_device struct
2395  * @pp: requested pause configuration
2396  *
2397  * Description: Test if the PHY/MAC combination supports the Pause
2398  * configuration the user is requesting. Returns True if it is
2399  * supported, false otherwise.
2400  */
2401 bool phy_validate_pause(struct phy_device *phydev,
2402 			struct ethtool_pauseparam *pp)
2403 {
2404 	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2405 			       phydev->supported) && pp->rx_pause)
2406 		return false;
2407 
2408 	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2409 			       phydev->supported) &&
2410 	    pp->rx_pause != pp->tx_pause)
2411 		return false;
2412 
2413 	return true;
2414 }
2415 EXPORT_SYMBOL(phy_validate_pause);
2416 
2417 static bool phy_drv_supports_irq(struct phy_driver *phydrv)
2418 {
2419 	return phydrv->config_intr && phydrv->ack_interrupt;
2420 }
2421 
2422 /**
2423  * phy_probe - probe and init a PHY device
2424  * @dev: device to probe and init
2425  *
2426  * Description: Take care of setting up the phy_device structure,
2427  *   set the state to READY (the driver's init function should
2428  *   set it to STARTING if needed).
2429  */
2430 static int phy_probe(struct device *dev)
2431 {
2432 	struct phy_device *phydev = to_phy_device(dev);
2433 	struct device_driver *drv = phydev->mdio.dev.driver;
2434 	struct phy_driver *phydrv = to_phy_driver(drv);
2435 	int err = 0;
2436 
2437 	phydev->drv = phydrv;
2438 
2439 	/* Disable the interrupt if the PHY doesn't support it
2440 	 * but the interrupt is still a valid one
2441 	 */
2442 	 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
2443 		phydev->irq = PHY_POLL;
2444 
2445 	if (phydrv->flags & PHY_IS_INTERNAL)
2446 		phydev->is_internal = true;
2447 
2448 	mutex_lock(&phydev->lock);
2449 
2450 	if (phydev->drv->probe) {
2451 		/* Deassert the reset signal */
2452 		phy_device_reset(phydev, 0);
2453 
2454 		err = phydev->drv->probe(phydev);
2455 		if (err) {
2456 			/* Assert the reset signal */
2457 			phy_device_reset(phydev, 1);
2458 			goto out;
2459 		}
2460 	}
2461 
2462 	/* Start out supporting everything. Eventually,
2463 	 * a controller will attach, and may modify one
2464 	 * or both of these values
2465 	 */
2466 	if (phydrv->features) {
2467 		linkmode_copy(phydev->supported, phydrv->features);
2468 	} else if (phydrv->get_features) {
2469 		err = phydrv->get_features(phydev);
2470 	} else if (phydev->is_c45) {
2471 		err = genphy_c45_pma_read_abilities(phydev);
2472 	} else {
2473 		err = genphy_read_abilities(phydev);
2474 	}
2475 
2476 	if (err)
2477 		goto out;
2478 
2479 	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2480 			       phydev->supported))
2481 		phydev->autoneg = 0;
2482 
2483 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2484 			      phydev->supported))
2485 		phydev->is_gigabit_capable = 1;
2486 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2487 			      phydev->supported))
2488 		phydev->is_gigabit_capable = 1;
2489 
2490 	of_set_phy_supported(phydev);
2491 	phy_advertise_supported(phydev);
2492 
2493 	/* Get the EEE modes we want to prohibit. We will ask
2494 	 * the PHY stop advertising these mode later on
2495 	 */
2496 	of_set_phy_eee_broken(phydev);
2497 
2498 	/* The Pause Frame bits indicate that the PHY can support passing
2499 	 * pause frames. During autonegotiation, the PHYs will determine if
2500 	 * they should allow pause frames to pass.  The MAC driver should then
2501 	 * use that result to determine whether to enable flow control via
2502 	 * pause frames.
2503 	 *
2504 	 * Normally, PHY drivers should not set the Pause bits, and instead
2505 	 * allow phylib to do that.  However, there may be some situations
2506 	 * (e.g. hardware erratum) where the driver wants to set only one
2507 	 * of these bits.
2508 	 */
2509 	if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
2510 	    !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
2511 		linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2512 				 phydev->supported);
2513 		linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2514 				 phydev->supported);
2515 	}
2516 
2517 	/* Set the state to READY by default */
2518 	phydev->state = PHY_READY;
2519 
2520 out:
2521 	mutex_unlock(&phydev->lock);
2522 
2523 	return err;
2524 }
2525 
2526 static int phy_remove(struct device *dev)
2527 {
2528 	struct phy_device *phydev = to_phy_device(dev);
2529 
2530 	cancel_delayed_work_sync(&phydev->state_queue);
2531 
2532 	mutex_lock(&phydev->lock);
2533 	phydev->state = PHY_DOWN;
2534 	mutex_unlock(&phydev->lock);
2535 
2536 	sfp_bus_del_upstream(phydev->sfp_bus);
2537 	phydev->sfp_bus = NULL;
2538 
2539 	if (phydev->drv && phydev->drv->remove) {
2540 		phydev->drv->remove(phydev);
2541 
2542 		/* Assert the reset signal */
2543 		phy_device_reset(phydev, 1);
2544 	}
2545 	phydev->drv = NULL;
2546 
2547 	return 0;
2548 }
2549 
2550 /**
2551  * phy_driver_register - register a phy_driver with the PHY layer
2552  * @new_driver: new phy_driver to register
2553  * @owner: module owning this PHY
2554  */
2555 int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
2556 {
2557 	int retval;
2558 
2559 	/* Either the features are hard coded, or dynamically
2560 	 * determined. It cannot be both.
2561 	 */
2562 	if (WARN_ON(new_driver->features && new_driver->get_features)) {
2563 		pr_err("%s: features and get_features must not both be set\n",
2564 		       new_driver->name);
2565 		return -EINVAL;
2566 	}
2567 
2568 	new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
2569 	new_driver->mdiodrv.driver.name = new_driver->name;
2570 	new_driver->mdiodrv.driver.bus = &mdio_bus_type;
2571 	new_driver->mdiodrv.driver.probe = phy_probe;
2572 	new_driver->mdiodrv.driver.remove = phy_remove;
2573 	new_driver->mdiodrv.driver.owner = owner;
2574 
2575 	retval = driver_register(&new_driver->mdiodrv.driver);
2576 	if (retval) {
2577 		pr_err("%s: Error %d in registering driver\n",
2578 		       new_driver->name, retval);
2579 
2580 		return retval;
2581 	}
2582 
2583 	pr_debug("%s: Registered new driver\n", new_driver->name);
2584 
2585 	return 0;
2586 }
2587 EXPORT_SYMBOL(phy_driver_register);
2588 
2589 int phy_drivers_register(struct phy_driver *new_driver, int n,
2590 			 struct module *owner)
2591 {
2592 	int i, ret = 0;
2593 
2594 	for (i = 0; i < n; i++) {
2595 		ret = phy_driver_register(new_driver + i, owner);
2596 		if (ret) {
2597 			while (i-- > 0)
2598 				phy_driver_unregister(new_driver + i);
2599 			break;
2600 		}
2601 	}
2602 	return ret;
2603 }
2604 EXPORT_SYMBOL(phy_drivers_register);
2605 
2606 void phy_driver_unregister(struct phy_driver *drv)
2607 {
2608 	driver_unregister(&drv->mdiodrv.driver);
2609 }
2610 EXPORT_SYMBOL(phy_driver_unregister);
2611 
2612 void phy_drivers_unregister(struct phy_driver *drv, int n)
2613 {
2614 	int i;
2615 
2616 	for (i = 0; i < n; i++)
2617 		phy_driver_unregister(drv + i);
2618 }
2619 EXPORT_SYMBOL(phy_drivers_unregister);
2620 
2621 static struct phy_driver genphy_driver = {
2622 	.phy_id		= 0xffffffff,
2623 	.phy_id_mask	= 0xffffffff,
2624 	.name		= "Generic PHY",
2625 	.soft_reset	= genphy_no_soft_reset,
2626 	.get_features	= genphy_read_abilities,
2627 	.suspend	= genphy_suspend,
2628 	.resume		= genphy_resume,
2629 	.set_loopback   = genphy_loopback,
2630 };
2631 
2632 static int __init phy_init(void)
2633 {
2634 	int rc;
2635 
2636 	rc = mdio_bus_init();
2637 	if (rc)
2638 		return rc;
2639 
2640 	features_init();
2641 
2642 	rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
2643 	if (rc)
2644 		goto err_c45;
2645 
2646 	rc = phy_driver_register(&genphy_driver, THIS_MODULE);
2647 	if (rc) {
2648 		phy_driver_unregister(&genphy_c45_driver);
2649 err_c45:
2650 		mdio_bus_exit();
2651 	}
2652 
2653 	return rc;
2654 }
2655 
2656 static void __exit phy_exit(void)
2657 {
2658 	phy_driver_unregister(&genphy_c45_driver);
2659 	phy_driver_unregister(&genphy_driver);
2660 	mdio_bus_exit();
2661 }
2662 
2663 subsys_initcall(phy_init);
2664 module_exit(phy_exit);
2665