xref: /linux/drivers/net/phy/phy.c (revision 569bf6d4)
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 
phy_state_to_str(enum phy_state st)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 
phy_process_state_change(struct phy_device * phydev,enum phy_state old_state)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 
phy_link_up(struct phy_device * phydev)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 
phy_link_down(struct phy_device * phydev)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 
phy_pause_str(struct phy_device * phydev)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  */
phy_print_status(struct phy_device * phydev)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  */
phy_get_rate_matching(struct phy_device * phydev,phy_interface_t iface)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  */
phy_config_interrupt(struct phy_device * phydev,bool interrupts)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  */
phy_restart_aneg(struct phy_device * phydev)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  */
phy_aneg_done(struct phy_device * phydev)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 *
phy_find_valid(int speed,int duplex,unsigned long * supported)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  */
phy_supported_speeds(struct phy_device * phy,unsigned int * speeds,unsigned int size)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  */
phy_check_valid(int speed,int duplex,unsigned long * features)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  */
phy_sanitize_settings(struct phy_device * phydev)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 
phy_ethtool_ksettings_get(struct phy_device * phydev,struct ethtool_link_ksettings * cmd)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  */
phy_mii_ioctl(struct phy_device * phydev,struct ifreq * ifr,int cmd)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 	struct kernel_hwtstamp_config kernel_cfg;
329 	struct netlink_ext_ack extack = {};
330 	u16 val = mii_data->val_in;
331 	bool change_autoneg = false;
332 	struct hwtstamp_config cfg;
333 	int prtad, devad;
334 	int ret;
335 
336 	switch (cmd) {
337 	case SIOCGMIIPHY:
338 		mii_data->phy_id = phydev->mdio.addr;
339 		fallthrough;
340 
341 	case SIOCGMIIREG:
342 		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
343 			prtad = mdio_phy_id_prtad(mii_data->phy_id);
344 			devad = mdio_phy_id_devad(mii_data->phy_id);
345 			ret = mdiobus_c45_read(phydev->mdio.bus, prtad, devad,
346 					       mii_data->reg_num);
347 
348 		} else {
349 			ret = mdiobus_read(phydev->mdio.bus, mii_data->phy_id,
350 					   mii_data->reg_num);
351 		}
352 
353 		if (ret < 0)
354 			return ret;
355 
356 		mii_data->val_out = ret;
357 
358 		return 0;
359 
360 	case SIOCSMIIREG:
361 		if (mdio_phy_id_is_c45(mii_data->phy_id)) {
362 			prtad = mdio_phy_id_prtad(mii_data->phy_id);
363 			devad = mdio_phy_id_devad(mii_data->phy_id);
364 		} else {
365 			prtad = mii_data->phy_id;
366 			devad = mii_data->reg_num;
367 		}
368 		if (prtad == phydev->mdio.addr) {
369 			switch (devad) {
370 			case MII_BMCR:
371 				if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
372 					if (phydev->autoneg == AUTONEG_ENABLE)
373 						change_autoneg = true;
374 					phydev->autoneg = AUTONEG_DISABLE;
375 					if (val & BMCR_FULLDPLX)
376 						phydev->duplex = DUPLEX_FULL;
377 					else
378 						phydev->duplex = DUPLEX_HALF;
379 					if (val & BMCR_SPEED1000)
380 						phydev->speed = SPEED_1000;
381 					else if (val & BMCR_SPEED100)
382 						phydev->speed = SPEED_100;
383 					else phydev->speed = SPEED_10;
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 		if (mdio_phy_id_is_c45(mii_data->phy_id))
407 			mdiobus_c45_write(phydev->mdio.bus, prtad, devad,
408 					  mii_data->reg_num, val);
409 		else
410 			mdiobus_write(phydev->mdio.bus, prtad, devad, val);
411 
412 		if (prtad == phydev->mdio.addr &&
413 		    devad == MII_BMCR &&
414 		    val & BMCR_RESET)
415 			return phy_init_hw(phydev);
416 
417 		if (change_autoneg)
418 			return phy_start_aneg(phydev);
419 
420 		return 0;
421 
422 	case SIOCSHWTSTAMP:
423 		if (phydev->mii_ts && phydev->mii_ts->hwtstamp) {
424 			if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
425 				return -EFAULT;
426 
427 			hwtstamp_config_to_kernel(&kernel_cfg, &cfg);
428 			ret = phydev->mii_ts->hwtstamp(phydev->mii_ts, &kernel_cfg, &extack);
429 			if (ret)
430 				return ret;
431 
432 			hwtstamp_config_from_kernel(&cfg, &kernel_cfg);
433 			if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)))
434 				return -EFAULT;
435 
436 			return 0;
437 		}
438 		fallthrough;
439 
440 	default:
441 		return -EOPNOTSUPP;
442 	}
443 }
444 EXPORT_SYMBOL(phy_mii_ioctl);
445 
446 /**
447  * phy_do_ioctl - generic ndo_eth_ioctl implementation
448  * @dev: the net_device struct
449  * @ifr: &struct ifreq for socket ioctl's
450  * @cmd: ioctl cmd to execute
451  */
phy_do_ioctl(struct net_device * dev,struct ifreq * ifr,int cmd)452 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
453 {
454 	if (!dev->phydev)
455 		return -ENODEV;
456 
457 	return phy_mii_ioctl(dev->phydev, ifr, cmd);
458 }
459 EXPORT_SYMBOL(phy_do_ioctl);
460 
461 /**
462  * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first
463  *
464  * @dev: the net_device struct
465  * @ifr: &struct ifreq for socket ioctl's
466  * @cmd: ioctl cmd to execute
467  *
468  * Same as phy_do_ioctl, but ensures that net_device is running before
469  * handling the ioctl.
470  */
phy_do_ioctl_running(struct net_device * dev,struct ifreq * ifr,int cmd)471 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
472 {
473 	if (!netif_running(dev))
474 		return -ENODEV;
475 
476 	return phy_do_ioctl(dev, ifr, cmd);
477 }
478 EXPORT_SYMBOL(phy_do_ioctl_running);
479 
480 /**
481  * __phy_hwtstamp_get - Get hardware timestamping configuration from PHY
482  *
483  * @phydev: the PHY device structure
484  * @config: structure holding the timestamping configuration
485  *
486  * Query the PHY device for its current hardware timestamping configuration.
487  */
__phy_hwtstamp_get(struct phy_device * phydev,struct kernel_hwtstamp_config * config)488 int __phy_hwtstamp_get(struct phy_device *phydev,
489 		       struct kernel_hwtstamp_config *config)
490 {
491 	if (!phydev)
492 		return -ENODEV;
493 
494 	return -EOPNOTSUPP;
495 }
496 
497 /**
498  * __phy_hwtstamp_set - Modify PHY hardware timestamping configuration
499  *
500  * @phydev: the PHY device structure
501  * @config: structure holding the timestamping configuration
502  * @extack: netlink extended ack structure, for error reporting
503  */
__phy_hwtstamp_set(struct phy_device * phydev,struct kernel_hwtstamp_config * config,struct netlink_ext_ack * extack)504 int __phy_hwtstamp_set(struct phy_device *phydev,
505 		       struct kernel_hwtstamp_config *config,
506 		       struct netlink_ext_ack *extack)
507 {
508 	if (!phydev)
509 		return -ENODEV;
510 
511 	if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
512 		return phydev->mii_ts->hwtstamp(phydev->mii_ts, config, extack);
513 
514 	return -EOPNOTSUPP;
515 }
516 
517 /**
518  * phy_queue_state_machine - Trigger the state machine to run soon
519  *
520  * @phydev: the phy_device struct
521  * @jiffies: Run the state machine after these jiffies
522  */
phy_queue_state_machine(struct phy_device * phydev,unsigned long jiffies)523 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
524 {
525 	mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
526 			 jiffies);
527 }
528 EXPORT_SYMBOL(phy_queue_state_machine);
529 
530 /**
531  * phy_trigger_machine - Trigger the state machine to run now
532  *
533  * @phydev: the phy_device struct
534  */
phy_trigger_machine(struct phy_device * phydev)535 void phy_trigger_machine(struct phy_device *phydev)
536 {
537 	phy_queue_state_machine(phydev, 0);
538 }
539 EXPORT_SYMBOL(phy_trigger_machine);
540 
phy_abort_cable_test(struct phy_device * phydev)541 static void phy_abort_cable_test(struct phy_device *phydev)
542 {
543 	int err;
544 
545 	ethnl_cable_test_finished(phydev);
546 
547 	err = phy_init_hw(phydev);
548 	if (err)
549 		phydev_err(phydev, "Error while aborting cable test");
550 }
551 
552 /**
553  * phy_ethtool_get_strings - Get the statistic counter names
554  *
555  * @phydev: the phy_device struct
556  * @data: Where to put the strings
557  */
phy_ethtool_get_strings(struct phy_device * phydev,u8 * data)558 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
559 {
560 	if (!phydev->drv)
561 		return -EIO;
562 
563 	mutex_lock(&phydev->lock);
564 	phydev->drv->get_strings(phydev, data);
565 	mutex_unlock(&phydev->lock);
566 
567 	return 0;
568 }
569 EXPORT_SYMBOL(phy_ethtool_get_strings);
570 
571 /**
572  * phy_ethtool_get_sset_count - Get the number of statistic counters
573  *
574  * @phydev: the phy_device struct
575  */
phy_ethtool_get_sset_count(struct phy_device * phydev)576 int phy_ethtool_get_sset_count(struct phy_device *phydev)
577 {
578 	int ret;
579 
580 	if (!phydev->drv)
581 		return -EIO;
582 
583 	if (phydev->drv->get_sset_count &&
584 	    phydev->drv->get_strings &&
585 	    phydev->drv->get_stats) {
586 		mutex_lock(&phydev->lock);
587 		ret = phydev->drv->get_sset_count(phydev);
588 		mutex_unlock(&phydev->lock);
589 
590 		return ret;
591 	}
592 
593 	return -EOPNOTSUPP;
594 }
595 EXPORT_SYMBOL(phy_ethtool_get_sset_count);
596 
597 /**
598  * phy_ethtool_get_stats - Get the statistic counters
599  *
600  * @phydev: the phy_device struct
601  * @stats: What counters to get
602  * @data: Where to store the counters
603  */
phy_ethtool_get_stats(struct phy_device * phydev,struct ethtool_stats * stats,u64 * data)604 int phy_ethtool_get_stats(struct phy_device *phydev,
605 			  struct ethtool_stats *stats, u64 *data)
606 {
607 	if (!phydev->drv)
608 		return -EIO;
609 
610 	mutex_lock(&phydev->lock);
611 	phydev->drv->get_stats(phydev, stats, data);
612 	mutex_unlock(&phydev->lock);
613 
614 	return 0;
615 }
616 EXPORT_SYMBOL(phy_ethtool_get_stats);
617 
618 /**
619  * phy_ethtool_get_plca_cfg - Get PLCA RS configuration
620  * @phydev: the phy_device struct
621  * @plca_cfg: where to store the retrieved configuration
622  *
623  * Retrieve the PLCA configuration from the PHY. Return 0 on success or a
624  * negative value if an error occurred.
625  */
phy_ethtool_get_plca_cfg(struct phy_device * phydev,struct phy_plca_cfg * plca_cfg)626 int phy_ethtool_get_plca_cfg(struct phy_device *phydev,
627 			     struct phy_plca_cfg *plca_cfg)
628 {
629 	int ret;
630 
631 	if (!phydev->drv) {
632 		ret = -EIO;
633 		goto out;
634 	}
635 
636 	if (!phydev->drv->get_plca_cfg) {
637 		ret = -EOPNOTSUPP;
638 		goto out;
639 	}
640 
641 	mutex_lock(&phydev->lock);
642 	ret = phydev->drv->get_plca_cfg(phydev, plca_cfg);
643 
644 	mutex_unlock(&phydev->lock);
645 out:
646 	return ret;
647 }
648 
649 /**
650  * plca_check_valid - Check PLCA configuration before enabling
651  * @phydev: the phy_device struct
652  * @plca_cfg: current PLCA configuration
653  * @extack: extack for reporting useful error messages
654  *
655  * Checks whether the PLCA and PHY configuration are consistent and it is safe
656  * to enable PLCA. Returns 0 on success or a negative value if the PLCA or PHY
657  * configuration is not consistent.
658  */
plca_check_valid(struct phy_device * phydev,const struct phy_plca_cfg * plca_cfg,struct netlink_ext_ack * extack)659 static int plca_check_valid(struct phy_device *phydev,
660 			    const struct phy_plca_cfg *plca_cfg,
661 			    struct netlink_ext_ack *extack)
662 {
663 	int ret = 0;
664 
665 	if (!linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,
666 			       phydev->advertising)) {
667 		ret = -EOPNOTSUPP;
668 		NL_SET_ERR_MSG(extack,
669 			       "Point to Multi-Point mode is not enabled");
670 	} else if (plca_cfg->node_id >= 255) {
671 		NL_SET_ERR_MSG(extack, "PLCA node ID is not set");
672 		ret = -EINVAL;
673 	}
674 
675 	return ret;
676 }
677 
678 /**
679  * phy_ethtool_set_plca_cfg - Set PLCA RS configuration
680  * @phydev: the phy_device struct
681  * @plca_cfg: new PLCA configuration to apply
682  * @extack: extack for reporting useful error messages
683  *
684  * Sets the PLCA configuration in the PHY. Return 0 on success or a
685  * negative value if an error occurred.
686  */
phy_ethtool_set_plca_cfg(struct phy_device * phydev,const struct phy_plca_cfg * plca_cfg,struct netlink_ext_ack * extack)687 int phy_ethtool_set_plca_cfg(struct phy_device *phydev,
688 			     const struct phy_plca_cfg *plca_cfg,
689 			     struct netlink_ext_ack *extack)
690 {
691 	struct phy_plca_cfg *curr_plca_cfg;
692 	int ret;
693 
694 	if (!phydev->drv) {
695 		ret = -EIO;
696 		goto out;
697 	}
698 
699 	if (!phydev->drv->set_plca_cfg ||
700 	    !phydev->drv->get_plca_cfg) {
701 		ret = -EOPNOTSUPP;
702 		goto out;
703 	}
704 
705 	curr_plca_cfg = kmalloc(sizeof(*curr_plca_cfg), GFP_KERNEL);
706 	if (!curr_plca_cfg) {
707 		ret = -ENOMEM;
708 		goto out;
709 	}
710 
711 	mutex_lock(&phydev->lock);
712 
713 	ret = phydev->drv->get_plca_cfg(phydev, curr_plca_cfg);
714 	if (ret)
715 		goto out_drv;
716 
717 	if (curr_plca_cfg->enabled < 0 && plca_cfg->enabled >= 0) {
718 		NL_SET_ERR_MSG(extack,
719 			       "PHY does not support changing the PLCA 'enable' attribute");
720 		ret = -EINVAL;
721 		goto out_drv;
722 	}
723 
724 	if (curr_plca_cfg->node_id < 0 && plca_cfg->node_id >= 0) {
725 		NL_SET_ERR_MSG(extack,
726 			       "PHY does not support changing the PLCA 'local node ID' attribute");
727 		ret = -EINVAL;
728 		goto out_drv;
729 	}
730 
731 	if (curr_plca_cfg->node_cnt < 0 && plca_cfg->node_cnt >= 0) {
732 		NL_SET_ERR_MSG(extack,
733 			       "PHY does not support changing the PLCA 'node count' attribute");
734 		ret = -EINVAL;
735 		goto out_drv;
736 	}
737 
738 	if (curr_plca_cfg->to_tmr < 0 && plca_cfg->to_tmr >= 0) {
739 		NL_SET_ERR_MSG(extack,
740 			       "PHY does not support changing the PLCA 'TO timer' attribute");
741 		ret = -EINVAL;
742 		goto out_drv;
743 	}
744 
745 	if (curr_plca_cfg->burst_cnt < 0 && plca_cfg->burst_cnt >= 0) {
746 		NL_SET_ERR_MSG(extack,
747 			       "PHY does not support changing the PLCA 'burst count' attribute");
748 		ret = -EINVAL;
749 		goto out_drv;
750 	}
751 
752 	if (curr_plca_cfg->burst_tmr < 0 && plca_cfg->burst_tmr >= 0) {
753 		NL_SET_ERR_MSG(extack,
754 			       "PHY does not support changing the PLCA 'burst timer' attribute");
755 		ret = -EINVAL;
756 		goto out_drv;
757 	}
758 
759 	// if enabling PLCA, perform a few sanity checks
760 	if (plca_cfg->enabled > 0) {
761 		// allow setting node_id concurrently with enabled
762 		if (plca_cfg->node_id >= 0)
763 			curr_plca_cfg->node_id = plca_cfg->node_id;
764 
765 		ret = plca_check_valid(phydev, curr_plca_cfg, extack);
766 		if (ret)
767 			goto out_drv;
768 	}
769 
770 	ret = phydev->drv->set_plca_cfg(phydev, plca_cfg);
771 
772 out_drv:
773 	kfree(curr_plca_cfg);
774 	mutex_unlock(&phydev->lock);
775 out:
776 	return ret;
777 }
778 
779 /**
780  * phy_ethtool_get_plca_status - Get PLCA RS status information
781  * @phydev: the phy_device struct
782  * @plca_st: where to store the retrieved status information
783  *
784  * Retrieve the PLCA status information from the PHY. Return 0 on success or a
785  * negative value if an error occurred.
786  */
phy_ethtool_get_plca_status(struct phy_device * phydev,struct phy_plca_status * plca_st)787 int phy_ethtool_get_plca_status(struct phy_device *phydev,
788 				struct phy_plca_status *plca_st)
789 {
790 	int ret;
791 
792 	if (!phydev->drv) {
793 		ret = -EIO;
794 		goto out;
795 	}
796 
797 	if (!phydev->drv->get_plca_status) {
798 		ret = -EOPNOTSUPP;
799 		goto out;
800 	}
801 
802 	mutex_lock(&phydev->lock);
803 	ret = phydev->drv->get_plca_status(phydev, plca_st);
804 
805 	mutex_unlock(&phydev->lock);
806 out:
807 	return ret;
808 }
809 
810 /**
811  * phy_start_cable_test - Start a cable test
812  *
813  * @phydev: the phy_device struct
814  * @extack: extack for reporting useful error messages
815  */
phy_start_cable_test(struct phy_device * phydev,struct netlink_ext_ack * extack)816 int phy_start_cable_test(struct phy_device *phydev,
817 			 struct netlink_ext_ack *extack)
818 {
819 	struct net_device *dev = phydev->attached_dev;
820 	int err = -ENOMEM;
821 
822 	if (!(phydev->drv &&
823 	      phydev->drv->cable_test_start &&
824 	      phydev->drv->cable_test_get_status)) {
825 		NL_SET_ERR_MSG(extack,
826 			       "PHY driver does not support cable testing");
827 		return -EOPNOTSUPP;
828 	}
829 
830 	mutex_lock(&phydev->lock);
831 	if (phydev->state == PHY_CABLETEST) {
832 		NL_SET_ERR_MSG(extack,
833 			       "PHY already performing a test");
834 		err = -EBUSY;
835 		goto out;
836 	}
837 
838 	if (phydev->state < PHY_UP ||
839 	    phydev->state > PHY_CABLETEST) {
840 		NL_SET_ERR_MSG(extack,
841 			       "PHY not configured. Try setting interface up");
842 		err = -EBUSY;
843 		goto out;
844 	}
845 
846 	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
847 	if (err)
848 		goto out;
849 
850 	/* Mark the carrier down until the test is complete */
851 	phy_link_down(phydev);
852 
853 	netif_testing_on(dev);
854 	err = phydev->drv->cable_test_start(phydev);
855 	if (err) {
856 		netif_testing_off(dev);
857 		phy_link_up(phydev);
858 		goto out_free;
859 	}
860 
861 	phydev->state = PHY_CABLETEST;
862 
863 	if (phy_polling_mode(phydev))
864 		phy_trigger_machine(phydev);
865 
866 	mutex_unlock(&phydev->lock);
867 
868 	return 0;
869 
870 out_free:
871 	ethnl_cable_test_free(phydev);
872 out:
873 	mutex_unlock(&phydev->lock);
874 
875 	return err;
876 }
877 EXPORT_SYMBOL(phy_start_cable_test);
878 
879 /**
880  * phy_start_cable_test_tdr - Start a raw TDR cable test
881  *
882  * @phydev: the phy_device struct
883  * @extack: extack for reporting useful error messages
884  * @config: Configuration of the test to run
885  */
phy_start_cable_test_tdr(struct phy_device * phydev,struct netlink_ext_ack * extack,const struct phy_tdr_config * config)886 int phy_start_cable_test_tdr(struct phy_device *phydev,
887 			     struct netlink_ext_ack *extack,
888 			     const struct phy_tdr_config *config)
889 {
890 	struct net_device *dev = phydev->attached_dev;
891 	int err = -ENOMEM;
892 
893 	if (!(phydev->drv &&
894 	      phydev->drv->cable_test_tdr_start &&
895 	      phydev->drv->cable_test_get_status)) {
896 		NL_SET_ERR_MSG(extack,
897 			       "PHY driver does not support cable test TDR");
898 		return -EOPNOTSUPP;
899 	}
900 
901 	mutex_lock(&phydev->lock);
902 	if (phydev->state == PHY_CABLETEST) {
903 		NL_SET_ERR_MSG(extack,
904 			       "PHY already performing a test");
905 		err = -EBUSY;
906 		goto out;
907 	}
908 
909 	if (phydev->state < PHY_UP ||
910 	    phydev->state > PHY_CABLETEST) {
911 		NL_SET_ERR_MSG(extack,
912 			       "PHY not configured. Try setting interface up");
913 		err = -EBUSY;
914 		goto out;
915 	}
916 
917 	err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
918 	if (err)
919 		goto out;
920 
921 	/* Mark the carrier down until the test is complete */
922 	phy_link_down(phydev);
923 
924 	netif_testing_on(dev);
925 	err = phydev->drv->cable_test_tdr_start(phydev, config);
926 	if (err) {
927 		netif_testing_off(dev);
928 		phy_link_up(phydev);
929 		goto out_free;
930 	}
931 
932 	phydev->state = PHY_CABLETEST;
933 
934 	if (phy_polling_mode(phydev))
935 		phy_trigger_machine(phydev);
936 
937 	mutex_unlock(&phydev->lock);
938 
939 	return 0;
940 
941 out_free:
942 	ethnl_cable_test_free(phydev);
943 out:
944 	mutex_unlock(&phydev->lock);
945 
946 	return err;
947 }
948 EXPORT_SYMBOL(phy_start_cable_test_tdr);
949 
phy_config_aneg(struct phy_device * phydev)950 int phy_config_aneg(struct phy_device *phydev)
951 {
952 	if (phydev->drv->config_aneg)
953 		return phydev->drv->config_aneg(phydev);
954 
955 	/* Clause 45 PHYs that don't implement Clause 22 registers are not
956 	 * allowed to call genphy_config_aneg()
957 	 */
958 	if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
959 		return genphy_c45_config_aneg(phydev);
960 
961 	return genphy_config_aneg(phydev);
962 }
963 EXPORT_SYMBOL(phy_config_aneg);
964 
965 /**
966  * phy_check_link_status - check link status and set state accordingly
967  * @phydev: the phy_device struct
968  *
969  * Description: Check for link and whether autoneg was triggered / is running
970  * and set state accordingly
971  */
phy_check_link_status(struct phy_device * phydev)972 static int phy_check_link_status(struct phy_device *phydev)
973 {
974 	int err;
975 
976 	lockdep_assert_held(&phydev->lock);
977 
978 	/* Keep previous state if loopback is enabled because some PHYs
979 	 * report that Link is Down when loopback is enabled.
980 	 */
981 	if (phydev->loopback_enabled)
982 		return 0;
983 
984 	err = phy_read_status(phydev);
985 	if (err)
986 		return err;
987 
988 	if (phydev->link && phydev->state != PHY_RUNNING) {
989 		phy_check_downshift(phydev);
990 		phydev->state = PHY_RUNNING;
991 		err = genphy_c45_eee_is_active(phydev,
992 					       NULL, NULL, NULL);
993 		if (err <= 0)
994 			phydev->enable_tx_lpi = false;
995 		else
996 			phydev->enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled;
997 
998 		phy_link_up(phydev);
999 	} else if (!phydev->link && phydev->state != PHY_NOLINK) {
1000 		phydev->state = PHY_NOLINK;
1001 		phydev->enable_tx_lpi = false;
1002 		phy_link_down(phydev);
1003 	}
1004 
1005 	return 0;
1006 }
1007 
1008 /**
1009  * _phy_start_aneg - start auto-negotiation for this PHY device
1010  * @phydev: the phy_device struct
1011  *
1012  * Description: Sanitizes the settings (if we're not autonegotiating
1013  *   them), and then calls the driver's config_aneg function.
1014  *   If the PHYCONTROL Layer is operating, we change the state to
1015  *   reflect the beginning of Auto-negotiation or forcing.
1016  */
_phy_start_aneg(struct phy_device * phydev)1017 int _phy_start_aneg(struct phy_device *phydev)
1018 {
1019 	int err;
1020 
1021 	lockdep_assert_held(&phydev->lock);
1022 
1023 	if (!phydev->drv)
1024 		return -EIO;
1025 
1026 	if (AUTONEG_DISABLE == phydev->autoneg)
1027 		phy_sanitize_settings(phydev);
1028 
1029 	err = phy_config_aneg(phydev);
1030 	if (err < 0)
1031 		return err;
1032 
1033 	if (phy_is_started(phydev))
1034 		err = phy_check_link_status(phydev);
1035 
1036 	return err;
1037 }
1038 EXPORT_SYMBOL(_phy_start_aneg);
1039 
1040 /**
1041  * phy_start_aneg - start auto-negotiation for this PHY device
1042  * @phydev: the phy_device struct
1043  *
1044  * Description: Sanitizes the settings (if we're not autonegotiating
1045  *   them), and then calls the driver's config_aneg function.
1046  *   If the PHYCONTROL Layer is operating, we change the state to
1047  *   reflect the beginning of Auto-negotiation or forcing.
1048  */
phy_start_aneg(struct phy_device * phydev)1049 int phy_start_aneg(struct phy_device *phydev)
1050 {
1051 	int err;
1052 
1053 	mutex_lock(&phydev->lock);
1054 	err = _phy_start_aneg(phydev);
1055 	mutex_unlock(&phydev->lock);
1056 
1057 	return err;
1058 }
1059 EXPORT_SYMBOL(phy_start_aneg);
1060 
phy_poll_aneg_done(struct phy_device * phydev)1061 static int phy_poll_aneg_done(struct phy_device *phydev)
1062 {
1063 	unsigned int retries = 100;
1064 	int ret;
1065 
1066 	do {
1067 		msleep(100);
1068 		ret = phy_aneg_done(phydev);
1069 	} while (!ret && --retries);
1070 
1071 	if (!ret)
1072 		return -ETIMEDOUT;
1073 
1074 	return ret < 0 ? ret : 0;
1075 }
1076 
phy_ethtool_ksettings_set(struct phy_device * phydev,const struct ethtool_link_ksettings * cmd)1077 int phy_ethtool_ksettings_set(struct phy_device *phydev,
1078 			      const struct ethtool_link_ksettings *cmd)
1079 {
1080 	__ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
1081 	u8 autoneg = cmd->base.autoneg;
1082 	u8 duplex = cmd->base.duplex;
1083 	u32 speed = cmd->base.speed;
1084 
1085 	if (cmd->base.phy_address != phydev->mdio.addr)
1086 		return -EINVAL;
1087 
1088 	linkmode_copy(advertising, cmd->link_modes.advertising);
1089 
1090 	/* We make sure that we don't pass unsupported values in to the PHY */
1091 	linkmode_and(advertising, advertising, phydev->supported);
1092 
1093 	/* Verify the settings we care about. */
1094 	if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
1095 		return -EINVAL;
1096 
1097 	if (autoneg == AUTONEG_ENABLE &&
1098 	    (linkmode_empty(advertising) ||
1099 	     !linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1100 				phydev->supported)))
1101 		return -EINVAL;
1102 
1103 	if (autoneg == AUTONEG_DISABLE &&
1104 	    ((speed != SPEED_1000 &&
1105 	      speed != SPEED_100 &&
1106 	      speed != SPEED_10) ||
1107 	     (duplex != DUPLEX_HALF &&
1108 	      duplex != DUPLEX_FULL)))
1109 		return -EINVAL;
1110 
1111 	mutex_lock(&phydev->lock);
1112 	phydev->autoneg = autoneg;
1113 
1114 	if (autoneg == AUTONEG_DISABLE) {
1115 		phydev->speed = speed;
1116 		phydev->duplex = duplex;
1117 	}
1118 
1119 	linkmode_copy(phydev->advertising, advertising);
1120 
1121 	linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1122 			 phydev->advertising, autoneg == AUTONEG_ENABLE);
1123 
1124 	phydev->master_slave_set = cmd->base.master_slave_cfg;
1125 	phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
1126 
1127 	/* Restart the PHY */
1128 	if (phy_is_started(phydev)) {
1129 		phydev->state = PHY_UP;
1130 		phy_trigger_machine(phydev);
1131 	} else {
1132 		_phy_start_aneg(phydev);
1133 	}
1134 
1135 	mutex_unlock(&phydev->lock);
1136 	return 0;
1137 }
1138 EXPORT_SYMBOL(phy_ethtool_ksettings_set);
1139 
1140 /**
1141  * phy_speed_down - set speed to lowest speed supported by both link partners
1142  * @phydev: the phy_device struct
1143  * @sync: perform action synchronously
1144  *
1145  * Description: Typically used to save energy when waiting for a WoL packet
1146  *
1147  * WARNING: Setting sync to false may cause the system being unable to suspend
1148  * in case the PHY generates an interrupt when finishing the autonegotiation.
1149  * This interrupt may wake up the system immediately after suspend.
1150  * Therefore use sync = false only if you're sure it's safe with the respective
1151  * network chip.
1152  */
phy_speed_down(struct phy_device * phydev,bool sync)1153 int phy_speed_down(struct phy_device *phydev, bool sync)
1154 {
1155 	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
1156 	int ret = 0;
1157 
1158 	mutex_lock(&phydev->lock);
1159 
1160 	if (phydev->autoneg != AUTONEG_ENABLE)
1161 		goto out;
1162 
1163 	linkmode_copy(adv_tmp, phydev->advertising);
1164 
1165 	ret = phy_speed_down_core(phydev);
1166 	if (ret)
1167 		goto out;
1168 
1169 	linkmode_copy(phydev->adv_old, adv_tmp);
1170 
1171 	if (linkmode_equal(phydev->advertising, adv_tmp)) {
1172 		ret = 0;
1173 		goto out;
1174 	}
1175 
1176 	ret = phy_config_aneg(phydev);
1177 	if (ret)
1178 		goto out;
1179 
1180 	ret = sync ? phy_poll_aneg_done(phydev) : 0;
1181 out:
1182 	mutex_unlock(&phydev->lock);
1183 
1184 	return ret;
1185 }
1186 EXPORT_SYMBOL_GPL(phy_speed_down);
1187 
1188 /**
1189  * phy_speed_up - (re)set advertised speeds to all supported speeds
1190  * @phydev: the phy_device struct
1191  *
1192  * Description: Used to revert the effect of phy_speed_down
1193  */
phy_speed_up(struct phy_device * phydev)1194 int phy_speed_up(struct phy_device *phydev)
1195 {
1196 	__ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
1197 	int ret = 0;
1198 
1199 	mutex_lock(&phydev->lock);
1200 
1201 	if (phydev->autoneg != AUTONEG_ENABLE)
1202 		goto out;
1203 
1204 	if (linkmode_empty(phydev->adv_old))
1205 		goto out;
1206 
1207 	linkmode_copy(adv_tmp, phydev->advertising);
1208 	linkmode_copy(phydev->advertising, phydev->adv_old);
1209 	linkmode_zero(phydev->adv_old);
1210 
1211 	if (linkmode_equal(phydev->advertising, adv_tmp))
1212 		goto out;
1213 
1214 	ret = phy_config_aneg(phydev);
1215 out:
1216 	mutex_unlock(&phydev->lock);
1217 
1218 	return ret;
1219 }
1220 EXPORT_SYMBOL_GPL(phy_speed_up);
1221 
1222 /**
1223  * phy_start_machine - start PHY state machine tracking
1224  * @phydev: the phy_device struct
1225  *
1226  * Description: The PHY infrastructure can run a state machine
1227  *   which tracks whether the PHY is starting up, negotiating,
1228  *   etc.  This function starts the delayed workqueue which tracks
1229  *   the state of the PHY. If you want to maintain your own state machine,
1230  *   do not call this function.
1231  */
phy_start_machine(struct phy_device * phydev)1232 void phy_start_machine(struct phy_device *phydev)
1233 {
1234 	phy_trigger_machine(phydev);
1235 }
1236 EXPORT_SYMBOL_GPL(phy_start_machine);
1237 
1238 /**
1239  * phy_stop_machine - stop the PHY state machine tracking
1240  * @phydev: target phy_device struct
1241  *
1242  * Description: Stops the state machine delayed workqueue, sets the
1243  *   state to UP (unless it wasn't up yet). This function must be
1244  *   called BEFORE phy_detach.
1245  */
phy_stop_machine(struct phy_device * phydev)1246 void phy_stop_machine(struct phy_device *phydev)
1247 {
1248 	cancel_delayed_work_sync(&phydev->state_queue);
1249 
1250 	mutex_lock(&phydev->lock);
1251 	if (phy_is_started(phydev))
1252 		phydev->state = PHY_UP;
1253 	mutex_unlock(&phydev->lock);
1254 }
1255 
phy_process_error(struct phy_device * phydev)1256 static void phy_process_error(struct phy_device *phydev)
1257 {
1258 	/* phydev->lock must be held for the state change to be safe */
1259 	if (!mutex_is_locked(&phydev->lock))
1260 		phydev_err(phydev, "PHY-device data unsafe context\n");
1261 
1262 	phydev->state = PHY_ERROR;
1263 
1264 	phy_trigger_machine(phydev);
1265 }
1266 
phy_error_precise(struct phy_device * phydev,const void * func,int err)1267 static void phy_error_precise(struct phy_device *phydev,
1268 			      const void *func, int err)
1269 {
1270 	WARN(1, "%pS: returned: %d\n", func, err);
1271 	phy_process_error(phydev);
1272 }
1273 
1274 /**
1275  * phy_error - enter ERROR state for this PHY device
1276  * @phydev: target phy_device struct
1277  *
1278  * Moves the PHY to the ERROR state in response to a read
1279  * or write error, and tells the controller the link is down.
1280  * Must be called with phydev->lock held.
1281  */
phy_error(struct phy_device * phydev)1282 void phy_error(struct phy_device *phydev)
1283 {
1284 	WARN_ON(1);
1285 	phy_process_error(phydev);
1286 }
1287 EXPORT_SYMBOL(phy_error);
1288 
1289 /**
1290  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
1291  * @phydev: target phy_device struct
1292  */
phy_disable_interrupts(struct phy_device * phydev)1293 int phy_disable_interrupts(struct phy_device *phydev)
1294 {
1295 	/* Disable PHY interrupts */
1296 	return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
1297 }
1298 
1299 /**
1300  * phy_interrupt - PHY interrupt handler
1301  * @irq: interrupt line
1302  * @phy_dat: phy_device pointer
1303  *
1304  * Description: Handle PHY interrupt
1305  */
phy_interrupt(int irq,void * phy_dat)1306 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
1307 {
1308 	struct phy_device *phydev = phy_dat;
1309 	irqreturn_t ret;
1310 
1311 	/* Wakeup interrupts may occur during a system sleep transition.
1312 	 * Postpone handling until the PHY has resumed.
1313 	 */
1314 	if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
1315 		struct net_device *netdev = phydev->attached_dev;
1316 
1317 		if (netdev) {
1318 			struct device *parent = netdev->dev.parent;
1319 
1320 			if (netdev->ethtool->wol_enabled)
1321 				pm_system_wakeup();
1322 			else if (device_may_wakeup(&netdev->dev))
1323 				pm_wakeup_dev_event(&netdev->dev, 0, true);
1324 			else if (parent && device_may_wakeup(parent))
1325 				pm_wakeup_dev_event(parent, 0, true);
1326 		}
1327 
1328 		phydev->irq_rerun = 1;
1329 		disable_irq_nosync(irq);
1330 		return IRQ_HANDLED;
1331 	}
1332 
1333 	mutex_lock(&phydev->lock);
1334 	ret = phydev->drv->handle_interrupt(phydev);
1335 	mutex_unlock(&phydev->lock);
1336 
1337 	return ret;
1338 }
1339 
1340 /**
1341  * phy_enable_interrupts - Enable the interrupts from the PHY side
1342  * @phydev: target phy_device struct
1343  */
phy_enable_interrupts(struct phy_device * phydev)1344 static int phy_enable_interrupts(struct phy_device *phydev)
1345 {
1346 	return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1347 }
1348 
1349 /**
1350  * phy_request_interrupt - request and enable interrupt for a PHY device
1351  * @phydev: target phy_device struct
1352  *
1353  * Description: Request and enable the interrupt for the given PHY.
1354  *   If this fails, then we set irq to PHY_POLL.
1355  *   This should only be called with a valid IRQ number.
1356  */
phy_request_interrupt(struct phy_device * phydev)1357 void phy_request_interrupt(struct phy_device *phydev)
1358 {
1359 	int err;
1360 
1361 	err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1362 				   IRQF_ONESHOT | IRQF_SHARED,
1363 				   phydev_name(phydev), phydev);
1364 	if (err) {
1365 		phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1366 			    err, phydev->irq);
1367 		phydev->irq = PHY_POLL;
1368 	} else {
1369 		if (phy_enable_interrupts(phydev)) {
1370 			phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1371 			phy_free_interrupt(phydev);
1372 			phydev->irq = PHY_POLL;
1373 		}
1374 	}
1375 }
1376 EXPORT_SYMBOL(phy_request_interrupt);
1377 
1378 /**
1379  * phy_free_interrupt - disable and free interrupt for a PHY device
1380  * @phydev: target phy_device struct
1381  *
1382  * Description: Disable and free the interrupt for the given PHY.
1383  *   This should only be called with a valid IRQ number.
1384  */
phy_free_interrupt(struct phy_device * phydev)1385 void phy_free_interrupt(struct phy_device *phydev)
1386 {
1387 	phy_disable_interrupts(phydev);
1388 	free_irq(phydev->irq, phydev);
1389 }
1390 EXPORT_SYMBOL(phy_free_interrupt);
1391 
1392 enum phy_state_work {
1393 	PHY_STATE_WORK_NONE,
1394 	PHY_STATE_WORK_ANEG,
1395 	PHY_STATE_WORK_SUSPEND,
1396 };
1397 
_phy_state_machine(struct phy_device * phydev)1398 static enum phy_state_work _phy_state_machine(struct phy_device *phydev)
1399 {
1400 	enum phy_state_work state_work = PHY_STATE_WORK_NONE;
1401 	struct net_device *dev = phydev->attached_dev;
1402 	enum phy_state old_state = phydev->state;
1403 	const void *func = NULL;
1404 	bool finished = false;
1405 	int err = 0;
1406 
1407 	switch (phydev->state) {
1408 	case PHY_DOWN:
1409 	case PHY_READY:
1410 		break;
1411 	case PHY_UP:
1412 		state_work = PHY_STATE_WORK_ANEG;
1413 		break;
1414 	case PHY_NOLINK:
1415 	case PHY_RUNNING:
1416 		err = phy_check_link_status(phydev);
1417 		func = &phy_check_link_status;
1418 		break;
1419 	case PHY_CABLETEST:
1420 		err = phydev->drv->cable_test_get_status(phydev, &finished);
1421 		if (err) {
1422 			phy_abort_cable_test(phydev);
1423 			netif_testing_off(dev);
1424 			state_work = PHY_STATE_WORK_ANEG;
1425 			phydev->state = PHY_UP;
1426 			break;
1427 		}
1428 
1429 		if (finished) {
1430 			ethnl_cable_test_finished(phydev);
1431 			netif_testing_off(dev);
1432 			state_work = PHY_STATE_WORK_ANEG;
1433 			phydev->state = PHY_UP;
1434 		}
1435 		break;
1436 	case PHY_HALTED:
1437 	case PHY_ERROR:
1438 		if (phydev->link) {
1439 			phydev->link = 0;
1440 			phy_link_down(phydev);
1441 		}
1442 		state_work = PHY_STATE_WORK_SUSPEND;
1443 		break;
1444 	}
1445 
1446 	if (state_work == PHY_STATE_WORK_ANEG) {
1447 		err = _phy_start_aneg(phydev);
1448 		func = &_phy_start_aneg;
1449 	}
1450 
1451 	if (err == -ENODEV)
1452 		return state_work;
1453 
1454 	if (err < 0)
1455 		phy_error_precise(phydev, func, err);
1456 
1457 	phy_process_state_change(phydev, old_state);
1458 
1459 	/* Only re-schedule a PHY state machine change if we are polling the
1460 	 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1461 	 * between states from phy_mac_interrupt().
1462 	 *
1463 	 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1464 	 * state machine would be pointless and possibly error prone when
1465 	 * called from phy_disconnect() synchronously.
1466 	 */
1467 	if (phy_polling_mode(phydev) && phy_is_started(phydev))
1468 		phy_queue_state_machine(phydev, PHY_STATE_TIME);
1469 
1470 	return state_work;
1471 }
1472 
1473 /* unlocked part of the PHY state machine */
_phy_state_machine_post_work(struct phy_device * phydev,enum phy_state_work state_work)1474 static void _phy_state_machine_post_work(struct phy_device *phydev,
1475 					 enum phy_state_work state_work)
1476 {
1477 	if (state_work == PHY_STATE_WORK_SUSPEND)
1478 		phy_suspend(phydev);
1479 }
1480 
1481 /**
1482  * phy_state_machine - Handle the state machine
1483  * @work: work_struct that describes the work to be done
1484  */
phy_state_machine(struct work_struct * work)1485 void phy_state_machine(struct work_struct *work)
1486 {
1487 	struct delayed_work *dwork = to_delayed_work(work);
1488 	struct phy_device *phydev =
1489 			container_of(dwork, struct phy_device, state_queue);
1490 	enum phy_state_work state_work;
1491 
1492 	mutex_lock(&phydev->lock);
1493 	state_work = _phy_state_machine(phydev);
1494 	mutex_unlock(&phydev->lock);
1495 
1496 	_phy_state_machine_post_work(phydev, state_work);
1497 }
1498 
1499 /**
1500  * phy_stop - Bring down the PHY link, and stop checking the status
1501  * @phydev: target phy_device struct
1502  */
phy_stop(struct phy_device * phydev)1503 void phy_stop(struct phy_device *phydev)
1504 {
1505 	struct net_device *dev = phydev->attached_dev;
1506 	enum phy_state_work state_work;
1507 	enum phy_state old_state;
1508 
1509 	if (!phy_is_started(phydev) && phydev->state != PHY_DOWN &&
1510 	    phydev->state != PHY_ERROR) {
1511 		WARN(1, "called from state %s\n",
1512 		     phy_state_to_str(phydev->state));
1513 		return;
1514 	}
1515 
1516 	mutex_lock(&phydev->lock);
1517 	old_state = phydev->state;
1518 
1519 	if (phydev->state == PHY_CABLETEST) {
1520 		phy_abort_cable_test(phydev);
1521 		netif_testing_off(dev);
1522 	}
1523 
1524 	if (phydev->sfp_bus)
1525 		sfp_upstream_stop(phydev->sfp_bus);
1526 
1527 	phydev->state = PHY_HALTED;
1528 	phy_process_state_change(phydev, old_state);
1529 
1530 	state_work = _phy_state_machine(phydev);
1531 	mutex_unlock(&phydev->lock);
1532 
1533 	_phy_state_machine_post_work(phydev, state_work);
1534 	phy_stop_machine(phydev);
1535 
1536 	/* Cannot call flush_scheduled_work() here as desired because
1537 	 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1538 	 * will not reenable interrupts.
1539 	 */
1540 }
1541 EXPORT_SYMBOL(phy_stop);
1542 
1543 /**
1544  * phy_start - start or restart a PHY device
1545  * @phydev: target phy_device struct
1546  *
1547  * Description: Indicates the attached device's readiness to
1548  *   handle PHY-related work.  Used during startup to start the
1549  *   PHY, and after a call to phy_stop() to resume operation.
1550  *   Also used to indicate the MDIO bus has cleared an error
1551  *   condition.
1552  */
phy_start(struct phy_device * phydev)1553 void phy_start(struct phy_device *phydev)
1554 {
1555 	mutex_lock(&phydev->lock);
1556 
1557 	if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1558 		WARN(1, "called from state %s\n",
1559 		     phy_state_to_str(phydev->state));
1560 		goto out;
1561 	}
1562 
1563 	if (phydev->sfp_bus)
1564 		sfp_upstream_start(phydev->sfp_bus);
1565 
1566 	/* if phy was suspended, bring the physical link up again */
1567 	__phy_resume(phydev);
1568 
1569 	phydev->state = PHY_UP;
1570 
1571 	phy_start_machine(phydev);
1572 out:
1573 	mutex_unlock(&phydev->lock);
1574 }
1575 EXPORT_SYMBOL(phy_start);
1576 
1577 /**
1578  * phy_mac_interrupt - MAC says the link has changed
1579  * @phydev: phy_device struct with changed link
1580  *
1581  * The MAC layer is able to indicate there has been a change in the PHY link
1582  * status. Trigger the state machine and work a work queue.
1583  */
phy_mac_interrupt(struct phy_device * phydev)1584 void phy_mac_interrupt(struct phy_device *phydev)
1585 {
1586 	/* Trigger a state machine change */
1587 	phy_trigger_machine(phydev);
1588 }
1589 EXPORT_SYMBOL(phy_mac_interrupt);
1590 
1591 /**
1592  * phy_init_eee - init and check the EEE feature
1593  * @phydev: target phy_device struct
1594  * @clk_stop_enable: PHY may stop the clock during LPI
1595  *
1596  * Description: it checks if the Energy-Efficient Ethernet (EEE)
1597  * is supported by looking at the MMD registers 3.20 and 7.60/61
1598  * and it programs the MMD register 3.0 setting the "Clock stop enable"
1599  * bit if required.
1600  */
phy_init_eee(struct phy_device * phydev,bool clk_stop_enable)1601 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1602 {
1603 	int ret;
1604 
1605 	if (!phydev->drv)
1606 		return -EIO;
1607 
1608 	ret = genphy_c45_eee_is_active(phydev, NULL, NULL, NULL);
1609 	if (ret < 0)
1610 		return ret;
1611 	if (!ret)
1612 		return -EPROTONOSUPPORT;
1613 
1614 	if (clk_stop_enable)
1615 		/* Configure the PHY to stop receiving xMII
1616 		 * clock while it is signaling LPI.
1617 		 */
1618 		ret = phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1619 				       MDIO_PCS_CTRL1_CLKSTOP_EN);
1620 
1621 	return ret < 0 ? ret : 0;
1622 }
1623 EXPORT_SYMBOL(phy_init_eee);
1624 
1625 /**
1626  * phy_get_eee_err - report the EEE wake error count
1627  * @phydev: target phy_device struct
1628  *
1629  * Description: it is to report the number of time where the PHY
1630  * failed to complete its normal wake sequence.
1631  */
phy_get_eee_err(struct phy_device * phydev)1632 int phy_get_eee_err(struct phy_device *phydev)
1633 {
1634 	int ret;
1635 
1636 	if (!phydev->drv)
1637 		return -EIO;
1638 
1639 	mutex_lock(&phydev->lock);
1640 	ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1641 	mutex_unlock(&phydev->lock);
1642 
1643 	return ret;
1644 }
1645 EXPORT_SYMBOL(phy_get_eee_err);
1646 
1647 /**
1648  * phy_ethtool_get_eee - get EEE supported and status
1649  * @phydev: target phy_device struct
1650  * @data: ethtool_keee data
1651  *
1652  * Description: reports the Supported/Advertisement/LP Advertisement
1653  * capabilities, etc.
1654  */
phy_ethtool_get_eee(struct phy_device * phydev,struct ethtool_keee * data)1655 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)
1656 {
1657 	int ret;
1658 
1659 	if (!phydev->drv)
1660 		return -EIO;
1661 
1662 	mutex_lock(&phydev->lock);
1663 	ret = genphy_c45_ethtool_get_eee(phydev, data);
1664 	eeecfg_to_eee(data, &phydev->eee_cfg);
1665 	mutex_unlock(&phydev->lock);
1666 
1667 	return ret;
1668 }
1669 EXPORT_SYMBOL(phy_ethtool_get_eee);
1670 
1671 /**
1672  * phy_ethtool_set_eee_noneg - Adjusts MAC LPI configuration without PHY
1673  *			       renegotiation
1674  * @phydev: pointer to the target PHY device structure
1675  * @data: pointer to the ethtool_keee structure containing the new EEE settings
1676  *
1677  * This function updates the Energy Efficient Ethernet (EEE) configuration
1678  * for cases where only the MAC's Low Power Idle (LPI) configuration changes,
1679  * without triggering PHY renegotiation. It ensures that the MAC is properly
1680  * informed of the new LPI settings by cycling the link down and up, which
1681  * is necessary for the MAC to adopt the new configuration. This adjustment
1682  * is done only if there is a change in the tx_lpi_enabled or tx_lpi_timer
1683  * configuration.
1684  */
phy_ethtool_set_eee_noneg(struct phy_device * phydev,struct ethtool_keee * data)1685 static void phy_ethtool_set_eee_noneg(struct phy_device *phydev,
1686 				      struct ethtool_keee *data)
1687 {
1688 	if (phydev->eee_cfg.tx_lpi_enabled != data->tx_lpi_enabled ||
1689 	    phydev->eee_cfg.tx_lpi_timer != data->tx_lpi_timer) {
1690 		eee_to_eeecfg(&phydev->eee_cfg, data);
1691 		phydev->enable_tx_lpi = eeecfg_mac_can_tx_lpi(&phydev->eee_cfg);
1692 		if (phydev->link) {
1693 			phydev->link = false;
1694 			phy_link_down(phydev);
1695 			phydev->link = true;
1696 			phy_link_up(phydev);
1697 		}
1698 	}
1699 }
1700 
1701 /**
1702  * phy_ethtool_set_eee - set EEE supported and status
1703  * @phydev: target phy_device struct
1704  * @data: ethtool_keee data
1705  *
1706  * Description: it is to program the Advertisement EEE register.
1707  */
phy_ethtool_set_eee(struct phy_device * phydev,struct ethtool_keee * data)1708 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)
1709 {
1710 	int ret;
1711 
1712 	if (!phydev->drv)
1713 		return -EIO;
1714 
1715 	mutex_lock(&phydev->lock);
1716 	ret = genphy_c45_ethtool_set_eee(phydev, data);
1717 	if (ret >= 0) {
1718 		if (ret == 0)
1719 			phy_ethtool_set_eee_noneg(phydev, data);
1720 		eee_to_eeecfg(&phydev->eee_cfg, data);
1721 	}
1722 	mutex_unlock(&phydev->lock);
1723 
1724 	return ret < 0 ? ret : 0;
1725 }
1726 EXPORT_SYMBOL(phy_ethtool_set_eee);
1727 
1728 /**
1729  * phy_ethtool_set_wol - Configure Wake On LAN
1730  *
1731  * @phydev: target phy_device struct
1732  * @wol: Configuration requested
1733  */
phy_ethtool_set_wol(struct phy_device * phydev,struct ethtool_wolinfo * wol)1734 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1735 {
1736 	int ret;
1737 
1738 	if (phydev->drv && phydev->drv->set_wol) {
1739 		mutex_lock(&phydev->lock);
1740 		ret = phydev->drv->set_wol(phydev, wol);
1741 		mutex_unlock(&phydev->lock);
1742 
1743 		return ret;
1744 	}
1745 
1746 	return -EOPNOTSUPP;
1747 }
1748 EXPORT_SYMBOL(phy_ethtool_set_wol);
1749 
1750 /**
1751  * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1752  *
1753  * @phydev: target phy_device struct
1754  * @wol: Store the current configuration here
1755  */
phy_ethtool_get_wol(struct phy_device * phydev,struct ethtool_wolinfo * wol)1756 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1757 {
1758 	if (phydev->drv && phydev->drv->get_wol) {
1759 		mutex_lock(&phydev->lock);
1760 		phydev->drv->get_wol(phydev, wol);
1761 		mutex_unlock(&phydev->lock);
1762 	}
1763 }
1764 EXPORT_SYMBOL(phy_ethtool_get_wol);
1765 
phy_ethtool_get_link_ksettings(struct net_device * ndev,struct ethtool_link_ksettings * cmd)1766 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1767 				   struct ethtool_link_ksettings *cmd)
1768 {
1769 	struct phy_device *phydev = ndev->phydev;
1770 
1771 	if (!phydev)
1772 		return -ENODEV;
1773 
1774 	phy_ethtool_ksettings_get(phydev, cmd);
1775 
1776 	return 0;
1777 }
1778 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1779 
phy_ethtool_set_link_ksettings(struct net_device * ndev,const struct ethtool_link_ksettings * cmd)1780 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1781 				   const struct ethtool_link_ksettings *cmd)
1782 {
1783 	struct phy_device *phydev = ndev->phydev;
1784 
1785 	if (!phydev)
1786 		return -ENODEV;
1787 
1788 	return phy_ethtool_ksettings_set(phydev, cmd);
1789 }
1790 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1791 
1792 /**
1793  * phy_ethtool_nway_reset - Restart auto negotiation
1794  * @ndev: Network device to restart autoneg for
1795  */
phy_ethtool_nway_reset(struct net_device * ndev)1796 int phy_ethtool_nway_reset(struct net_device *ndev)
1797 {
1798 	struct phy_device *phydev = ndev->phydev;
1799 	int ret;
1800 
1801 	if (!phydev)
1802 		return -ENODEV;
1803 
1804 	if (!phydev->drv)
1805 		return -EIO;
1806 
1807 	mutex_lock(&phydev->lock);
1808 	ret = phy_restart_aneg(phydev);
1809 	mutex_unlock(&phydev->lock);
1810 
1811 	return ret;
1812 }
1813 EXPORT_SYMBOL(phy_ethtool_nway_reset);
1814