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