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_clear_interrupt - Ack the phy device's interrupt
118 * @phydev: the phy_device struct
120 * If the @phydev driver has an ack_interrupt function, call it to
121 * ack and clear the phy device's interrupt.
123 * Returns 0 on success or < 0 on error.
125 static int phy_clear_interrupt(struct phy_device
*phydev
)
127 if (phydev
->drv
->ack_interrupt
)
128 return phydev
->drv
->ack_interrupt(phydev
);
134 * phy_config_interrupt - configure the PHY device for the requested interrupts
135 * @phydev: the phy_device struct
136 * @interrupts: interrupt flags to configure for this @phydev
138 * Returns 0 on success or < 0 on error.
140 static int phy_config_interrupt(struct phy_device
*phydev
, bool interrupts
)
142 phydev
->interrupts
= interrupts
? 1 : 0;
143 if (phydev
->drv
->config_intr
)
144 return phydev
->drv
->config_intr(phydev
);
150 * phy_restart_aneg - restart auto-negotiation
151 * @phydev: target phy_device struct
153 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
154 * negative errno on error.
156 int phy_restart_aneg(struct phy_device
*phydev
)
160 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
161 ret
= genphy_c45_restart_aneg(phydev
);
163 ret
= genphy_restart_aneg(phydev
);
167 EXPORT_SYMBOL_GPL(phy_restart_aneg
);
170 * phy_aneg_done - return auto-negotiation status
171 * @phydev: target phy_device struct
173 * Description: Return the auto-negotiation status from this @phydev
174 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
177 int phy_aneg_done(struct phy_device
*phydev
)
179 if (phydev
->drv
&& phydev
->drv
->aneg_done
)
180 return phydev
->drv
->aneg_done(phydev
);
181 else if (phydev
->is_c45
)
182 return genphy_c45_aneg_done(phydev
);
184 return genphy_aneg_done(phydev
);
186 EXPORT_SYMBOL(phy_aneg_done
);
189 * phy_find_valid - find a PHY setting that matches the requested parameters
190 * @speed: desired speed
191 * @duplex: desired duplex
192 * @supported: mask of supported link modes
194 * Locate a supported phy setting that is, in priority order:
195 * - an exact match for the specified speed and duplex mode
196 * - a match for the specified speed, or slower speed
197 * - the slowest supported speed
198 * Returns the matched phy_setting entry, or %NULL if no supported phy
199 * settings were found.
201 static const struct phy_setting
*
202 phy_find_valid(int speed
, int duplex
, unsigned long *supported
)
204 return phy_lookup_setting(speed
, duplex
, supported
, false);
208 * phy_supported_speeds - return all speeds currently supported by a phy device
209 * @phy: The phy device to return supported speeds of.
210 * @speeds: buffer to store supported speeds in.
211 * @size: size of speeds buffer.
213 * Description: Returns the number of supported speeds, and fills the speeds
214 * buffer with the supported speeds. If speeds buffer is too small to contain
215 * all currently supported speeds, will return as many speeds as can fit.
217 unsigned int phy_supported_speeds(struct phy_device
*phy
,
218 unsigned int *speeds
,
221 return phy_speeds(speeds
, size
, phy
->supported
);
225 * phy_check_valid - check if there is a valid PHY setting which matches
226 * speed, duplex, and feature mask
227 * @speed: speed to match
228 * @duplex: duplex to match
229 * @features: A mask of the valid settings
231 * Description: Returns true if there is a valid setting, false otherwise.
233 static inline bool phy_check_valid(int speed
, int duplex
,
234 unsigned long *features
)
236 return !!phy_lookup_setting(speed
, duplex
, features
, true);
240 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
241 * @phydev: the target phy_device struct
243 * Description: Make sure the PHY is set to supported speeds and
244 * duplexes. Drop down by one in this order: 1000/FULL,
245 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
247 static void phy_sanitize_settings(struct phy_device
*phydev
)
249 const struct phy_setting
*setting
;
251 setting
= phy_find_valid(phydev
->speed
, phydev
->duplex
,
254 phydev
->speed
= setting
->speed
;
255 phydev
->duplex
= setting
->duplex
;
257 /* We failed to find anything (no supported speeds?) */
258 phydev
->speed
= SPEED_UNKNOWN
;
259 phydev
->duplex
= DUPLEX_UNKNOWN
;
263 int phy_ethtool_ksettings_set(struct phy_device
*phydev
,
264 const struct ethtool_link_ksettings
*cmd
)
266 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising
);
267 u8 autoneg
= cmd
->base
.autoneg
;
268 u8 duplex
= cmd
->base
.duplex
;
269 u32 speed
= cmd
->base
.speed
;
271 if (cmd
->base
.phy_address
!= phydev
->mdio
.addr
)
274 linkmode_copy(advertising
, cmd
->link_modes
.advertising
);
276 /* We make sure that we don't pass unsupported values in to the PHY */
277 linkmode_and(advertising
, advertising
, phydev
->supported
);
279 /* Verify the settings we care about. */
280 if (autoneg
!= AUTONEG_ENABLE
&& autoneg
!= AUTONEG_DISABLE
)
283 if (autoneg
== AUTONEG_ENABLE
&& linkmode_empty(advertising
))
286 if (autoneg
== AUTONEG_DISABLE
&&
287 ((speed
!= SPEED_1000
&&
288 speed
!= SPEED_100
&&
289 speed
!= SPEED_10
) ||
290 (duplex
!= DUPLEX_HALF
&&
291 duplex
!= DUPLEX_FULL
)))
294 phydev
->autoneg
= autoneg
;
296 phydev
->speed
= speed
;
298 linkmode_copy(phydev
->advertising
, advertising
);
300 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
301 phydev
->advertising
, autoneg
== AUTONEG_ENABLE
);
303 phydev
->duplex
= duplex
;
304 phydev
->master_slave_set
= cmd
->base
.master_slave_cfg
;
305 phydev
->mdix_ctrl
= cmd
->base
.eth_tp_mdix_ctrl
;
307 /* Restart the PHY */
308 phy_start_aneg(phydev
);
312 EXPORT_SYMBOL(phy_ethtool_ksettings_set
);
314 void phy_ethtool_ksettings_get(struct phy_device
*phydev
,
315 struct ethtool_link_ksettings
*cmd
)
317 linkmode_copy(cmd
->link_modes
.supported
, phydev
->supported
);
318 linkmode_copy(cmd
->link_modes
.advertising
, phydev
->advertising
);
319 linkmode_copy(cmd
->link_modes
.lp_advertising
, phydev
->lp_advertising
);
321 cmd
->base
.speed
= phydev
->speed
;
322 cmd
->base
.duplex
= phydev
->duplex
;
323 cmd
->base
.master_slave_cfg
= phydev
->master_slave_get
;
324 cmd
->base
.master_slave_state
= phydev
->master_slave_state
;
325 if (phydev
->interface
== PHY_INTERFACE_MODE_MOCA
)
326 cmd
->base
.port
= PORT_BNC
;
328 cmd
->base
.port
= PORT_MII
;
329 cmd
->base
.transceiver
= phy_is_internal(phydev
) ?
330 XCVR_INTERNAL
: XCVR_EXTERNAL
;
331 cmd
->base
.phy_address
= phydev
->mdio
.addr
;
332 cmd
->base
.autoneg
= phydev
->autoneg
;
333 cmd
->base
.eth_tp_mdix_ctrl
= phydev
->mdix_ctrl
;
334 cmd
->base
.eth_tp_mdix
= phydev
->mdix
;
336 EXPORT_SYMBOL(phy_ethtool_ksettings_get
);
339 * phy_mii_ioctl - generic PHY MII ioctl interface
340 * @phydev: the phy_device struct
341 * @ifr: &struct ifreq for socket ioctl's
342 * @cmd: ioctl cmd to execute
344 * Note that this function is currently incompatible with the
345 * PHYCONTROL layer. It changes registers without regard to
346 * current state. Use at own risk.
348 int phy_mii_ioctl(struct phy_device
*phydev
, struct ifreq
*ifr
, int cmd
)
350 struct mii_ioctl_data
*mii_data
= if_mii(ifr
);
351 u16 val
= mii_data
->val_in
;
352 bool change_autoneg
= false;
357 mii_data
->phy_id
= phydev
->mdio
.addr
;
361 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
362 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
363 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
364 devad
= mdiobus_c45_addr(devad
, mii_data
->reg_num
);
366 prtad
= mii_data
->phy_id
;
367 devad
= mii_data
->reg_num
;
369 mii_data
->val_out
= mdiobus_read(phydev
->mdio
.bus
, prtad
,
374 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
375 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
376 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
377 devad
= mdiobus_c45_addr(devad
, mii_data
->reg_num
);
379 prtad
= mii_data
->phy_id
;
380 devad
= mii_data
->reg_num
;
382 if (prtad
== phydev
->mdio
.addr
) {
385 if ((val
& (BMCR_RESET
| BMCR_ANENABLE
)) == 0) {
386 if (phydev
->autoneg
== AUTONEG_ENABLE
)
387 change_autoneg
= true;
388 phydev
->autoneg
= AUTONEG_DISABLE
;
389 if (val
& BMCR_FULLDPLX
)
390 phydev
->duplex
= DUPLEX_FULL
;
392 phydev
->duplex
= DUPLEX_HALF
;
393 if (val
& BMCR_SPEED1000
)
394 phydev
->speed
= SPEED_1000
;
395 else if (val
& BMCR_SPEED100
)
396 phydev
->speed
= SPEED_100
;
397 else phydev
->speed
= SPEED_10
;
400 if (phydev
->autoneg
== AUTONEG_DISABLE
)
401 change_autoneg
= true;
402 phydev
->autoneg
= AUTONEG_ENABLE
;
406 mii_adv_mod_linkmode_adv_t(phydev
->advertising
,
408 change_autoneg
= true;
411 mii_ctrl1000_mod_linkmode_adv_t(phydev
->advertising
,
413 change_autoneg
= true;
421 mdiobus_write(phydev
->mdio
.bus
, prtad
, devad
, val
);
423 if (prtad
== phydev
->mdio
.addr
&&
426 return phy_init_hw(phydev
);
429 return phy_start_aneg(phydev
);
434 if (phydev
->mii_ts
&& phydev
->mii_ts
->hwtstamp
)
435 return phydev
->mii_ts
->hwtstamp(phydev
->mii_ts
, ifr
);
442 EXPORT_SYMBOL(phy_mii_ioctl
);
445 * phy_do_ioctl - generic ndo_do_ioctl implementation
446 * @dev: the net_device struct
447 * @ifr: &struct ifreq for socket ioctl's
448 * @cmd: ioctl cmd to execute
450 int phy_do_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
455 return phy_mii_ioctl(dev
->phydev
, ifr
, cmd
);
457 EXPORT_SYMBOL(phy_do_ioctl
);
459 /* same as phy_do_ioctl, but ensures that net_device is running */
460 int phy_do_ioctl_running(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
462 if (!netif_running(dev
))
465 return phy_do_ioctl(dev
, ifr
, cmd
);
467 EXPORT_SYMBOL(phy_do_ioctl_running
);
469 void phy_queue_state_machine(struct phy_device
*phydev
, unsigned long jiffies
)
471 mod_delayed_work(system_power_efficient_wq
, &phydev
->state_queue
,
474 EXPORT_SYMBOL(phy_queue_state_machine
);
476 static void phy_trigger_machine(struct phy_device
*phydev
)
478 phy_queue_state_machine(phydev
, 0);
481 static void phy_abort_cable_test(struct phy_device
*phydev
)
485 ethnl_cable_test_finished(phydev
);
487 err
= phy_init_hw(phydev
);
489 phydev_err(phydev
, "Error while aborting cable test");
492 int phy_start_cable_test(struct phy_device
*phydev
,
493 struct netlink_ext_ack
*extack
)
495 struct net_device
*dev
= phydev
->attached_dev
;
499 phydev
->drv
->cable_test_start
&&
500 phydev
->drv
->cable_test_get_status
)) {
501 NL_SET_ERR_MSG(extack
,
502 "PHY driver does not support cable testing");
506 mutex_lock(&phydev
->lock
);
507 if (phydev
->state
== PHY_CABLETEST
) {
508 NL_SET_ERR_MSG(extack
,
509 "PHY already performing a test");
514 if (phydev
->state
< PHY_UP
||
515 phydev
->state
> PHY_CABLETEST
) {
516 NL_SET_ERR_MSG(extack
,
517 "PHY not configured. Try setting interface up");
522 err
= ethnl_cable_test_alloc(phydev
, ETHTOOL_MSG_CABLE_TEST_NTF
);
526 /* Mark the carrier down until the test is complete */
527 phy_link_down(phydev
);
529 netif_testing_on(dev
);
530 err
= phydev
->drv
->cable_test_start(phydev
);
532 netif_testing_off(dev
);
537 phydev
->state
= PHY_CABLETEST
;
539 if (phy_polling_mode(phydev
))
540 phy_trigger_machine(phydev
);
542 mutex_unlock(&phydev
->lock
);
547 ethnl_cable_test_free(phydev
);
549 mutex_unlock(&phydev
->lock
);
553 EXPORT_SYMBOL(phy_start_cable_test
);
555 int phy_start_cable_test_tdr(struct phy_device
*phydev
,
556 struct netlink_ext_ack
*extack
)
558 struct net_device
*dev
= phydev
->attached_dev
;
562 phydev
->drv
->cable_test_tdr_start
&&
563 phydev
->drv
->cable_test_get_status
)) {
564 NL_SET_ERR_MSG(extack
,
565 "PHY driver does not support cable test TDR");
569 mutex_lock(&phydev
->lock
);
570 if (phydev
->state
== PHY_CABLETEST
) {
571 NL_SET_ERR_MSG(extack
,
572 "PHY already performing a test");
577 if (phydev
->state
< PHY_UP
||
578 phydev
->state
> PHY_CABLETEST
) {
579 NL_SET_ERR_MSG(extack
,
580 "PHY not configured. Try setting interface up");
585 err
= ethnl_cable_test_alloc(phydev
, ETHTOOL_MSG_CABLE_TEST_TDR_NTF
);
589 /* Mark the carrier down until the test is complete */
590 phy_link_down(phydev
);
592 netif_testing_on(dev
);
593 err
= phydev
->drv
->cable_test_tdr_start(phydev
);
595 netif_testing_off(dev
);
600 phydev
->state
= PHY_CABLETEST
;
602 if (phy_polling_mode(phydev
))
603 phy_trigger_machine(phydev
);
605 mutex_unlock(&phydev
->lock
);
610 ethnl_cable_test_free(phydev
);
612 mutex_unlock(&phydev
->lock
);
616 EXPORT_SYMBOL(phy_start_cable_test_tdr
);
618 static int phy_config_aneg(struct phy_device
*phydev
)
620 if (phydev
->drv
->config_aneg
)
621 return phydev
->drv
->config_aneg(phydev
);
623 /* Clause 45 PHYs that don't implement Clause 22 registers are not
624 * allowed to call genphy_config_aneg()
626 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
627 return genphy_c45_config_aneg(phydev
);
629 return genphy_config_aneg(phydev
);
633 * phy_check_link_status - check link status and set state accordingly
634 * @phydev: the phy_device struct
636 * Description: Check for link and whether autoneg was triggered / is running
637 * and set state accordingly
639 static int phy_check_link_status(struct phy_device
*phydev
)
643 WARN_ON(!mutex_is_locked(&phydev
->lock
));
645 /* Keep previous state if loopback is enabled because some PHYs
646 * report that Link is Down when loopback is enabled.
648 if (phydev
->loopback_enabled
)
651 err
= phy_read_status(phydev
);
655 if (phydev
->link
&& phydev
->state
!= PHY_RUNNING
) {
656 phy_check_downshift(phydev
);
657 phydev
->state
= PHY_RUNNING
;
659 } else if (!phydev
->link
&& phydev
->state
!= PHY_NOLINK
) {
660 phydev
->state
= PHY_NOLINK
;
661 phy_link_down(phydev
);
668 * phy_start_aneg - start auto-negotiation for this PHY device
669 * @phydev: the phy_device struct
671 * Description: Sanitizes the settings (if we're not autonegotiating
672 * them), and then calls the driver's config_aneg function.
673 * If the PHYCONTROL Layer is operating, we change the state to
674 * reflect the beginning of Auto-negotiation or forcing.
676 int phy_start_aneg(struct phy_device
*phydev
)
683 mutex_lock(&phydev
->lock
);
685 if (AUTONEG_DISABLE
== phydev
->autoneg
)
686 phy_sanitize_settings(phydev
);
688 err
= phy_config_aneg(phydev
);
692 if (phy_is_started(phydev
))
693 err
= phy_check_link_status(phydev
);
695 mutex_unlock(&phydev
->lock
);
699 EXPORT_SYMBOL(phy_start_aneg
);
701 static int phy_poll_aneg_done(struct phy_device
*phydev
)
703 unsigned int retries
= 100;
708 ret
= phy_aneg_done(phydev
);
709 } while (!ret
&& --retries
);
714 return ret
< 0 ? ret
: 0;
718 * phy_speed_down - set speed to lowest speed supported by both link partners
719 * @phydev: the phy_device struct
720 * @sync: perform action synchronously
722 * Description: Typically used to save energy when waiting for a WoL packet
724 * WARNING: Setting sync to false may cause the system being unable to suspend
725 * in case the PHY generates an interrupt when finishing the autonegotiation.
726 * This interrupt may wake up the system immediately after suspend.
727 * Therefore use sync = false only if you're sure it's safe with the respective
730 int phy_speed_down(struct phy_device
*phydev
, bool sync
)
732 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
735 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
738 linkmode_copy(adv_tmp
, phydev
->advertising
);
740 ret
= phy_speed_down_core(phydev
);
744 linkmode_copy(phydev
->adv_old
, adv_tmp
);
746 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
749 ret
= phy_config_aneg(phydev
);
753 return sync
? phy_poll_aneg_done(phydev
) : 0;
755 EXPORT_SYMBOL_GPL(phy_speed_down
);
758 * phy_speed_up - (re)set advertised speeds to all supported speeds
759 * @phydev: the phy_device struct
761 * Description: Used to revert the effect of phy_speed_down
763 int phy_speed_up(struct phy_device
*phydev
)
765 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
767 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
770 if (linkmode_empty(phydev
->adv_old
))
773 linkmode_copy(adv_tmp
, phydev
->advertising
);
774 linkmode_copy(phydev
->advertising
, phydev
->adv_old
);
775 linkmode_zero(phydev
->adv_old
);
777 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
780 return phy_config_aneg(phydev
);
782 EXPORT_SYMBOL_GPL(phy_speed_up
);
785 * phy_start_machine - start PHY state machine tracking
786 * @phydev: the phy_device struct
788 * Description: The PHY infrastructure can run a state machine
789 * which tracks whether the PHY is starting up, negotiating,
790 * etc. This function starts the delayed workqueue which tracks
791 * the state of the PHY. If you want to maintain your own state machine,
792 * do not call this function.
794 void phy_start_machine(struct phy_device
*phydev
)
796 phy_trigger_machine(phydev
);
798 EXPORT_SYMBOL_GPL(phy_start_machine
);
801 * phy_stop_machine - stop the PHY state machine tracking
802 * @phydev: target phy_device struct
804 * Description: Stops the state machine delayed workqueue, sets the
805 * state to UP (unless it wasn't up yet). This function must be
806 * called BEFORE phy_detach.
808 void phy_stop_machine(struct phy_device
*phydev
)
810 cancel_delayed_work_sync(&phydev
->state_queue
);
812 mutex_lock(&phydev
->lock
);
813 if (phy_is_started(phydev
))
814 phydev
->state
= PHY_UP
;
815 mutex_unlock(&phydev
->lock
);
819 * phy_error - enter HALTED state for this PHY device
820 * @phydev: target phy_device struct
822 * Moves the PHY to the HALTED state in response to a read
823 * or write error, and tells the controller the link is down.
824 * Must not be called from interrupt context, or while the
825 * phydev->lock is held.
827 static void phy_error(struct phy_device
*phydev
)
831 mutex_lock(&phydev
->lock
);
832 phydev
->state
= PHY_HALTED
;
833 mutex_unlock(&phydev
->lock
);
835 phy_trigger_machine(phydev
);
839 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
840 * @phydev: target phy_device struct
842 static int phy_disable_interrupts(struct phy_device
*phydev
)
846 /* Disable PHY interrupts */
847 err
= phy_config_interrupt(phydev
, PHY_INTERRUPT_DISABLED
);
851 /* Clear the interrupt */
852 return phy_clear_interrupt(phydev
);
856 * phy_interrupt - PHY interrupt handler
857 * @irq: interrupt line
858 * @phy_dat: phy_device pointer
860 * Description: Handle PHY interrupt
862 static irqreturn_t
phy_interrupt(int irq
, void *phy_dat
)
864 struct phy_device
*phydev
= phy_dat
;
865 struct phy_driver
*drv
= phydev
->drv
;
867 if (drv
->handle_interrupt
)
868 return drv
->handle_interrupt(phydev
);
870 if (drv
->did_interrupt
&& !drv
->did_interrupt(phydev
))
873 /* reschedule state queue work to run as soon as possible */
874 phy_trigger_machine(phydev
);
876 /* did_interrupt() may have cleared the interrupt already */
877 if (!drv
->did_interrupt
&& phy_clear_interrupt(phydev
)) {
886 * phy_enable_interrupts - Enable the interrupts from the PHY side
887 * @phydev: target phy_device struct
889 static int phy_enable_interrupts(struct phy_device
*phydev
)
891 int err
= phy_clear_interrupt(phydev
);
896 return phy_config_interrupt(phydev
, PHY_INTERRUPT_ENABLED
);
900 * phy_request_interrupt - request and enable interrupt for a PHY device
901 * @phydev: target phy_device struct
903 * Description: Request and enable the interrupt for the given PHY.
904 * If this fails, then we set irq to PHY_POLL.
905 * This should only be called with a valid IRQ number.
907 void phy_request_interrupt(struct phy_device
*phydev
)
911 err
= request_threaded_irq(phydev
->irq
, NULL
, phy_interrupt
,
912 IRQF_ONESHOT
| IRQF_SHARED
,
913 phydev_name(phydev
), phydev
);
915 phydev_warn(phydev
, "Error %d requesting IRQ %d, falling back to polling\n",
917 phydev
->irq
= PHY_POLL
;
919 if (phy_enable_interrupts(phydev
)) {
920 phydev_warn(phydev
, "Can't enable interrupt, falling back to polling\n");
921 phy_free_interrupt(phydev
);
922 phydev
->irq
= PHY_POLL
;
926 EXPORT_SYMBOL(phy_request_interrupt
);
929 * phy_free_interrupt - disable and free interrupt for a PHY device
930 * @phydev: target phy_device struct
932 * Description: Disable and free the interrupt for the given PHY.
933 * This should only be called with a valid IRQ number.
935 void phy_free_interrupt(struct phy_device
*phydev
)
937 phy_disable_interrupts(phydev
);
938 free_irq(phydev
->irq
, phydev
);
940 EXPORT_SYMBOL(phy_free_interrupt
);
943 * phy_stop - Bring down the PHY link, and stop checking the status
944 * @phydev: target phy_device struct
946 void phy_stop(struct phy_device
*phydev
)
948 struct net_device
*dev
= phydev
->attached_dev
;
950 if (!phy_is_started(phydev
)) {
951 WARN(1, "called from state %s\n",
952 phy_state_to_str(phydev
->state
));
956 mutex_lock(&phydev
->lock
);
958 if (phydev
->state
== PHY_CABLETEST
) {
959 phy_abort_cable_test(phydev
);
960 netif_testing_off(dev
);
964 sfp_upstream_stop(phydev
->sfp_bus
);
966 phydev
->state
= PHY_HALTED
;
968 mutex_unlock(&phydev
->lock
);
970 phy_state_machine(&phydev
->state_queue
.work
);
971 phy_stop_machine(phydev
);
973 /* Cannot call flush_scheduled_work() here as desired because
974 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
975 * will not reenable interrupts.
978 EXPORT_SYMBOL(phy_stop
);
981 * phy_start - start or restart a PHY device
982 * @phydev: target phy_device struct
984 * Description: Indicates the attached device's readiness to
985 * handle PHY-related work. Used during startup to start the
986 * PHY, and after a call to phy_stop() to resume operation.
987 * Also used to indicate the MDIO bus has cleared an error
990 void phy_start(struct phy_device
*phydev
)
992 mutex_lock(&phydev
->lock
);
994 if (phydev
->state
!= PHY_READY
&& phydev
->state
!= PHY_HALTED
) {
995 WARN(1, "called from state %s\n",
996 phy_state_to_str(phydev
->state
));
1000 if (phydev
->sfp_bus
)
1001 sfp_upstream_start(phydev
->sfp_bus
);
1003 /* if phy was suspended, bring the physical link up again */
1004 __phy_resume(phydev
);
1006 phydev
->state
= PHY_UP
;
1008 phy_start_machine(phydev
);
1010 mutex_unlock(&phydev
->lock
);
1012 EXPORT_SYMBOL(phy_start
);
1015 * phy_state_machine - Handle the state machine
1016 * @work: work_struct that describes the work to be done
1018 void phy_state_machine(struct work_struct
*work
)
1020 struct delayed_work
*dwork
= to_delayed_work(work
);
1021 struct phy_device
*phydev
=
1022 container_of(dwork
, struct phy_device
, state_queue
);
1023 struct net_device
*dev
= phydev
->attached_dev
;
1024 bool needs_aneg
= false, do_suspend
= false;
1025 enum phy_state old_state
;
1026 bool finished
= false;
1029 mutex_lock(&phydev
->lock
);
1031 old_state
= phydev
->state
;
1033 switch (phydev
->state
) {
1043 err
= phy_check_link_status(phydev
);
1046 err
= phydev
->drv
->cable_test_get_status(phydev
, &finished
);
1048 phy_abort_cable_test(phydev
);
1049 netif_testing_off(dev
);
1051 phydev
->state
= PHY_UP
;
1056 ethnl_cable_test_finished(phydev
);
1057 netif_testing_off(dev
);
1059 phydev
->state
= PHY_UP
;
1065 phy_link_down(phydev
);
1071 mutex_unlock(&phydev
->lock
);
1074 err
= phy_start_aneg(phydev
);
1075 else if (do_suspend
)
1076 phy_suspend(phydev
);
1081 if (old_state
!= phydev
->state
) {
1082 phydev_dbg(phydev
, "PHY state change %s -> %s\n",
1083 phy_state_to_str(old_state
),
1084 phy_state_to_str(phydev
->state
));
1085 if (phydev
->drv
&& phydev
->drv
->link_change_notify
)
1086 phydev
->drv
->link_change_notify(phydev
);
1089 /* Only re-schedule a PHY state machine change if we are polling the
1090 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
1091 * between states from phy_mac_interrupt().
1093 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1094 * state machine would be pointless and possibly error prone when
1095 * called from phy_disconnect() synchronously.
1097 mutex_lock(&phydev
->lock
);
1098 if (phy_polling_mode(phydev
) && phy_is_started(phydev
))
1099 phy_queue_state_machine(phydev
, PHY_STATE_TIME
);
1100 mutex_unlock(&phydev
->lock
);
1104 * phy_mac_interrupt - MAC says the link has changed
1105 * @phydev: phy_device struct with changed link
1107 * The MAC layer is able to indicate there has been a change in the PHY link
1108 * status. Trigger the state machine and work a work queue.
1110 void phy_mac_interrupt(struct phy_device
*phydev
)
1112 /* Trigger a state machine change */
1113 phy_trigger_machine(phydev
);
1115 EXPORT_SYMBOL(phy_mac_interrupt
);
1117 static void mmd_eee_adv_to_linkmode(unsigned long *advertising
, u16 eee_adv
)
1119 linkmode_zero(advertising
);
1121 if (eee_adv
& MDIO_EEE_100TX
)
1122 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT
,
1124 if (eee_adv
& MDIO_EEE_1000T
)
1125 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
1127 if (eee_adv
& MDIO_EEE_10GT
)
1128 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT
,
1130 if (eee_adv
& MDIO_EEE_1000KX
)
1131 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
,
1133 if (eee_adv
& MDIO_EEE_10GKX4
)
1134 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
,
1136 if (eee_adv
& MDIO_EEE_10GKR
)
1137 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
,
1142 * phy_init_eee - init and check the EEE feature
1143 * @phydev: target phy_device struct
1144 * @clk_stop_enable: PHY may stop the clock during LPI
1146 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1147 * is supported by looking at the MMD registers 3.20 and 7.60/61
1148 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1151 int phy_init_eee(struct phy_device
*phydev
, bool clk_stop_enable
)
1156 /* According to 802.3az,the EEE is supported only in full duplex-mode.
1158 if (phydev
->duplex
== DUPLEX_FULL
) {
1159 __ETHTOOL_DECLARE_LINK_MODE_MASK(common
);
1160 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp
);
1161 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv
);
1162 int eee_lp
, eee_cap
, eee_adv
;
1166 /* Read phy status to properly get the right settings */
1167 status
= phy_read_status(phydev
);
1171 /* First check if the EEE ability is supported */
1172 eee_cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1176 cap
= mmd_eee_cap_to_ethtool_sup_t(eee_cap
);
1180 /* Check which link settings negotiated and verify it in
1181 * the EEE advertising registers.
1183 eee_lp
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1187 eee_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1191 mmd_eee_adv_to_linkmode(adv
, eee_adv
);
1192 mmd_eee_adv_to_linkmode(lp
, eee_lp
);
1193 linkmode_and(common
, adv
, lp
);
1195 if (!phy_check_valid(phydev
->speed
, phydev
->duplex
, common
))
1198 if (clk_stop_enable
)
1199 /* Configure the PHY to stop receiving xMII
1200 * clock while it is signaling LPI.
1202 phy_set_bits_mmd(phydev
, MDIO_MMD_PCS
, MDIO_CTRL1
,
1203 MDIO_PCS_CTRL1_CLKSTOP_EN
);
1205 return 0; /* EEE supported */
1208 return -EPROTONOSUPPORT
;
1210 EXPORT_SYMBOL(phy_init_eee
);
1213 * phy_get_eee_err - report the EEE wake error count
1214 * @phydev: target phy_device struct
1216 * Description: it is to report the number of time where the PHY
1217 * failed to complete its normal wake sequence.
1219 int phy_get_eee_err(struct phy_device
*phydev
)
1224 return phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_WK_ERR
);
1226 EXPORT_SYMBOL(phy_get_eee_err
);
1229 * phy_ethtool_get_eee - get EEE supported and status
1230 * @phydev: target phy_device struct
1231 * @data: ethtool_eee data
1233 * Description: it reportes the Supported/Advertisement/LP Advertisement
1236 int phy_ethtool_get_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1243 /* Get Supported EEE */
1244 val
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1247 data
->supported
= mmd_eee_cap_to_ethtool_sup_t(val
);
1249 /* Get advertisement EEE */
1250 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1253 data
->advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1254 data
->eee_enabled
= !!data
->advertised
;
1256 /* Get LP advertisement EEE */
1257 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1260 data
->lp_advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1262 data
->eee_active
= !!(data
->advertised
& data
->lp_advertised
);
1266 EXPORT_SYMBOL(phy_ethtool_get_eee
);
1269 * phy_ethtool_set_eee - set EEE supported and status
1270 * @phydev: target phy_device struct
1271 * @data: ethtool_eee data
1273 * Description: it is to program the Advertisement EEE register.
1275 int phy_ethtool_set_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1277 int cap
, old_adv
, adv
= 0, ret
;
1282 /* Get Supported EEE */
1283 cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1287 old_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1291 if (data
->eee_enabled
) {
1292 adv
= !data
->advertised
? cap
:
1293 ethtool_adv_to_mmd_eee_adv_t(data
->advertised
) & cap
;
1294 /* Mask prohibited EEE modes */
1295 adv
&= ~phydev
->eee_broken_modes
;
1298 if (old_adv
!= adv
) {
1299 ret
= phy_write_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
, adv
);
1303 /* Restart autonegotiation so the new modes get sent to the
1306 if (phydev
->autoneg
== AUTONEG_ENABLE
) {
1307 ret
= phy_restart_aneg(phydev
);
1315 EXPORT_SYMBOL(phy_ethtool_set_eee
);
1317 int phy_ethtool_set_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1319 if (phydev
->drv
&& phydev
->drv
->set_wol
)
1320 return phydev
->drv
->set_wol(phydev
, wol
);
1324 EXPORT_SYMBOL(phy_ethtool_set_wol
);
1326 void phy_ethtool_get_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1328 if (phydev
->drv
&& phydev
->drv
->get_wol
)
1329 phydev
->drv
->get_wol(phydev
, wol
);
1331 EXPORT_SYMBOL(phy_ethtool_get_wol
);
1333 int phy_ethtool_get_link_ksettings(struct net_device
*ndev
,
1334 struct ethtool_link_ksettings
*cmd
)
1336 struct phy_device
*phydev
= ndev
->phydev
;
1341 phy_ethtool_ksettings_get(phydev
, cmd
);
1345 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings
);
1347 int phy_ethtool_set_link_ksettings(struct net_device
*ndev
,
1348 const struct ethtool_link_ksettings
*cmd
)
1350 struct phy_device
*phydev
= ndev
->phydev
;
1355 return phy_ethtool_ksettings_set(phydev
, cmd
);
1357 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings
);
1359 int phy_ethtool_nway_reset(struct net_device
*ndev
)
1361 struct phy_device
*phydev
= ndev
->phydev
;
1369 return phy_restart_aneg(phydev
);
1371 EXPORT_SYMBOL(phy_ethtool_nway_reset
);