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