xref: /openbmc/linux/drivers/net/phy/phy.c (revision 35f752be)
1 // SPDX-License-Identifier: GPL-2.0+
2 /* Framework for configuring and reading PHY devices
3  * Based on code in sungem_phy.c and gianfar_phy.c
4  *
5  * Author: Andy Fleming
6  *
7  * Copyright (c) 2004 Freescale Semiconductor, Inc.
8  * Copyright (c) 2006, 2007  Maciej W. Rozycki
9  */
10 
11 #include <linux/kernel.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14 #include <linux/unistd.h>
15 #include <linux/interrupt.h>
16 #include <linux/delay.h>
17 #include <linux/netdevice.h>
18 #include <linux/netlink.h>
19 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
21 #include <linux/mm.h>
22 #include <linux/module.h>
23 #include <linux/mii.h>
24 #include <linux/ethtool.h>
25 #include <linux/ethtool_netlink.h>
26 #include <linux/phy.h>
27 #include <linux/phy_led_triggers.h>
28 #include <linux/sfp.h>
29 #include <linux/workqueue.h>
30 #include <linux/mdio.h>
31 #include <linux/io.h>
32 #include <linux/uaccess.h>
33 #include <linux/atomic.h>
34 #include <net/netlink.h>
35 #include <net/genetlink.h>
36 #include <net/sock.h>
37 
38 #define PHY_STATE_TIME	HZ
39 
40 #define PHY_STATE_STR(_state)			\
41 	case PHY_##_state:			\
42 		return __stringify(_state);	\
43 
44 static const char *phy_state_to_str(enum phy_state st)
45 {
46 	switch (st) {
47 	PHY_STATE_STR(DOWN)
48 	PHY_STATE_STR(READY)
49 	PHY_STATE_STR(UP)
50 	PHY_STATE_STR(RUNNING)
51 	PHY_STATE_STR(NOLINK)
52 	PHY_STATE_STR(CABLETEST)
53 	PHY_STATE_STR(HALTED)
54 	}
55 
56 	return NULL;
57 }
58 
59 static void phy_link_up(struct phy_device *phydev)
60 {
61 	phydev->phy_link_change(phydev, true);
62 	phy_led_trigger_change_speed(phydev);
63 }
64 
65 static void phy_link_down(struct phy_device *phydev)
66 {
67 	phydev->phy_link_change(phydev, false);
68 	phy_led_trigger_change_speed(phydev);
69 }
70 
71 static const char *phy_pause_str(struct phy_device *phydev)
72 {
73 	bool local_pause, local_asym_pause;
74 
75 	if (phydev->autoneg == AUTONEG_DISABLE)
76 		goto no_pause;
77 
78 	local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
79 					phydev->advertising);
80 	local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
81 					     phydev->advertising);
82 
83 	if (local_pause && phydev->pause)
84 		return "rx/tx";
85 
86 	if (local_asym_pause && phydev->asym_pause) {
87 		if (local_pause)
88 			return "rx";
89 		if (phydev->pause)
90 			return "tx";
91 	}
92 
93 no_pause:
94 	return "off";
95 }
96 
97 /**
98  * phy_print_status - Convenience function to print out the current phy status
99  * @phydev: the phy_device struct
100  */
101 void phy_print_status(struct phy_device *phydev)
102 {
103 	if (phydev->link) {
104 		netdev_info(phydev->attached_dev,
105 			"Link is Up - %s/%s %s- flow control %s\n",
106 			phy_speed_to_str(phydev->speed),
107 			phy_duplex_to_str(phydev->duplex),
108 			phydev->downshifted_rate ? "(downshifted) " : "",
109 			phy_pause_str(phydev));
110 	} else	{
111 		netdev_info(phydev->attached_dev, "Link is Down\n");
112 	}
113 }
114 EXPORT_SYMBOL(phy_print_status);
115 
116 /**
117  * phy_config_interrupt - configure the PHY device for the requested interrupts
118  * @phydev: the phy_device struct
119  * @interrupts: interrupt flags to configure for this @phydev
120  *
121  * Returns 0 on success or < 0 on error.
122  */
123 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
124 {
125 	phydev->interrupts = interrupts ? 1 : 0;
126 	if (phydev->drv->config_intr)
127 		return phydev->drv->config_intr(phydev);
128 
129 	return 0;
130 }
131 
132 /**
133  * phy_restart_aneg - restart auto-negotiation
134  * @phydev: target phy_device struct
135  *
136  * Restart the autonegotiation on @phydev.  Returns >= 0 on success or
137  * negative errno on error.
138  */
139 int phy_restart_aneg(struct phy_device *phydev)
140 {
141 	int ret;
142 
143 	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
144 		ret = genphy_c45_restart_aneg(phydev);
145 	else
146 		ret = genphy_restart_aneg(phydev);
147 
148 	return ret;
149 }
150 EXPORT_SYMBOL_GPL(phy_restart_aneg);
151 
152 /**
153  * phy_aneg_done - return auto-negotiation status
154  * @phydev: target phy_device struct
155  *
156  * Description: Return the auto-negotiation status from this @phydev
157  * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
158  * is still pending.
159  */
160 int phy_aneg_done(struct phy_device *phydev)
161 {
162 	if (phydev->drv && phydev->drv->aneg_done)
163 		return phydev->drv->aneg_done(phydev);
164 	else if (phydev->is_c45)
165 		return genphy_c45_aneg_done(phydev);
166 	else
167 		return genphy_aneg_done(phydev);
168 }
169 EXPORT_SYMBOL(phy_aneg_done);
170 
171 /**
172  * phy_find_valid - find a PHY setting that matches the requested parameters
173  * @speed: desired speed
174  * @duplex: desired duplex
175  * @supported: mask of supported link modes
176  *
177  * Locate a supported phy setting that is, in priority order:
178  * - an exact match for the specified speed and duplex mode
179  * - a match for the specified speed, or slower speed
180  * - the slowest supported speed
181  * Returns the matched phy_setting entry, or %NULL if no supported phy
182  * settings were found.
183  */
184 static const struct phy_setting *
185 phy_find_valid(int speed, int duplex, unsigned long *supported)
186 {
187 	return phy_lookup_setting(speed, duplex, supported, false);
188 }
189 
190 /**
191  * phy_supported_speeds - return all speeds currently supported by a phy device
192  * @phy: The phy device to return supported speeds of.
193  * @speeds: buffer to store supported speeds in.
194  * @size:   size of speeds buffer.
195  *
196  * Description: Returns the number of supported speeds, and fills the speeds
197  * buffer with the supported speeds. If speeds buffer is too small to contain
198  * all currently supported speeds, will return as many speeds as can fit.
199  */
200 unsigned int phy_supported_speeds(struct phy_device *phy,
201 				  unsigned int *speeds,
202 				  unsigned int size)
203 {
204 	return phy_speeds(speeds, size, phy->supported);
205 }
206 
207 /**
208  * phy_check_valid - check if there is a valid PHY setting which matches
209  *		     speed, duplex, and feature mask
210  * @speed: speed to match
211  * @duplex: duplex to match
212  * @features: A mask of the valid settings
213  *
214  * Description: Returns true if there is a valid setting, false otherwise.
215  */
216 static inline bool phy_check_valid(int speed, int duplex,
217 				   unsigned long *features)
218 {
219 	return !!phy_lookup_setting(speed, duplex, features, true);
220 }
221 
222 /**
223  * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
224  * @phydev: the target phy_device struct
225  *
226  * Description: Make sure the PHY is set to supported speeds and
227  *   duplexes.  Drop down by one in this order:  1000/FULL,
228  *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
229  */
230 static void phy_sanitize_settings(struct phy_device *phydev)
231 {
232 	const struct phy_setting *setting;
233 
234 	setting = phy_find_valid(phydev->speed, phydev->duplex,
235 				 phydev->supported);
236 	if (setting) {
237 		phydev->speed = setting->speed;
238 		phydev->duplex = setting->duplex;
239 	} else {
240 		/* We failed to find anything (no supported speeds?) */
241 		phydev->speed = SPEED_UNKNOWN;
242 		phydev->duplex = DUPLEX_UNKNOWN;
243 	}
244 }
245 
246 int phy_ethtool_ksettings_set(struct phy_device *phydev,
247 			      const struct ethtool_link_ksettings *cmd)
248 {
249 	__ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
250 	u8 autoneg = cmd->base.autoneg;
251 	u8 duplex = cmd->base.duplex;
252 	u32 speed = cmd->base.speed;
253 
254 	if (cmd->base.phy_address != phydev->mdio.addr)
255 		return -EINVAL;
256 
257 	linkmode_copy(advertising, cmd->link_modes.advertising);
258 
259 	/* We make sure that we don't pass unsupported values in to the PHY */
260 	linkmode_and(advertising, advertising, phydev->supported);
261 
262 	/* Verify the settings we care about. */
263 	if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
264 		return -EINVAL;
265 
266 	if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
267 		return -EINVAL;
268 
269 	if (autoneg == AUTONEG_DISABLE &&
270 	    ((speed != SPEED_1000 &&
271 	      speed != SPEED_100 &&
272 	      speed != SPEED_10) ||
273 	     (duplex != DUPLEX_HALF &&
274 	      duplex != DUPLEX_FULL)))
275 		return -EINVAL;
276 
277 	phydev->autoneg = autoneg;
278 
279 	if (autoneg == AUTONEG_DISABLE) {
280 		phydev->speed = speed;
281 		phydev->duplex = duplex;
282 	}
283 
284 	linkmode_copy(phydev->advertising, advertising);
285 
286 	linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
287 			 phydev->advertising, autoneg == AUTONEG_ENABLE);
288 
289 	phydev->master_slave_set = cmd->base.master_slave_cfg;
290 	phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
291 
292 	/* Restart the PHY */
293 	phy_start_aneg(phydev);
294 
295 	return 0;
296 }
297 EXPORT_SYMBOL(phy_ethtool_ksettings_set);
298 
299 void phy_ethtool_ksettings_get(struct phy_device *phydev,
300 			       struct ethtool_link_ksettings *cmd)
301 {
302 	linkmode_copy(cmd->link_modes.supported, phydev->supported);
303 	linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
304 	linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
305 
306 	cmd->base.speed = phydev->speed;
307 	cmd->base.duplex = phydev->duplex;
308 	cmd->base.master_slave_cfg = phydev->master_slave_get;
309 	cmd->base.master_slave_state = phydev->master_slave_state;
310 	if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
311 		cmd->base.port = PORT_BNC;
312 	else
313 		cmd->base.port = phydev->port;
314 	cmd->base.transceiver = phy_is_internal(phydev) ?
315 				XCVR_INTERNAL : XCVR_EXTERNAL;
316 	cmd->base.phy_address = phydev->mdio.addr;
317 	cmd->base.autoneg = phydev->autoneg;
318 	cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
319 	cmd->base.eth_tp_mdix = phydev->mdix;
320 }
321 EXPORT_SYMBOL(phy_ethtool_ksettings_get);
322 
323 /**
324  * phy_mii_ioctl - generic PHY MII ioctl interface
325  * @phydev: the phy_device struct
326  * @ifr: &struct ifreq for socket ioctl's
327  * @cmd: ioctl cmd to execute
328  *
329  * Note that this function is currently incompatible with the
330  * PHYCONTROL layer.  It changes registers without regard to
331  * current state.  Use at own risk.
332  */
333 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
334 {
335 	struct mii_ioctl_data *mii_data = if_mii(ifr);
336 	u16 val = mii_data->val_in;
337 	bool change_autoneg = false;
338 	int prtad, devad;
339 
340 	switch (cmd) {
341 	case SIOCGMIIPHY:
342 		mii_data->phy_id = phydev->mdio.addr;
343 		fallthrough;
344 
345 	case SIOCGMIIREG:
346 		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
347 			prtad = mdio_phy_id_prtad(mii_data->phy_id);
348 			devad = mdio_phy_id_devad(mii_data->phy_id);
349 			devad = mdiobus_c45_addr(devad, mii_data->reg_num);
350 		} else {
351 			prtad = mii_data->phy_id;
352 			devad = mii_data->reg_num;
353 		}
354 		mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
355 						 devad);
356 		return 0;
357 
358 	case SIOCSMIIREG:
359 		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
360 			prtad = mdio_phy_id_prtad(mii_data->phy_id);
361 			devad = mdio_phy_id_devad(mii_data->phy_id);
362 			devad = mdiobus_c45_addr(devad, mii_data->reg_num);
363 		} else {
364 			prtad = mii_data->phy_id;
365 			devad = mii_data->reg_num;
366 		}
367 		if (prtad == phydev->mdio.addr) {
368 			switch (devad) {
369 			case MII_BMCR:
370 				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
371 					if (phydev->autoneg == AUTONEG_ENABLE)
372 						change_autoneg = true;
373 					phydev->autoneg = AUTONEG_DISABLE;
374 					if (val & BMCR_FULLDPLX)
375 						phydev->duplex = DUPLEX_FULL;
376 					else
377 						phydev->duplex = DUPLEX_HALF;
378 					if (val & BMCR_SPEED1000)
379 						phydev->speed = SPEED_1000;
380 					else if (val & BMCR_SPEED100)
381 						phydev->speed = SPEED_100;
382 					else phydev->speed = SPEED_10;
383 				}
384 				else {
385 					if (phydev->autoneg == AUTONEG_DISABLE)
386 						change_autoneg = true;
387 					phydev->autoneg = AUTONEG_ENABLE;
388 				}
389 				break;
390 			case MII_ADVERTISE:
391 				mii_adv_mod_linkmode_adv_t(phydev->advertising,
392 							   val);
393 				change_autoneg = true;
394 				break;
395 			case MII_CTRL1000:
396 				mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
397 							        val);
398 				change_autoneg = true;
399 				break;
400 			default:
401 				/* do nothing */
402 				break;
403 			}
404 		}
405 
406 		mdiobus_write(phydev->mdio.bus, prtad, devad, val);
407 
408 		if (prtad == phydev->mdio.addr &&
409 		    devad == MII_BMCR &&
410 		    val & BMCR_RESET)
411 			return phy_init_hw(phydev);
412 
413 		if (change_autoneg)
414 			return phy_start_aneg(phydev);
415 
416 		return 0;
417 
418 	case SIOCSHWTSTAMP:
419 		if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
420 			return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
421 		fallthrough;
422 
423 	default:
424 		return -EOPNOTSUPP;
425 	}
426 }
427 EXPORT_SYMBOL(phy_mii_ioctl);
428 
429 /**
430  * phy_do_ioctl - generic ndo_do_ioctl implementation
431  * @dev: the net_device struct
432  * @ifr: &struct ifreq for socket ioctl's
433  * @cmd: ioctl cmd to execute
434  */
435 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
436 {
437 	if (!dev->phydev)
438 		return -ENODEV;
439 
440 	return phy_mii_ioctl(dev->phydev, ifr, cmd);
441 }
442 EXPORT_SYMBOL(phy_do_ioctl);
443 
444 /**
445  * phy_do_ioctl_running - generic ndo_do_ioctl implementation but test first
446  *
447  * @dev: the net_device struct
448  * @ifr: &struct ifreq for socket ioctl's
449  * @cmd: ioctl cmd to execute
450  *
451  * Same as phy_do_ioctl, but ensures that net_device is running before
452  * handling the ioctl.
453  */
454 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
455 {
456 	if (!netif_running(dev))
457 		return -ENODEV;
458 
459 	return phy_do_ioctl(dev, ifr, cmd);
460 }
461 EXPORT_SYMBOL(phy_do_ioctl_running);
462 
463 /**
464  * phy_queue_state_machine - Trigger the state machine to run soon
465  *
466  * @phydev: the phy_device struct
467  * @jiffies: Run the state machine after these jiffies
468  */
469 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
470 {
471 	mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
472 			 jiffies);
473 }
474 EXPORT_SYMBOL(phy_queue_state_machine);
475 
476 /**
477  * phy_trigger_machine - Trigger the state machine to run now
478  *
479  * @phydev: the phy_device struct
480  */
481 void phy_trigger_machine(struct phy_device *phydev)
482 {
483 	phy_queue_state_machine(phydev, 0);
484 }
485 EXPORT_SYMBOL(phy_trigger_machine);
486 
487 static void phy_abort_cable_test(struct phy_device *phydev)
488 {
489 	int err;
490 
491 	ethnl_cable_test_finished(phydev);
492 
493 	err = phy_init_hw(phydev);
494 	if (err)
495 		phydev_err(phydev, "Error while aborting cable test");
496 }
497 
498 /**
499  * phy_ethtool_get_strings - Get the statistic counter names
500  *
501  * @phydev: the phy_device struct
502  * @data: Where to put the strings
503  */
504 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
505 {
506 	if (!phydev->drv)
507 		return -EIO;
508 
509 	mutex_lock(&phydev->lock);
510 	phydev->drv->get_strings(phydev, data);
511 	mutex_unlock(&phydev->lock);
512 
513 	return 0;
514 }
515 EXPORT_SYMBOL(phy_ethtool_get_strings);
516 
517 /**
518  * phy_ethtool_get_sset_count - Get the number of statistic counters
519  *
520  * @phydev: the phy_device struct
521  */
522 int phy_ethtool_get_sset_count(struct phy_device *phydev)
523 {
524 	int ret;
525 
526 	if (!phydev->drv)
527 		return -EIO;
528 
529 	if (phydev->drv->get_sset_count &&
530 	    phydev->drv->get_strings &&
531 	    phydev->drv->get_stats) {
532 		mutex_lock(&phydev->lock);
533 		ret = phydev->drv->get_sset_count(phydev);
534 		mutex_unlock(&phydev->lock);
535 
536 		return ret;
537 	}
538 
539 	return -EOPNOTSUPP;
540 }
541 EXPORT_SYMBOL(phy_ethtool_get_sset_count);
542 
543 /**
544  * phy_ethtool_get_stats - Get the statistic counters
545  *
546  * @phydev: the phy_device struct
547  * @stats: What counters to get
548  * @data: Where to store the counters
549  */
550 int phy_ethtool_get_stats(struct phy_device *phydev,
551 			  struct ethtool_stats *stats, u64 *data)
552 {
553 	if (!phydev->drv)
554 		return -EIO;
555 
556 	mutex_lock(&phydev->lock);
557 	phydev->drv->get_stats(phydev, stats, data);
558 	mutex_unlock(&phydev->lock);
559 
560 	return 0;
561 }
562 EXPORT_SYMBOL(phy_ethtool_get_stats);
563 
564 /**
565  * phy_start_cable_test - Start a cable test
566  *
567  * @phydev: the phy_device struct
568  * @extack: extack for reporting useful error messages
569  */
570 int phy_start_cable_test(struct phy_device *phydev,
571 			 struct netlink_ext_ack *extack)
572 {
573 	struct net_device *dev = phydev->attached_dev;
574 	int err = -ENOMEM;
575 
576 	if (!(phydev->drv &&
577 	      phydev->drv->cable_test_start &&
578 	      phydev->drv->cable_test_get_status)) {
579 		NL_SET_ERR_MSG(extack,
580 			       "PHY driver does not support cable testing");
581 		return -EOPNOTSUPP;
582 	}
583 
584 	mutex_lock(&phydev->lock);
585 	if (phydev->state == PHY_CABLETEST) {
586 		NL_SET_ERR_MSG(extack,
587 			       "PHY already performing a test");
588 		err = -EBUSY;
589 		goto out;
590 	}
591 
592 	if (phydev->state < PHY_UP ||
593 	    phydev->state > PHY_CABLETEST) {
594 		NL_SET_ERR_MSG(extack,
595 			       "PHY not configured. Try setting interface up");
596 		err = -EBUSY;
597 		goto out;
598 	}
599 
600 	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
601 	if (err)
602 		goto out;
603 
604 	/* Mark the carrier down until the test is complete */
605 	phy_link_down(phydev);
606 
607 	netif_testing_on(dev);
608 	err = phydev->drv->cable_test_start(phydev);
609 	if (err) {
610 		netif_testing_off(dev);
611 		phy_link_up(phydev);
612 		goto out_free;
613 	}
614 
615 	phydev->state = PHY_CABLETEST;
616 
617 	if (phy_polling_mode(phydev))
618 		phy_trigger_machine(phydev);
619 
620 	mutex_unlock(&phydev->lock);
621 
622 	return 0;
623 
624 out_free:
625 	ethnl_cable_test_free(phydev);
626 out:
627 	mutex_unlock(&phydev->lock);
628 
629 	return err;
630 }
631 EXPORT_SYMBOL(phy_start_cable_test);
632 
633 /**
634  * phy_start_cable_test_tdr - Start a raw TDR cable test
635  *
636  * @phydev: the phy_device struct
637  * @extack: extack for reporting useful error messages
638  * @config: Configuration of the test to run
639  */
640 int phy_start_cable_test_tdr(struct phy_device *phydev,
641 			     struct netlink_ext_ack *extack,
642 			     const struct phy_tdr_config *config)
643 {
644 	struct net_device *dev = phydev->attached_dev;
645 	int err = -ENOMEM;
646 
647 	if (!(phydev->drv &&
648 	      phydev->drv->cable_test_tdr_start &&
649 	      phydev->drv->cable_test_get_status)) {
650 		NL_SET_ERR_MSG(extack,
651 			       "PHY driver does not support cable test TDR");
652 		return -EOPNOTSUPP;
653 	}
654 
655 	mutex_lock(&phydev->lock);
656 	if (phydev->state == PHY_CABLETEST) {
657 		NL_SET_ERR_MSG(extack,
658 			       "PHY already performing a test");
659 		err = -EBUSY;
660 		goto out;
661 	}
662 
663 	if (phydev->state < PHY_UP ||
664 	    phydev->state > PHY_CABLETEST) {
665 		NL_SET_ERR_MSG(extack,
666 			       "PHY not configured. Try setting interface up");
667 		err = -EBUSY;
668 		goto out;
669 	}
670 
671 	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
672 	if (err)
673 		goto out;
674 
675 	/* Mark the carrier down until the test is complete */
676 	phy_link_down(phydev);
677 
678 	netif_testing_on(dev);
679 	err = phydev->drv->cable_test_tdr_start(phydev, config);
680 	if (err) {
681 		netif_testing_off(dev);
682 		phy_link_up(phydev);
683 		goto out_free;
684 	}
685 
686 	phydev->state = PHY_CABLETEST;
687 
688 	if (phy_polling_mode(phydev))
689 		phy_trigger_machine(phydev);
690 
691 	mutex_unlock(&phydev->lock);
692 
693 	return 0;
694 
695 out_free:
696 	ethnl_cable_test_free(phydev);
697 out:
698 	mutex_unlock(&phydev->lock);
699 
700 	return err;
701 }
702 EXPORT_SYMBOL(phy_start_cable_test_tdr);
703 
704 int phy_config_aneg(struct phy_device *phydev)
705 {
706 	if (phydev->drv->config_aneg)
707 		return phydev->drv->config_aneg(phydev);
708 
709 	/* Clause 45 PHYs that don't implement Clause 22 registers are not
710 	 * allowed to call genphy_config_aneg()
711 	 */
712 	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
713 		return genphy_c45_config_aneg(phydev);
714 
715 	return genphy_config_aneg(phydev);
716 }
717 EXPORT_SYMBOL(phy_config_aneg);
718 
719 /**
720  * phy_check_link_status - check link status and set state accordingly
721  * @phydev: the phy_device struct
722  *
723  * Description: Check for link and whether autoneg was triggered / is running
724  * and set state accordingly
725  */
726 static int phy_check_link_status(struct phy_device *phydev)
727 {
728 	int err;
729 
730 	lockdep_assert_held(&phydev->lock);
731 
732 	/* Keep previous state if loopback is enabled because some PHYs
733 	 * report that Link is Down when loopback is enabled.
734 	 */
735 	if (phydev->loopback_enabled)
736 		return 0;
737 
738 	err = phy_read_status(phydev);
739 	if (err)
740 		return err;
741 
742 	if (phydev->link && phydev->state != PHY_RUNNING) {
743 		phy_check_downshift(phydev);
744 		phydev->state = PHY_RUNNING;
745 		phy_link_up(phydev);
746 	} else if (!phydev->link && phydev->state != PHY_NOLINK) {
747 		phydev->state = PHY_NOLINK;
748 		phy_link_down(phydev);
749 	}
750 
751 	return 0;
752 }
753 
754 /**
755  * phy_start_aneg - start auto-negotiation for this PHY device
756  * @phydev: the phy_device struct
757  *
758  * Description: Sanitizes the settings (if we're not autonegotiating
759  *   them), and then calls the driver's config_aneg function.
760  *   If the PHYCONTROL Layer is operating, we change the state to
761  *   reflect the beginning of Auto-negotiation or forcing.
762  */
763 int phy_start_aneg(struct phy_device *phydev)
764 {
765 	int err;
766 
767 	if (!phydev->drv)
768 		return -EIO;
769 
770 	mutex_lock(&phydev->lock);
771 
772 	if (AUTONEG_DISABLE == phydev->autoneg)
773 		phy_sanitize_settings(phydev);
774 
775 	err = phy_config_aneg(phydev);
776 	if (err < 0)
777 		goto out_unlock;
778 
779 	if (phy_is_started(phydev))
780 		err = phy_check_link_status(phydev);
781 out_unlock:
782 	mutex_unlock(&phydev->lock);
783 
784 	return err;
785 }
786 EXPORT_SYMBOL(phy_start_aneg);
787 
788 static int phy_poll_aneg_done(struct phy_device *phydev)
789 {
790 	unsigned int retries = 100;
791 	int ret;
792 
793 	do {
794 		msleep(100);
795 		ret = phy_aneg_done(phydev);
796 	} while (!ret && --retries);
797 
798 	if (!ret)
799 		return -ETIMEDOUT;
800 
801 	return ret < 0 ? ret : 0;
802 }
803 
804 /**
805  * phy_speed_down - set speed to lowest speed supported by both link partners
806  * @phydev: the phy_device struct
807  * @sync: perform action synchronously
808  *
809  * Description: Typically used to save energy when waiting for a WoL packet
810  *
811  * WARNING: Setting sync to false may cause the system being unable to suspend
812  * in case the PHY generates an interrupt when finishing the autonegotiation.
813  * This interrupt may wake up the system immediately after suspend.
814  * Therefore use sync = false only if you're sure it's safe with the respective
815  * network chip.
816  */
817 int phy_speed_down(struct phy_device *phydev, bool sync)
818 {
819 	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
820 	int ret;
821 
822 	if (phydev->autoneg != AUTONEG_ENABLE)
823 		return 0;
824 
825 	linkmode_copy(adv_tmp, phydev->advertising);
826 
827 	ret = phy_speed_down_core(phydev);
828 	if (ret)
829 		return ret;
830 
831 	linkmode_copy(phydev->adv_old, adv_tmp);
832 
833 	if (linkmode_equal(phydev->advertising, adv_tmp))
834 		return 0;
835 
836 	ret = phy_config_aneg(phydev);
837 	if (ret)
838 		return ret;
839 
840 	return sync ? phy_poll_aneg_done(phydev) : 0;
841 }
842 EXPORT_SYMBOL_GPL(phy_speed_down);
843 
844 /**
845  * phy_speed_up - (re)set advertised speeds to all supported speeds
846  * @phydev: the phy_device struct
847  *
848  * Description: Used to revert the effect of phy_speed_down
849  */
850 int phy_speed_up(struct phy_device *phydev)
851 {
852 	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
853 
854 	if (phydev->autoneg != AUTONEG_ENABLE)
855 		return 0;
856 
857 	if (linkmode_empty(phydev->adv_old))
858 		return 0;
859 
860 	linkmode_copy(adv_tmp, phydev->advertising);
861 	linkmode_copy(phydev->advertising, phydev->adv_old);
862 	linkmode_zero(phydev->adv_old);
863 
864 	if (linkmode_equal(phydev->advertising, adv_tmp))
865 		return 0;
866 
867 	return phy_config_aneg(phydev);
868 }
869 EXPORT_SYMBOL_GPL(phy_speed_up);
870 
871 /**
872  * phy_start_machine - start PHY state machine tracking
873  * @phydev: the phy_device struct
874  *
875  * Description: The PHY infrastructure can run a state machine
876  *   which tracks whether the PHY is starting up, negotiating,
877  *   etc.  This function starts the delayed workqueue which tracks
878  *   the state of the PHY. If you want to maintain your own state machine,
879  *   do not call this function.
880  */
881 void phy_start_machine(struct phy_device *phydev)
882 {
883 	phy_trigger_machine(phydev);
884 }
885 EXPORT_SYMBOL_GPL(phy_start_machine);
886 
887 /**
888  * phy_stop_machine - stop the PHY state machine tracking
889  * @phydev: target phy_device struct
890  *
891  * Description: Stops the state machine delayed workqueue, sets the
892  *   state to UP (unless it wasn't up yet). This function must be
893  *   called BEFORE phy_detach.
894  */
895 void phy_stop_machine(struct phy_device *phydev)
896 {
897 	cancel_delayed_work_sync(&phydev->state_queue);
898 
899 	mutex_lock(&phydev->lock);
900 	if (phy_is_started(phydev))
901 		phydev->state = PHY_UP;
902 	mutex_unlock(&phydev->lock);
903 }
904 
905 /**
906  * phy_error - enter HALTED state for this PHY device
907  * @phydev: target phy_device struct
908  *
909  * Moves the PHY to the HALTED state in response to a read
910  * or write error, and tells the controller the link is down.
911  * Must not be called from interrupt context, or while the
912  * phydev->lock is held.
913  */
914 void phy_error(struct phy_device *phydev)
915 {
916 	WARN_ON(1);
917 
918 	mutex_lock(&phydev->lock);
919 	phydev->state = PHY_HALTED;
920 	mutex_unlock(&phydev->lock);
921 
922 	phy_trigger_machine(phydev);
923 }
924 EXPORT_SYMBOL(phy_error);
925 
926 /**
927  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
928  * @phydev: target phy_device struct
929  */
930 int phy_disable_interrupts(struct phy_device *phydev)
931 {
932 	/* Disable PHY interrupts */
933 	return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
934 }
935 
936 /**
937  * phy_interrupt - PHY interrupt handler
938  * @irq: interrupt line
939  * @phy_dat: phy_device pointer
940  *
941  * Description: Handle PHY interrupt
942  */
943 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
944 {
945 	struct phy_device *phydev = phy_dat;
946 	struct phy_driver *drv = phydev->drv;
947 
948 	return drv->handle_interrupt(phydev);
949 }
950 
951 /**
952  * phy_enable_interrupts - Enable the interrupts from the PHY side
953  * @phydev: target phy_device struct
954  */
955 static int phy_enable_interrupts(struct phy_device *phydev)
956 {
957 	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
958 }
959 
960 /**
961  * phy_request_interrupt - request and enable interrupt for a PHY device
962  * @phydev: target phy_device struct
963  *
964  * Description: Request and enable the interrupt for the given PHY.
965  *   If this fails, then we set irq to PHY_POLL.
966  *   This should only be called with a valid IRQ number.
967  */
968 void phy_request_interrupt(struct phy_device *phydev)
969 {
970 	int err;
971 
972 	err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
973 				   IRQF_ONESHOT | IRQF_SHARED,
974 				   phydev_name(phydev), phydev);
975 	if (err) {
976 		phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
977 			    err, phydev->irq);
978 		phydev->irq = PHY_POLL;
979 	} else {
980 		if (phy_enable_interrupts(phydev)) {
981 			phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
982 			phy_free_interrupt(phydev);
983 			phydev->irq = PHY_POLL;
984 		}
985 	}
986 }
987 EXPORT_SYMBOL(phy_request_interrupt);
988 
989 /**
990  * phy_free_interrupt - disable and free interrupt for a PHY device
991  * @phydev: target phy_device struct
992  *
993  * Description: Disable and free the interrupt for the given PHY.
994  *   This should only be called with a valid IRQ number.
995  */
996 void phy_free_interrupt(struct phy_device *phydev)
997 {
998 	phy_disable_interrupts(phydev);
999 	free_irq(phydev->irq, phydev);
1000 }
1001 EXPORT_SYMBOL(phy_free_interrupt);
1002 
1003 /**
1004  * phy_stop - Bring down the PHY link, and stop checking the status
1005  * @phydev: target phy_device struct
1006  */
1007 void phy_stop(struct phy_device *phydev)
1008 {
1009 	struct net_device *dev = phydev->attached_dev;
1010 
1011 	if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1012 		WARN(1, "called from state %s\n",
1013 		     phy_state_to_str(phydev->state));
1014 		return;
1015 	}
1016 
1017 	mutex_lock(&phydev->lock);
1018 
1019 	if (phydev->state == PHY_CABLETEST) {
1020 		phy_abort_cable_test(phydev);
1021 		netif_testing_off(dev);
1022 	}
1023 
1024 	if (phydev->sfp_bus)
1025 		sfp_upstream_stop(phydev->sfp_bus);
1026 
1027 	phydev->state = PHY_HALTED;
1028 
1029 	mutex_unlock(&phydev->lock);
1030 
1031 	phy_state_machine(&phydev->state_queue.work);
1032 	phy_stop_machine(phydev);
1033 
1034 	/* Cannot call flush_scheduled_work() here as desired because
1035 	 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1036 	 * will not reenable interrupts.
1037 	 */
1038 }
1039 EXPORT_SYMBOL(phy_stop);
1040 
1041 /**
1042  * phy_start - start or restart a PHY device
1043  * @phydev: target phy_device struct
1044  *
1045  * Description: Indicates the attached device's readiness to
1046  *   handle PHY-related work.  Used during startup to start the
1047  *   PHY, and after a call to phy_stop() to resume operation.
1048  *   Also used to indicate the MDIO bus has cleared an error
1049  *   condition.
1050  */
1051 void phy_start(struct phy_device *phydev)
1052 {
1053 	mutex_lock(&phydev->lock);
1054 
1055 	if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1056 		WARN(1, "called from state %s\n",
1057 		     phy_state_to_str(phydev->state));
1058 		goto out;
1059 	}
1060 
1061 	if (phydev->sfp_bus)
1062 		sfp_upstream_start(phydev->sfp_bus);
1063 
1064 	/* if phy was suspended, bring the physical link up again */
1065 	__phy_resume(phydev);
1066 
1067 	phydev->state = PHY_UP;
1068 
1069 	phy_start_machine(phydev);
1070 out:
1071 	mutex_unlock(&phydev->lock);
1072 }
1073 EXPORT_SYMBOL(phy_start);
1074 
1075 /**
1076  * phy_state_machine - Handle the state machine
1077  * @work: work_struct that describes the work to be done
1078  */
1079 void phy_state_machine(struct work_struct *work)
1080 {
1081 	struct delayed_work *dwork = to_delayed_work(work);
1082 	struct phy_device *phydev =
1083 			container_of(dwork, struct phy_device, state_queue);
1084 	struct net_device *dev = phydev->attached_dev;
1085 	bool needs_aneg = false, do_suspend = false;
1086 	enum phy_state old_state;
1087 	bool finished = false;
1088 	int err = 0;
1089 
1090 	mutex_lock(&phydev->lock);
1091 
1092 	old_state = phydev->state;
1093 
1094 	switch (phydev->state) {
1095 	case PHY_DOWN:
1096 	case PHY_READY:
1097 		break;
1098 	case PHY_UP:
1099 		needs_aneg = true;
1100 
1101 		break;
1102 	case PHY_NOLINK:
1103 	case PHY_RUNNING:
1104 		err = phy_check_link_status(phydev);
1105 		break;
1106 	case PHY_CABLETEST:
1107 		err = phydev->drv->cable_test_get_status(phydev, &finished);
1108 		if (err) {
1109 			phy_abort_cable_test(phydev);
1110 			netif_testing_off(dev);
1111 			needs_aneg = true;
1112 			phydev->state = PHY_UP;
1113 			break;
1114 		}
1115 
1116 		if (finished) {
1117 			ethnl_cable_test_finished(phydev);
1118 			netif_testing_off(dev);
1119 			needs_aneg = true;
1120 			phydev->state = PHY_UP;
1121 		}
1122 		break;
1123 	case PHY_HALTED:
1124 		if (phydev->link) {
1125 			phydev->link = 0;
1126 			phy_link_down(phydev);
1127 		}
1128 		do_suspend = true;
1129 		break;
1130 	}
1131 
1132 	mutex_unlock(&phydev->lock);
1133 
1134 	if (needs_aneg)
1135 		err = phy_start_aneg(phydev);
1136 	else if (do_suspend)
1137 		phy_suspend(phydev);
1138 
1139 	if (err < 0)
1140 		phy_error(phydev);
1141 
1142 	if (old_state != phydev->state) {
1143 		phydev_dbg(phydev, "PHY state change %s -> %s\n",
1144 			   phy_state_to_str(old_state),
1145 			   phy_state_to_str(phydev->state));
1146 		if (phydev->drv && phydev->drv->link_change_notify)
1147 			phydev->drv->link_change_notify(phydev);
1148 	}
1149 
1150 	/* Only re-schedule a PHY state machine change if we are polling the
1151 	 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1152 	 * between states from phy_mac_interrupt().
1153 	 *
1154 	 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1155 	 * state machine would be pointless and possibly error prone when
1156 	 * called from phy_disconnect() synchronously.
1157 	 */
1158 	mutex_lock(&phydev->lock);
1159 	if (phy_polling_mode(phydev) && phy_is_started(phydev))
1160 		phy_queue_state_machine(phydev, PHY_STATE_TIME);
1161 	mutex_unlock(&phydev->lock);
1162 }
1163 
1164 /**
1165  * phy_mac_interrupt - MAC says the link has changed
1166  * @phydev: phy_device struct with changed link
1167  *
1168  * The MAC layer is able to indicate there has been a change in the PHY link
1169  * status. Trigger the state machine and work a work queue.
1170  */
1171 void phy_mac_interrupt(struct phy_device *phydev)
1172 {
1173 	/* Trigger a state machine change */
1174 	phy_trigger_machine(phydev);
1175 }
1176 EXPORT_SYMBOL(phy_mac_interrupt);
1177 
1178 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1179 {
1180 	linkmode_zero(advertising);
1181 
1182 	if (eee_adv & MDIO_EEE_100TX)
1183 		linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1184 				 advertising);
1185 	if (eee_adv & MDIO_EEE_1000T)
1186 		linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1187 				 advertising);
1188 	if (eee_adv & MDIO_EEE_10GT)
1189 		linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1190 				 advertising);
1191 	if (eee_adv & MDIO_EEE_1000KX)
1192 		linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1193 				 advertising);
1194 	if (eee_adv & MDIO_EEE_10GKX4)
1195 		linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1196 				 advertising);
1197 	if (eee_adv & MDIO_EEE_10GKR)
1198 		linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1199 				 advertising);
1200 }
1201 
1202 /**
1203  * phy_init_eee - init and check the EEE feature
1204  * @phydev: target phy_device struct
1205  * @clk_stop_enable: PHY may stop the clock during LPI
1206  *
1207  * Description: it checks if the Energy-Efficient Ethernet (EEE)
1208  * is supported by looking at the MMD registers 3.20 and 7.60/61
1209  * and it programs the MMD register 3.0 setting the "Clock stop enable"
1210  * bit if required.
1211  */
1212 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1213 {
1214 	if (!phydev->drv)
1215 		return -EIO;
1216 
1217 	/* According to 802.3az,the EEE is supported only in full duplex-mode.
1218 	 */
1219 	if (phydev->duplex == DUPLEX_FULL) {
1220 		__ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1221 		__ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1222 		__ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1223 		int eee_lp, eee_cap, eee_adv;
1224 		int status;
1225 		u32 cap;
1226 
1227 		/* Read phy status to properly get the right settings */
1228 		status = phy_read_status(phydev);
1229 		if (status)
1230 			return status;
1231 
1232 		/* First check if the EEE ability is supported */
1233 		eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1234 		if (eee_cap <= 0)
1235 			goto eee_exit_err;
1236 
1237 		cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1238 		if (!cap)
1239 			goto eee_exit_err;
1240 
1241 		/* Check which link settings negotiated and verify it in
1242 		 * the EEE advertising registers.
1243 		 */
1244 		eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1245 		if (eee_lp <= 0)
1246 			goto eee_exit_err;
1247 
1248 		eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1249 		if (eee_adv <= 0)
1250 			goto eee_exit_err;
1251 
1252 		mmd_eee_adv_to_linkmode(adv, eee_adv);
1253 		mmd_eee_adv_to_linkmode(lp, eee_lp);
1254 		linkmode_and(common, adv, lp);
1255 
1256 		if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1257 			goto eee_exit_err;
1258 
1259 		if (clk_stop_enable)
1260 			/* Configure the PHY to stop receiving xMII
1261 			 * clock while it is signaling LPI.
1262 			 */
1263 			phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1264 					 MDIO_PCS_CTRL1_CLKSTOP_EN);
1265 
1266 		return 0; /* EEE supported */
1267 	}
1268 eee_exit_err:
1269 	return -EPROTONOSUPPORT;
1270 }
1271 EXPORT_SYMBOL(phy_init_eee);
1272 
1273 /**
1274  * phy_get_eee_err - report the EEE wake error count
1275  * @phydev: target phy_device struct
1276  *
1277  * Description: it is to report the number of time where the PHY
1278  * failed to complete its normal wake sequence.
1279  */
1280 int phy_get_eee_err(struct phy_device *phydev)
1281 {
1282 	if (!phydev->drv)
1283 		return -EIO;
1284 
1285 	return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1286 }
1287 EXPORT_SYMBOL(phy_get_eee_err);
1288 
1289 /**
1290  * phy_ethtool_get_eee - get EEE supported and status
1291  * @phydev: target phy_device struct
1292  * @data: ethtool_eee data
1293  *
1294  * Description: it reportes the Supported/Advertisement/LP Advertisement
1295  * capabilities.
1296  */
1297 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1298 {
1299 	int val;
1300 
1301 	if (!phydev->drv)
1302 		return -EIO;
1303 
1304 	/* Get Supported EEE */
1305 	val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1306 	if (val < 0)
1307 		return val;
1308 	data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1309 
1310 	/* Get advertisement EEE */
1311 	val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1312 	if (val < 0)
1313 		return val;
1314 	data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1315 	data->eee_enabled = !!data->advertised;
1316 
1317 	/* Get LP advertisement EEE */
1318 	val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1319 	if (val < 0)
1320 		return val;
1321 	data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1322 
1323 	data->eee_active = !!(data->advertised & data->lp_advertised);
1324 
1325 	return 0;
1326 }
1327 EXPORT_SYMBOL(phy_ethtool_get_eee);
1328 
1329 /**
1330  * phy_ethtool_set_eee - set EEE supported and status
1331  * @phydev: target phy_device struct
1332  * @data: ethtool_eee data
1333  *
1334  * Description: it is to program the Advertisement EEE register.
1335  */
1336 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1337 {
1338 	int cap, old_adv, adv = 0, ret;
1339 
1340 	if (!phydev->drv)
1341 		return -EIO;
1342 
1343 	/* Get Supported EEE */
1344 	cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1345 	if (cap < 0)
1346 		return cap;
1347 
1348 	old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1349 	if (old_adv < 0)
1350 		return old_adv;
1351 
1352 	if (data->eee_enabled) {
1353 		adv = !data->advertised ? cap :
1354 		      ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1355 		/* Mask prohibited EEE modes */
1356 		adv &= ~phydev->eee_broken_modes;
1357 	}
1358 
1359 	if (old_adv != adv) {
1360 		ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1361 		if (ret < 0)
1362 			return ret;
1363 
1364 		/* Restart autonegotiation so the new modes get sent to the
1365 		 * link partner.
1366 		 */
1367 		if (phydev->autoneg == AUTONEG_ENABLE) {
1368 			ret = phy_restart_aneg(phydev);
1369 			if (ret < 0)
1370 				return ret;
1371 		}
1372 	}
1373 
1374 	return 0;
1375 }
1376 EXPORT_SYMBOL(phy_ethtool_set_eee);
1377 
1378 /**
1379  * phy_ethtool_set_wol - Configure Wake On LAN
1380  *
1381  * @phydev: target phy_device struct
1382  * @wol: Configuration requested
1383  */
1384 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1385 {
1386 	if (phydev->drv && phydev->drv->set_wol)
1387 		return phydev->drv->set_wol(phydev, wol);
1388 
1389 	return -EOPNOTSUPP;
1390 }
1391 EXPORT_SYMBOL(phy_ethtool_set_wol);
1392 
1393 /**
1394  * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1395  *
1396  * @phydev: target phy_device struct
1397  * @wol: Store the current configuration here
1398  */
1399 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1400 {
1401 	if (phydev->drv && phydev->drv->get_wol)
1402 		phydev->drv->get_wol(phydev, wol);
1403 }
1404 EXPORT_SYMBOL(phy_ethtool_get_wol);
1405 
1406 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1407 				   struct ethtool_link_ksettings *cmd)
1408 {
1409 	struct phy_device *phydev = ndev->phydev;
1410 
1411 	if (!phydev)
1412 		return -ENODEV;
1413 
1414 	phy_ethtool_ksettings_get(phydev, cmd);
1415 
1416 	return 0;
1417 }
1418 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1419 
1420 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1421 				   const struct ethtool_link_ksettings *cmd)
1422 {
1423 	struct phy_device *phydev = ndev->phydev;
1424 
1425 	if (!phydev)
1426 		return -ENODEV;
1427 
1428 	return phy_ethtool_ksettings_set(phydev, cmd);
1429 }
1430 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1431 
1432 /**
1433  * phy_ethtool_nway_reset - Restart auto negotiation
1434  * @ndev: Network device to restart autoneg for
1435  */
1436 int phy_ethtool_nway_reset(struct net_device *ndev)
1437 {
1438 	struct phy_device *phydev = ndev->phydev;
1439 
1440 	if (!phydev)
1441 		return -ENODEV;
1442 
1443 	if (!phydev->drv)
1444 		return -EIO;
1445 
1446 	return phy_restart_aneg(phydev);
1447 }
1448 EXPORT_SYMBOL(phy_ethtool_nway_reset);
1449