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