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
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
8 * Copyright (c) 2006, 2007 Maciej W. Rozycki
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>
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>
32 #include <linux/uaccess.h>
33 #include <linux/atomic.h>
34 #include <net/netlink.h>
35 #include <net/genetlink.h>
38 #define PHY_STATE_TIME HZ
40 #define PHY_STATE_STR(_state) \
42 return __stringify(_state); \
44 static const char *phy_state_to_str(enum phy_state st)
50 PHY_STATE_STR(RUNNING
)
52 PHY_STATE_STR(CABLETEST
)
59 static void phy_link_up(struct phy_device
*phydev
)
61 phydev
->phy_link_change(phydev
, true);
62 phy_led_trigger_change_speed(phydev
);
65 static void phy_link_down(struct phy_device
*phydev
)
67 phydev
->phy_link_change(phydev
, false);
68 phy_led_trigger_change_speed(phydev
);
71 static const char *phy_pause_str(struct phy_device
*phydev
)
73 bool local_pause
, local_asym_pause
;
75 if (phydev
->autoneg
== AUTONEG_DISABLE
)
78 local_pause
= linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
80 local_asym_pause
= linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
83 if (local_pause
&& phydev
->pause
)
86 if (local_asym_pause
&& phydev
->asym_pause
) {
98 * phy_print_status - Convenience function to print out the current phy status
99 * @phydev: the phy_device struct
101 void phy_print_status(struct phy_device
*phydev
)
104 netdev_info(phydev
->attached_dev
,
105 "Link is Up - %s/%s %s- flow control %s\n",
106 phy_speed_to_str(phydev
->speed
),
107 phy_duplex_to_str(phydev
->duplex
),
108 phydev
->downshifted_rate
? "(downshifted) " : "",
109 phy_pause_str(phydev
));
111 netdev_info(phydev
->attached_dev
, "Link is Down\n");
114 EXPORT_SYMBOL(phy_print_status
);
117 * phy_config_interrupt - configure the PHY device for the requested interrupts
118 * @phydev: the phy_device struct
119 * @interrupts: interrupt flags to configure for this @phydev
121 * Returns 0 on success or < 0 on error.
123 static int phy_config_interrupt(struct phy_device
*phydev
, bool interrupts
)
125 phydev
->interrupts
= interrupts
? 1 : 0;
126 if (phydev
->drv
->config_intr
)
127 return phydev
->drv
->config_intr(phydev
);
133 * phy_restart_aneg - restart auto-negotiation
134 * @phydev: target phy_device struct
136 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
137 * negative errno on error.
139 int phy_restart_aneg(struct phy_device
*phydev
)
143 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
144 ret
= genphy_c45_restart_aneg(phydev
);
146 ret
= genphy_restart_aneg(phydev
);
150 EXPORT_SYMBOL_GPL(phy_restart_aneg
);
153 * phy_aneg_done - return auto-negotiation status
154 * @phydev: target phy_device struct
156 * Description: Return the auto-negotiation status from this @phydev
157 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
160 int phy_aneg_done(struct phy_device
*phydev
)
162 if (phydev
->drv
&& phydev
->drv
->aneg_done
)
163 return phydev
->drv
->aneg_done(phydev
);
164 else if (phydev
->is_c45
)
165 return genphy_c45_aneg_done(phydev
);
167 return genphy_aneg_done(phydev
);
169 EXPORT_SYMBOL(phy_aneg_done
);
172 * phy_find_valid - find a PHY setting that matches the requested parameters
173 * @speed: desired speed
174 * @duplex: desired duplex
175 * @supported: mask of supported link modes
177 * Locate a supported phy setting that is, in priority order:
178 * - an exact match for the specified speed and duplex mode
179 * - a match for the specified speed, or slower speed
180 * - the slowest supported speed
181 * Returns the matched phy_setting entry, or %NULL if no supported phy
182 * settings were found.
184 static const struct phy_setting
*
185 phy_find_valid(int speed
, int duplex
, unsigned long *supported
)
187 return phy_lookup_setting(speed
, duplex
, supported
, false);
191 * phy_supported_speeds - return all speeds currently supported by a phy device
192 * @phy: The phy device to return supported speeds of.
193 * @speeds: buffer to store supported speeds in.
194 * @size: size of speeds buffer.
196 * Description: Returns the number of supported speeds, and fills the speeds
197 * buffer with the supported speeds. If speeds buffer is too small to contain
198 * all currently supported speeds, will return as many speeds as can fit.
200 unsigned int phy_supported_speeds(struct phy_device
*phy
,
201 unsigned int *speeds
,
204 return phy_speeds(speeds
, size
, phy
->supported
);
208 * phy_check_valid - check if there is a valid PHY setting which matches
209 * speed, duplex, and feature mask
210 * @speed: speed to match
211 * @duplex: duplex to match
212 * @features: A mask of the valid settings
214 * Description: Returns true if there is a valid setting, false otherwise.
216 static inline bool phy_check_valid(int speed
, int duplex
,
217 unsigned long *features
)
219 return !!phy_lookup_setting(speed
, duplex
, features
, true);
223 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
224 * @phydev: the target phy_device struct
226 * Description: Make sure the PHY is set to supported speeds and
227 * duplexes. Drop down by one in this order: 1000/FULL,
228 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
230 static void phy_sanitize_settings(struct phy_device
*phydev
)
232 const struct phy_setting
*setting
;
234 setting
= phy_find_valid(phydev
->speed
, phydev
->duplex
,
237 phydev
->speed
= setting
->speed
;
238 phydev
->duplex
= setting
->duplex
;
240 /* We failed to find anything (no supported speeds?) */
241 phydev
->speed
= SPEED_UNKNOWN
;
242 phydev
->duplex
= DUPLEX_UNKNOWN
;
246 int phy_ethtool_ksettings_set(struct phy_device
*phydev
,
247 const struct ethtool_link_ksettings
*cmd
)
249 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising
);
250 u8 autoneg
= cmd
->base
.autoneg
;
251 u8 duplex
= cmd
->base
.duplex
;
252 u32 speed
= cmd
->base
.speed
;
254 if (cmd
->base
.phy_address
!= phydev
->mdio
.addr
)
257 linkmode_copy(advertising
, cmd
->link_modes
.advertising
);
259 /* We make sure that we don't pass unsupported values in to the PHY */
260 linkmode_and(advertising
, advertising
, phydev
->supported
);
262 /* Verify the settings we care about. */
263 if (autoneg
!= AUTONEG_ENABLE
&& autoneg
!= AUTONEG_DISABLE
)
266 if (autoneg
== AUTONEG_ENABLE
&& linkmode_empty(advertising
))
269 if (autoneg
== AUTONEG_DISABLE
&&
270 ((speed
!= SPEED_1000
&&
271 speed
!= SPEED_100
&&
272 speed
!= SPEED_10
) ||
273 (duplex
!= DUPLEX_HALF
&&
274 duplex
!= DUPLEX_FULL
)))
277 phydev
->autoneg
= autoneg
;
279 if (autoneg
== AUTONEG_DISABLE
) {
280 phydev
->speed
= speed
;
281 phydev
->duplex
= duplex
;
284 linkmode_copy(phydev
->advertising
, advertising
);
286 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
287 phydev
->advertising
, autoneg
== AUTONEG_ENABLE
);
289 phydev
->master_slave_set
= cmd
->base
.master_slave_cfg
;
290 phydev
->mdix_ctrl
= cmd
->base
.eth_tp_mdix_ctrl
;
292 /* Restart the PHY */
293 phy_start_aneg(phydev
);
297 EXPORT_SYMBOL(phy_ethtool_ksettings_set
);
299 void phy_ethtool_ksettings_get(struct phy_device
*phydev
,
300 struct ethtool_link_ksettings
*cmd
)
302 linkmode_copy(cmd
->link_modes
.supported
, phydev
->supported
);
303 linkmode_copy(cmd
->link_modes
.advertising
, phydev
->advertising
);
304 linkmode_copy(cmd
->link_modes
.lp_advertising
, phydev
->lp_advertising
);
306 cmd
->base
.speed
= phydev
->speed
;
307 cmd
->base
.duplex
= phydev
->duplex
;
308 cmd
->base
.master_slave_cfg
= phydev
->master_slave_get
;
309 cmd
->base
.master_slave_state
= phydev
->master_slave_state
;
310 if (phydev
->interface
== PHY_INTERFACE_MODE_MOCA
)
311 cmd
->base
.port
= PORT_BNC
;
313 cmd
->base
.port
= phydev
->port
;
314 cmd
->base
.transceiver
= phy_is_internal(phydev
) ?
315 XCVR_INTERNAL
: XCVR_EXTERNAL
;
316 cmd
->base
.phy_address
= phydev
->mdio
.addr
;
317 cmd
->base
.autoneg
= phydev
->autoneg
;
318 cmd
->base
.eth_tp_mdix_ctrl
= phydev
->mdix_ctrl
;
319 cmd
->base
.eth_tp_mdix
= phydev
->mdix
;
321 EXPORT_SYMBOL(phy_ethtool_ksettings_get
);
324 * phy_mii_ioctl - generic PHY MII ioctl interface
325 * @phydev: the phy_device struct
326 * @ifr: &struct ifreq for socket ioctl's
327 * @cmd: ioctl cmd to execute
329 * Note that this function is currently incompatible with the
330 * PHYCONTROL layer. It changes registers without regard to
331 * current state. Use at own risk.
333 int phy_mii_ioctl(struct phy_device
*phydev
, struct ifreq
*ifr
, int cmd
)
335 struct mii_ioctl_data
*mii_data
= if_mii(ifr
);
336 u16 val
= mii_data
->val_in
;
337 bool change_autoneg
= false;
342 mii_data
->phy_id
= phydev
->mdio
.addr
;
346 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
347 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
348 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
349 devad
= mdiobus_c45_addr(devad
, mii_data
->reg_num
);
351 prtad
= mii_data
->phy_id
;
352 devad
= mii_data
->reg_num
;
354 mii_data
->val_out
= mdiobus_read(phydev
->mdio
.bus
, prtad
,
359 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
360 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
361 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
362 devad
= mdiobus_c45_addr(devad
, mii_data
->reg_num
);
364 prtad
= mii_data
->phy_id
;
365 devad
= mii_data
->reg_num
;
367 if (prtad
== phydev
->mdio
.addr
) {
370 if ((val
& (BMCR_RESET
| BMCR_ANENABLE
)) == 0) {
371 if (phydev
->autoneg
== AUTONEG_ENABLE
)
372 change_autoneg
= true;
373 phydev
->autoneg
= AUTONEG_DISABLE
;
374 if (val
& BMCR_FULLDPLX
)
375 phydev
->duplex
= DUPLEX_FULL
;
377 phydev
->duplex
= DUPLEX_HALF
;
378 if (val
& BMCR_SPEED1000
)
379 phydev
->speed
= SPEED_1000
;
380 else if (val
& BMCR_SPEED100
)
381 phydev
->speed
= SPEED_100
;
382 else phydev
->speed
= SPEED_10
;
384 if (phydev
->autoneg
== AUTONEG_DISABLE
)
385 change_autoneg
= true;
386 phydev
->autoneg
= AUTONEG_ENABLE
;
390 mii_adv_mod_linkmode_adv_t(phydev
->advertising
,
392 change_autoneg
= true;
395 mii_ctrl1000_mod_linkmode_adv_t(phydev
->advertising
,
397 change_autoneg
= true;
405 mdiobus_write(phydev
->mdio
.bus
, prtad
, devad
, val
);
407 if (prtad
== phydev
->mdio
.addr
&&
410 return phy_init_hw(phydev
);
413 return phy_start_aneg(phydev
);
418 if (phydev
->mii_ts
&& phydev
->mii_ts
->hwtstamp
)
419 return phydev
->mii_ts
->hwtstamp(phydev
->mii_ts
, ifr
);
426 EXPORT_SYMBOL(phy_mii_ioctl
);
429 * phy_do_ioctl - generic ndo_eth_ioctl implementation
430 * @dev: the net_device struct
431 * @ifr: &struct ifreq for socket ioctl's
432 * @cmd: ioctl cmd to execute
434 int phy_do_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
439 return phy_mii_ioctl(dev
->phydev
, ifr
, cmd
);
441 EXPORT_SYMBOL(phy_do_ioctl
);
444 * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first
446 * @dev: the net_device struct
447 * @ifr: &struct ifreq for socket ioctl's
448 * @cmd: ioctl cmd to execute
450 * Same as phy_do_ioctl, but ensures that net_device is running before
451 * handling the ioctl.
453 int phy_do_ioctl_running(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
455 if (!netif_running(dev
))
458 return phy_do_ioctl(dev
, ifr
, cmd
);
460 EXPORT_SYMBOL(phy_do_ioctl_running
);
463 * phy_queue_state_machine - Trigger the state machine to run soon
465 * @phydev: the phy_device struct
466 * @jiffies: Run the state machine after these jiffies
468 void phy_queue_state_machine(struct phy_device
*phydev
, unsigned long jiffies
)
470 mod_delayed_work(system_power_efficient_wq
, &phydev
->state_queue
,
473 EXPORT_SYMBOL(phy_queue_state_machine
);
476 * phy_trigger_machine - Trigger the state machine to run now
478 * @phydev: the phy_device struct
480 void phy_trigger_machine(struct phy_device
*phydev
)
482 phy_queue_state_machine(phydev
, 0);
484 EXPORT_SYMBOL(phy_trigger_machine
);
486 static void phy_abort_cable_test(struct phy_device
*phydev
)
490 ethnl_cable_test_finished(phydev
);
492 err
= phy_init_hw(phydev
);
494 phydev_err(phydev
, "Error while aborting cable test");
498 * phy_ethtool_get_strings - Get the statistic counter names
500 * @phydev: the phy_device struct
501 * @data: Where to put the strings
503 int phy_ethtool_get_strings(struct phy_device
*phydev
, u8
*data
)
508 mutex_lock(&phydev
->lock
);
509 phydev
->drv
->get_strings(phydev
, data
);
510 mutex_unlock(&phydev
->lock
);
514 EXPORT_SYMBOL(phy_ethtool_get_strings
);
517 * phy_ethtool_get_sset_count - Get the number of statistic counters
519 * @phydev: the phy_device struct
521 int phy_ethtool_get_sset_count(struct phy_device
*phydev
)
528 if (phydev
->drv
->get_sset_count
&&
529 phydev
->drv
->get_strings
&&
530 phydev
->drv
->get_stats
) {
531 mutex_lock(&phydev
->lock
);
532 ret
= phydev
->drv
->get_sset_count(phydev
);
533 mutex_unlock(&phydev
->lock
);
540 EXPORT_SYMBOL(phy_ethtool_get_sset_count
);
543 * phy_ethtool_get_stats - Get the statistic counters
545 * @phydev: the phy_device struct
546 * @stats: What counters to get
547 * @data: Where to store the counters
549 int phy_ethtool_get_stats(struct phy_device
*phydev
,
550 struct ethtool_stats
*stats
, u64
*data
)
555 mutex_lock(&phydev
->lock
);
556 phydev
->drv
->get_stats(phydev
, stats
, data
);
557 mutex_unlock(&phydev
->lock
);
561 EXPORT_SYMBOL(phy_ethtool_get_stats
);
564 * phy_start_cable_test - Start a cable test
566 * @phydev: the phy_device struct
567 * @extack: extack for reporting useful error messages
569 int phy_start_cable_test(struct phy_device
*phydev
,
570 struct netlink_ext_ack
*extack
)
572 struct net_device
*dev
= phydev
->attached_dev
;
576 phydev
->drv
->cable_test_start
&&
577 phydev
->drv
->cable_test_get_status
)) {
578 NL_SET_ERR_MSG(extack
,
579 "PHY driver does not support cable testing");
583 mutex_lock(&phydev
->lock
);
584 if (phydev
->state
== PHY_CABLETEST
) {
585 NL_SET_ERR_MSG(extack
,
586 "PHY already performing a test");
591 if (phydev
->state
< PHY_UP
||
592 phydev
->state
> PHY_CABLETEST
) {
593 NL_SET_ERR_MSG(extack
,
594 "PHY not configured. Try setting interface up");
599 err
= ethnl_cable_test_alloc(phydev
, ETHTOOL_MSG_CABLE_TEST_NTF
);
603 /* Mark the carrier down until the test is complete */
604 phy_link_down(phydev
);
606 netif_testing_on(dev
);
607 err
= phydev
->drv
->cable_test_start(phydev
);
609 netif_testing_off(dev
);
614 phydev
->state
= PHY_CABLETEST
;
616 if (phy_polling_mode(phydev
))
617 phy_trigger_machine(phydev
);
619 mutex_unlock(&phydev
->lock
);
624 ethnl_cable_test_free(phydev
);
626 mutex_unlock(&phydev
->lock
);
630 EXPORT_SYMBOL(phy_start_cable_test
);
633 * phy_start_cable_test_tdr - Start a raw TDR cable test
635 * @phydev: the phy_device struct
636 * @extack: extack for reporting useful error messages
637 * @config: Configuration of the test to run
639 int phy_start_cable_test_tdr(struct phy_device
*phydev
,
640 struct netlink_ext_ack
*extack
,
641 const struct phy_tdr_config
*config
)
643 struct net_device
*dev
= phydev
->attached_dev
;
647 phydev
->drv
->cable_test_tdr_start
&&
648 phydev
->drv
->cable_test_get_status
)) {
649 NL_SET_ERR_MSG(extack
,
650 "PHY driver does not support cable test TDR");
654 mutex_lock(&phydev
->lock
);
655 if (phydev
->state
== PHY_CABLETEST
) {
656 NL_SET_ERR_MSG(extack
,
657 "PHY already performing a test");
662 if (phydev
->state
< PHY_UP
||
663 phydev
->state
> PHY_CABLETEST
) {
664 NL_SET_ERR_MSG(extack
,
665 "PHY not configured. Try setting interface up");
670 err
= ethnl_cable_test_alloc(phydev
, ETHTOOL_MSG_CABLE_TEST_TDR_NTF
);
674 /* Mark the carrier down until the test is complete */
675 phy_link_down(phydev
);
677 netif_testing_on(dev
);
678 err
= phydev
->drv
->cable_test_tdr_start(phydev
, config
);
680 netif_testing_off(dev
);
685 phydev
->state
= PHY_CABLETEST
;
687 if (phy_polling_mode(phydev
))
688 phy_trigger_machine(phydev
);
690 mutex_unlock(&phydev
->lock
);
695 ethnl_cable_test_free(phydev
);
697 mutex_unlock(&phydev
->lock
);
701 EXPORT_SYMBOL(phy_start_cable_test_tdr
);
703 int phy_config_aneg(struct phy_device
*phydev
)
705 if (phydev
->drv
->config_aneg
)
706 return phydev
->drv
->config_aneg(phydev
);
708 /* Clause 45 PHYs that don't implement Clause 22 registers are not
709 * allowed to call genphy_config_aneg()
711 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
712 return genphy_c45_config_aneg(phydev
);
714 return genphy_config_aneg(phydev
);
716 EXPORT_SYMBOL(phy_config_aneg
);
719 * phy_check_link_status - check link status and set state accordingly
720 * @phydev: the phy_device struct
722 * Description: Check for link and whether autoneg was triggered / is running
723 * and set state accordingly
725 static int phy_check_link_status(struct phy_device
*phydev
)
729 lockdep_assert_held(&phydev
->lock
);
731 /* Keep previous state if loopback is enabled because some PHYs
732 * report that Link is Down when loopback is enabled.
734 if (phydev
->loopback_enabled
)
737 err
= phy_read_status(phydev
);
741 if (phydev
->link
&& phydev
->state
!= PHY_RUNNING
) {
742 phy_check_downshift(phydev
);
743 phydev
->state
= PHY_RUNNING
;
745 } else if (!phydev
->link
&& phydev
->state
!= PHY_NOLINK
) {
746 phydev
->state
= PHY_NOLINK
;
747 phy_link_down(phydev
);
754 * phy_start_aneg - start auto-negotiation for this PHY device
755 * @phydev: the phy_device struct
757 * Description: Sanitizes the settings (if we're not autonegotiating
758 * them), and then calls the driver's config_aneg function.
759 * If the PHYCONTROL Layer is operating, we change the state to
760 * reflect the beginning of Auto-negotiation or forcing.
762 int phy_start_aneg(struct phy_device
*phydev
)
769 mutex_lock(&phydev
->lock
);
771 if (AUTONEG_DISABLE
== phydev
->autoneg
)
772 phy_sanitize_settings(phydev
);
774 err
= phy_config_aneg(phydev
);
778 if (phy_is_started(phydev
))
779 err
= phy_check_link_status(phydev
);
781 mutex_unlock(&phydev
->lock
);
785 EXPORT_SYMBOL(phy_start_aneg
);
787 static int phy_poll_aneg_done(struct phy_device
*phydev
)
789 unsigned int retries
= 100;
794 ret
= phy_aneg_done(phydev
);
795 } while (!ret
&& --retries
);
800 return ret
< 0 ? ret
: 0;
804 * phy_speed_down - set speed to lowest speed supported by both link partners
805 * @phydev: the phy_device struct
806 * @sync: perform action synchronously
808 * Description: Typically used to save energy when waiting for a WoL packet
810 * WARNING: Setting sync to false may cause the system being unable to suspend
811 * in case the PHY generates an interrupt when finishing the autonegotiation.
812 * This interrupt may wake up the system immediately after suspend.
813 * Therefore use sync = false only if you're sure it's safe with the respective
816 int phy_speed_down(struct phy_device
*phydev
, bool sync
)
818 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
821 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
824 linkmode_copy(adv_tmp
, phydev
->advertising
);
826 ret
= phy_speed_down_core(phydev
);
830 linkmode_copy(phydev
->adv_old
, adv_tmp
);
832 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
835 ret
= phy_config_aneg(phydev
);
839 return sync
? phy_poll_aneg_done(phydev
) : 0;
841 EXPORT_SYMBOL_GPL(phy_speed_down
);
844 * phy_speed_up - (re)set advertised speeds to all supported speeds
845 * @phydev: the phy_device struct
847 * Description: Used to revert the effect of phy_speed_down
849 int phy_speed_up(struct phy_device
*phydev
)
851 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
853 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
856 if (linkmode_empty(phydev
->adv_old
))
859 linkmode_copy(adv_tmp
, phydev
->advertising
);
860 linkmode_copy(phydev
->advertising
, phydev
->adv_old
);
861 linkmode_zero(phydev
->adv_old
);
863 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
866 return phy_config_aneg(phydev
);
868 EXPORT_SYMBOL_GPL(phy_speed_up
);
871 * phy_start_machine - start PHY state machine tracking
872 * @phydev: the phy_device struct
874 * Description: The PHY infrastructure can run a state machine
875 * which tracks whether the PHY is starting up, negotiating,
876 * etc. This function starts the delayed workqueue which tracks
877 * the state of the PHY. If you want to maintain your own state machine,
878 * do not call this function.
880 void phy_start_machine(struct phy_device
*phydev
)
882 phy_trigger_machine(phydev
);
884 EXPORT_SYMBOL_GPL(phy_start_machine
);
887 * phy_stop_machine - stop the PHY state machine tracking
888 * @phydev: target phy_device struct
890 * Description: Stops the state machine delayed workqueue, sets the
891 * state to UP (unless it wasn't up yet). This function must be
892 * called BEFORE phy_detach.
894 void phy_stop_machine(struct phy_device
*phydev
)
896 cancel_delayed_work_sync(&phydev
->state_queue
);
898 mutex_lock(&phydev
->lock
);
899 if (phy_is_started(phydev
))
900 phydev
->state
= PHY_UP
;
901 mutex_unlock(&phydev
->lock
);
905 * phy_error - enter HALTED state for this PHY device
906 * @phydev: target phy_device struct
908 * Moves the PHY to the HALTED state in response to a read
909 * or write error, and tells the controller the link is down.
910 * Must not be called from interrupt context, or while the
911 * phydev->lock is held.
913 void phy_error(struct phy_device
*phydev
)
917 mutex_lock(&phydev
->lock
);
918 phydev
->state
= PHY_HALTED
;
919 mutex_unlock(&phydev
->lock
);
921 phy_trigger_machine(phydev
);
923 EXPORT_SYMBOL(phy_error
);
926 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
927 * @phydev: target phy_device struct
929 int phy_disable_interrupts(struct phy_device
*phydev
)
931 /* Disable PHY interrupts */
932 return phy_config_interrupt(phydev
, PHY_INTERRUPT_DISABLED
);
936 * phy_interrupt - PHY interrupt handler
937 * @irq: interrupt line
938 * @phy_dat: phy_device pointer
940 * Description: Handle PHY interrupt
942 static irqreturn_t
phy_interrupt(int irq
, void *phy_dat
)
944 struct phy_device
*phydev
= phy_dat
;
945 struct phy_driver
*drv
= phydev
->drv
;
947 return drv
->handle_interrupt(phydev
);
951 * phy_enable_interrupts - Enable the interrupts from the PHY side
952 * @phydev: target phy_device struct
954 static int phy_enable_interrupts(struct phy_device
*phydev
)
956 return phy_config_interrupt(phydev
, PHY_INTERRUPT_ENABLED
);
960 * phy_request_interrupt - request and enable interrupt for a PHY device
961 * @phydev: target phy_device struct
963 * Description: Request and enable the interrupt for the given PHY.
964 * If this fails, then we set irq to PHY_POLL.
965 * This should only be called with a valid IRQ number.
967 void phy_request_interrupt(struct phy_device
*phydev
)
971 err
= request_threaded_irq(phydev
->irq
, NULL
, phy_interrupt
,
972 IRQF_ONESHOT
| IRQF_SHARED
,
973 phydev_name(phydev
), phydev
);
975 phydev_warn(phydev
, "Error %d requesting IRQ %d, falling back to polling\n",
977 phydev
->irq
= PHY_POLL
;
979 if (phy_enable_interrupts(phydev
)) {
980 phydev_warn(phydev
, "Can't enable interrupt, falling back to polling\n");
981 phy_free_interrupt(phydev
);
982 phydev
->irq
= PHY_POLL
;
986 EXPORT_SYMBOL(phy_request_interrupt
);
989 * phy_free_interrupt - disable and free interrupt for a PHY device
990 * @phydev: target phy_device struct
992 * Description: Disable and free the interrupt for the given PHY.
993 * This should only be called with a valid IRQ number.
995 void phy_free_interrupt(struct phy_device
*phydev
)
997 phy_disable_interrupts(phydev
);
998 free_irq(phydev
->irq
, phydev
);
1000 EXPORT_SYMBOL(phy_free_interrupt
);
1003 * phy_stop - Bring down the PHY link, and stop checking the status
1004 * @phydev: target phy_device struct
1006 void phy_stop(struct phy_device
*phydev
)
1008 struct net_device
*dev
= phydev
->attached_dev
;
1010 if (!phy_is_started(phydev
) && phydev
->state
!= PHY_DOWN
) {
1011 WARN(1, "called from state %s\n",
1012 phy_state_to_str(phydev
->state
));
1016 mutex_lock(&phydev
->lock
);
1018 if (phydev
->state
== PHY_CABLETEST
) {
1019 phy_abort_cable_test(phydev
);
1020 netif_testing_off(dev
);
1023 if (phydev
->sfp_bus
)
1024 sfp_upstream_stop(phydev
->sfp_bus
);
1026 phydev
->state
= PHY_HALTED
;
1028 mutex_unlock(&phydev
->lock
);
1030 phy_state_machine(&phydev
->state_queue
.work
);
1031 phy_stop_machine(phydev
);
1033 /* Cannot call flush_scheduled_work() here as desired because
1034 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1035 * will not reenable interrupts.
1038 EXPORT_SYMBOL(phy_stop
);
1041 * phy_start - start or restart a PHY device
1042 * @phydev: target phy_device struct
1044 * Description: Indicates the attached device's readiness to
1045 * handle PHY-related work. Used during startup to start the
1046 * PHY, and after a call to phy_stop() to resume operation.
1047 * Also used to indicate the MDIO bus has cleared an error
1050 void phy_start(struct phy_device
*phydev
)
1052 mutex_lock(&phydev
->lock
);
1054 if (phydev
->state
!= PHY_READY
&& phydev
->state
!= PHY_HALTED
) {
1055 WARN(1, "called from state %s\n",
1056 phy_state_to_str(phydev
->state
));
1060 if (phydev
->sfp_bus
)
1061 sfp_upstream_start(phydev
->sfp_bus
);
1063 /* if phy was suspended, bring the physical link up again */
1064 __phy_resume(phydev
);
1066 phydev
->state
= PHY_UP
;
1068 phy_start_machine(phydev
);
1070 mutex_unlock(&phydev
->lock
);
1072 EXPORT_SYMBOL(phy_start
);
1075 * phy_state_machine - Handle the state machine
1076 * @work: work_struct that describes the work to be done
1078 void phy_state_machine(struct work_struct
*work
)
1080 struct delayed_work
*dwork
= to_delayed_work(work
);
1081 struct phy_device
*phydev
=
1082 container_of(dwork
, struct phy_device
, state_queue
);
1083 struct net_device
*dev
= phydev
->attached_dev
;
1084 bool needs_aneg
= false, do_suspend
= false;
1085 enum phy_state old_state
;
1086 bool finished
= false;
1089 mutex_lock(&phydev
->lock
);
1091 old_state
= phydev
->state
;
1093 switch (phydev
->state
) {
1103 err
= phy_check_link_status(phydev
);
1106 err
= phydev
->drv
->cable_test_get_status(phydev
, &finished
);
1108 phy_abort_cable_test(phydev
);
1109 netif_testing_off(dev
);
1111 phydev
->state
= PHY_UP
;
1116 ethnl_cable_test_finished(phydev
);
1117 netif_testing_off(dev
);
1119 phydev
->state
= PHY_UP
;
1125 phy_link_down(phydev
);
1131 mutex_unlock(&phydev
->lock
);
1134 err
= phy_start_aneg(phydev
);
1135 else if (do_suspend
)
1136 phy_suspend(phydev
);
1144 if (old_state
!= phydev
->state
) {
1145 phydev_dbg(phydev
, "PHY state change %s -> %s\n",
1146 phy_state_to_str(old_state
),
1147 phy_state_to_str(phydev
->state
));
1148 if (phydev
->drv
&& phydev
->drv
->link_change_notify
)
1149 phydev
->drv
->link_change_notify(phydev
);
1152 /* Only re-schedule a PHY state machine change if we are polling the
1153 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1154 * between states from phy_mac_interrupt().
1156 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1157 * state machine would be pointless and possibly error prone when
1158 * called from phy_disconnect() synchronously.
1160 mutex_lock(&phydev
->lock
);
1161 if (phy_polling_mode(phydev
) && phy_is_started(phydev
))
1162 phy_queue_state_machine(phydev
, PHY_STATE_TIME
);
1163 mutex_unlock(&phydev
->lock
);
1167 * phy_mac_interrupt - MAC says the link has changed
1168 * @phydev: phy_device struct with changed link
1170 * The MAC layer is able to indicate there has been a change in the PHY link
1171 * status. Trigger the state machine and work a work queue.
1173 void phy_mac_interrupt(struct phy_device
*phydev
)
1175 /* Trigger a state machine change */
1176 phy_trigger_machine(phydev
);
1178 EXPORT_SYMBOL(phy_mac_interrupt
);
1180 static void mmd_eee_adv_to_linkmode(unsigned long *advertising
, u16 eee_adv
)
1182 linkmode_zero(advertising
);
1184 if (eee_adv
& MDIO_EEE_100TX
)
1185 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT
,
1187 if (eee_adv
& MDIO_EEE_1000T
)
1188 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
1190 if (eee_adv
& MDIO_EEE_10GT
)
1191 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT
,
1193 if (eee_adv
& MDIO_EEE_1000KX
)
1194 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
,
1196 if (eee_adv
& MDIO_EEE_10GKX4
)
1197 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
,
1199 if (eee_adv
& MDIO_EEE_10GKR
)
1200 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
,
1205 * phy_init_eee - init and check the EEE feature
1206 * @phydev: target phy_device struct
1207 * @clk_stop_enable: PHY may stop the clock during LPI
1209 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1210 * is supported by looking at the MMD registers 3.20 and 7.60/61
1211 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1214 int phy_init_eee(struct phy_device
*phydev
, bool clk_stop_enable
)
1219 /* According to 802.3az,the EEE is supported only in full duplex-mode.
1221 if (phydev
->duplex
== DUPLEX_FULL
) {
1222 __ETHTOOL_DECLARE_LINK_MODE_MASK(common
);
1223 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp
);
1224 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv
);
1225 int eee_lp
, eee_cap
, eee_adv
;
1229 /* Read phy status to properly get the right settings */
1230 status
= phy_read_status(phydev
);
1234 /* First check if the EEE ability is supported */
1235 eee_cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1239 cap
= mmd_eee_cap_to_ethtool_sup_t(eee_cap
);
1243 /* Check which link settings negotiated and verify it in
1244 * the EEE advertising registers.
1246 eee_lp
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1250 eee_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1254 mmd_eee_adv_to_linkmode(adv
, eee_adv
);
1255 mmd_eee_adv_to_linkmode(lp
, eee_lp
);
1256 linkmode_and(common
, adv
, lp
);
1258 if (!phy_check_valid(phydev
->speed
, phydev
->duplex
, common
))
1261 if (clk_stop_enable
)
1262 /* Configure the PHY to stop receiving xMII
1263 * clock while it is signaling LPI.
1265 phy_set_bits_mmd(phydev
, MDIO_MMD_PCS
, MDIO_CTRL1
,
1266 MDIO_PCS_CTRL1_CLKSTOP_EN
);
1268 return 0; /* EEE supported */
1271 return -EPROTONOSUPPORT
;
1273 EXPORT_SYMBOL(phy_init_eee
);
1276 * phy_get_eee_err - report the EEE wake error count
1277 * @phydev: target phy_device struct
1279 * Description: it is to report the number of time where the PHY
1280 * failed to complete its normal wake sequence.
1282 int phy_get_eee_err(struct phy_device
*phydev
)
1287 return phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_WK_ERR
);
1289 EXPORT_SYMBOL(phy_get_eee_err
);
1292 * phy_ethtool_get_eee - get EEE supported and status
1293 * @phydev: target phy_device struct
1294 * @data: ethtool_eee data
1296 * Description: it reportes the Supported/Advertisement/LP Advertisement
1299 int phy_ethtool_get_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1306 /* Get Supported EEE */
1307 val
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1310 data
->supported
= mmd_eee_cap_to_ethtool_sup_t(val
);
1312 /* Get advertisement EEE */
1313 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1316 data
->advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1317 data
->eee_enabled
= !!data
->advertised
;
1319 /* Get LP advertisement EEE */
1320 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1323 data
->lp_advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1325 data
->eee_active
= !!(data
->advertised
& data
->lp_advertised
);
1329 EXPORT_SYMBOL(phy_ethtool_get_eee
);
1332 * phy_ethtool_set_eee - set EEE supported and status
1333 * @phydev: target phy_device struct
1334 * @data: ethtool_eee data
1336 * Description: it is to program the Advertisement EEE register.
1338 int phy_ethtool_set_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1340 int cap
, old_adv
, adv
= 0, ret
;
1345 /* Get Supported EEE */
1346 cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1350 old_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1354 if (data
->eee_enabled
) {
1355 adv
= !data
->advertised
? cap
:
1356 ethtool_adv_to_mmd_eee_adv_t(data
->advertised
) & cap
;
1357 /* Mask prohibited EEE modes */
1358 adv
&= ~phydev
->eee_broken_modes
;
1361 if (old_adv
!= adv
) {
1362 ret
= phy_write_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
, adv
);
1366 /* Restart autonegotiation so the new modes get sent to the
1369 if (phydev
->autoneg
== AUTONEG_ENABLE
) {
1370 ret
= phy_restart_aneg(phydev
);
1378 EXPORT_SYMBOL(phy_ethtool_set_eee
);
1381 * phy_ethtool_set_wol - Configure Wake On LAN
1383 * @phydev: target phy_device struct
1384 * @wol: Configuration requested
1386 int phy_ethtool_set_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1388 if (phydev
->drv
&& phydev
->drv
->set_wol
)
1389 return phydev
->drv
->set_wol(phydev
, wol
);
1393 EXPORT_SYMBOL(phy_ethtool_set_wol
);
1396 * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1398 * @phydev: target phy_device struct
1399 * @wol: Store the current configuration here
1401 void phy_ethtool_get_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1403 if (phydev
->drv
&& phydev
->drv
->get_wol
)
1404 phydev
->drv
->get_wol(phydev
, wol
);
1406 EXPORT_SYMBOL(phy_ethtool_get_wol
);
1408 int phy_ethtool_get_link_ksettings(struct net_device
*ndev
,
1409 struct ethtool_link_ksettings
*cmd
)
1411 struct phy_device
*phydev
= ndev
->phydev
;
1416 phy_ethtool_ksettings_get(phydev
, cmd
);
1420 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings
);
1422 int phy_ethtool_set_link_ksettings(struct net_device
*ndev
,
1423 const struct ethtool_link_ksettings
*cmd
)
1425 struct phy_device
*phydev
= ndev
->phydev
;
1430 return phy_ethtool_ksettings_set(phydev
, cmd
);
1432 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings
);
1435 * phy_ethtool_nway_reset - Restart auto negotiation
1436 * @ndev: Network device to restart autoneg for
1438 int phy_ethtool_nway_reset(struct net_device
*ndev
)
1440 struct phy_device
*phydev
= ndev
->phydev
;
1448 return phy_restart_aneg(phydev
);
1450 EXPORT_SYMBOL(phy_ethtool_nway_reset
);