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/etherdevice.h>
19 #include <linux/skbuff.h>
21 #include <linux/module.h>
22 #include <linux/mii.h>
23 #include <linux/ethtool.h>
24 #include <linux/phy.h>
25 #include <linux/phy_led_triggers.h>
26 #include <linux/workqueue.h>
27 #include <linux/mdio.h>
29 #include <linux/uaccess.h>
30 #include <linux/atomic.h>
32 #define PHY_STATE_TIME HZ
34 #define PHY_STATE_STR(_state) \
36 return __stringify(_state); \
38 static const char *phy_state_to_str(enum phy_state st)
44 PHY_STATE_STR(RUNNING
)
52 static void phy_link_up(struct phy_device
*phydev
)
54 phydev
->phy_link_change(phydev
, true, true);
55 phy_led_trigger_change_speed(phydev
);
58 static void phy_link_down(struct phy_device
*phydev
, bool do_carrier
)
60 phydev
->phy_link_change(phydev
, false, do_carrier
);
61 phy_led_trigger_change_speed(phydev
);
64 static const char *phy_pause_str(struct phy_device
*phydev
)
66 bool local_pause
, local_asym_pause
;
68 if (phydev
->autoneg
== AUTONEG_DISABLE
)
71 local_pause
= linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT
,
73 local_asym_pause
= linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT
,
76 if (local_pause
&& phydev
->pause
)
79 if (local_asym_pause
&& phydev
->asym_pause
) {
91 * phy_print_status - Convenience function to print out the current phy status
92 * @phydev: the phy_device struct
94 void phy_print_status(struct phy_device
*phydev
)
97 netdev_info(phydev
->attached_dev
,
98 "Link is Up - %s/%s - flow control %s\n",
99 phy_speed_to_str(phydev
->speed
),
100 phy_duplex_to_str(phydev
->duplex
),
101 phy_pause_str(phydev
));
103 netdev_info(phydev
->attached_dev
, "Link is Down\n");
106 EXPORT_SYMBOL(phy_print_status
);
109 * phy_clear_interrupt - Ack the phy device's interrupt
110 * @phydev: the phy_device struct
112 * If the @phydev driver has an ack_interrupt function, call it to
113 * ack and clear the phy device's interrupt.
115 * Returns 0 on success or < 0 on error.
117 static int phy_clear_interrupt(struct phy_device
*phydev
)
119 if (phydev
->drv
->ack_interrupt
)
120 return phydev
->drv
->ack_interrupt(phydev
);
126 * phy_config_interrupt - configure the PHY device for the requested interrupts
127 * @phydev: the phy_device struct
128 * @interrupts: interrupt flags to configure for this @phydev
130 * Returns 0 on success or < 0 on error.
132 static int phy_config_interrupt(struct phy_device
*phydev
, bool interrupts
)
134 phydev
->interrupts
= interrupts
? 1 : 0;
135 if (phydev
->drv
->config_intr
)
136 return phydev
->drv
->config_intr(phydev
);
142 * phy_restart_aneg - restart auto-negotiation
143 * @phydev: target phy_device struct
145 * Restart the autonegotiation on @phydev. Returns >= 0 on success or
146 * negative errno on error.
148 int phy_restart_aneg(struct phy_device
*phydev
)
152 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
153 ret
= genphy_c45_restart_aneg(phydev
);
155 ret
= genphy_restart_aneg(phydev
);
159 EXPORT_SYMBOL_GPL(phy_restart_aneg
);
162 * phy_aneg_done - return auto-negotiation status
163 * @phydev: target phy_device struct
165 * Description: Return the auto-negotiation status from this @phydev
166 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
169 int phy_aneg_done(struct phy_device
*phydev
)
171 if (phydev
->drv
&& phydev
->drv
->aneg_done
)
172 return phydev
->drv
->aneg_done(phydev
);
173 else if (phydev
->is_c45
)
174 return genphy_c45_aneg_done(phydev
);
176 return genphy_aneg_done(phydev
);
178 EXPORT_SYMBOL(phy_aneg_done
);
181 * phy_find_valid - find a PHY setting that matches the requested parameters
182 * @speed: desired speed
183 * @duplex: desired duplex
184 * @supported: mask of supported link modes
186 * Locate a supported phy setting that is, in priority order:
187 * - an exact match for the specified speed and duplex mode
188 * - a match for the specified speed, or slower speed
189 * - the slowest supported speed
190 * Returns the matched phy_setting entry, or %NULL if no supported phy
191 * settings were found.
193 static const struct phy_setting
*
194 phy_find_valid(int speed
, int duplex
, unsigned long *supported
)
196 return phy_lookup_setting(speed
, duplex
, supported
, false);
200 * phy_supported_speeds - return all speeds currently supported by a phy device
201 * @phy: The phy device to return supported speeds of.
202 * @speeds: buffer to store supported speeds in.
203 * @size: size of speeds buffer.
205 * Description: Returns the number of supported speeds, and fills the speeds
206 * buffer with the supported speeds. If speeds buffer is too small to contain
207 * all currently supported speeds, will return as many speeds as can fit.
209 unsigned int phy_supported_speeds(struct phy_device
*phy
,
210 unsigned int *speeds
,
213 return phy_speeds(speeds
, size
, phy
->supported
);
217 * phy_check_valid - check if there is a valid PHY setting which matches
218 * speed, duplex, and feature mask
219 * @speed: speed to match
220 * @duplex: duplex to match
221 * @features: A mask of the valid settings
223 * Description: Returns true if there is a valid setting, false otherwise.
225 static inline bool phy_check_valid(int speed
, int duplex
,
226 unsigned long *features
)
228 return !!phy_lookup_setting(speed
, duplex
, features
, true);
232 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
233 * @phydev: the target phy_device struct
235 * Description: Make sure the PHY is set to supported speeds and
236 * duplexes. Drop down by one in this order: 1000/FULL,
237 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
239 static void phy_sanitize_settings(struct phy_device
*phydev
)
241 const struct phy_setting
*setting
;
243 setting
= phy_find_valid(phydev
->speed
, phydev
->duplex
,
246 phydev
->speed
= setting
->speed
;
247 phydev
->duplex
= setting
->duplex
;
249 /* We failed to find anything (no supported speeds?) */
250 phydev
->speed
= SPEED_UNKNOWN
;
251 phydev
->duplex
= DUPLEX_UNKNOWN
;
256 * phy_ethtool_sset - generic ethtool sset function, handles all the details
257 * @phydev: target phy_device struct
260 * A few notes about parameter checking:
262 * - We don't set port or transceiver, so we don't care what they
264 * - phy_start_aneg() will make sure forced settings are sane, and
265 * choose the next best ones from the ones selected, so we don't
266 * care if ethtool tries to give us bad values.
268 int phy_ethtool_sset(struct phy_device
*phydev
, struct ethtool_cmd
*cmd
)
270 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising
);
271 u32 speed
= ethtool_cmd_speed(cmd
);
273 if (cmd
->phy_address
!= phydev
->mdio
.addr
)
276 /* We make sure that we don't pass unsupported values in to the PHY */
277 ethtool_convert_legacy_u32_to_link_mode(advertising
, cmd
->advertising
);
278 linkmode_and(advertising
, advertising
, phydev
->supported
);
280 /* Verify the settings we care about. */
281 if (cmd
->autoneg
!= AUTONEG_ENABLE
&& cmd
->autoneg
!= AUTONEG_DISABLE
)
284 if (cmd
->autoneg
== AUTONEG_ENABLE
&& cmd
->advertising
== 0)
287 if (cmd
->autoneg
== AUTONEG_DISABLE
&&
288 ((speed
!= SPEED_1000
&&
289 speed
!= SPEED_100
&&
290 speed
!= SPEED_10
) ||
291 (cmd
->duplex
!= DUPLEX_HALF
&&
292 cmd
->duplex
!= DUPLEX_FULL
)))
295 phydev
->autoneg
= cmd
->autoneg
;
297 phydev
->speed
= speed
;
299 linkmode_copy(phydev
->advertising
, advertising
);
301 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
302 phydev
->advertising
, AUTONEG_ENABLE
== cmd
->autoneg
);
304 phydev
->duplex
= cmd
->duplex
;
306 phydev
->mdix_ctrl
= cmd
->eth_tp_mdix_ctrl
;
308 /* Restart the PHY */
309 phy_start_aneg(phydev
);
313 EXPORT_SYMBOL(phy_ethtool_sset
);
315 int phy_ethtool_ksettings_set(struct phy_device
*phydev
,
316 const struct ethtool_link_ksettings
*cmd
)
318 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising
);
319 u8 autoneg
= cmd
->base
.autoneg
;
320 u8 duplex
= cmd
->base
.duplex
;
321 u32 speed
= cmd
->base
.speed
;
323 if (cmd
->base
.phy_address
!= phydev
->mdio
.addr
)
326 linkmode_copy(advertising
, cmd
->link_modes
.advertising
);
328 /* We make sure that we don't pass unsupported values in to the PHY */
329 linkmode_and(advertising
, advertising
, phydev
->supported
);
331 /* Verify the settings we care about. */
332 if (autoneg
!= AUTONEG_ENABLE
&& autoneg
!= AUTONEG_DISABLE
)
335 if (autoneg
== AUTONEG_ENABLE
&& linkmode_empty(advertising
))
338 if (autoneg
== AUTONEG_DISABLE
&&
339 ((speed
!= SPEED_1000
&&
340 speed
!= SPEED_100
&&
341 speed
!= SPEED_10
) ||
342 (duplex
!= DUPLEX_HALF
&&
343 duplex
!= DUPLEX_FULL
)))
346 phydev
->autoneg
= autoneg
;
348 if (autoneg
== AUTONEG_DISABLE
) {
349 phydev
->speed
= speed
;
350 phydev
->duplex
= duplex
;
353 linkmode_copy(phydev
->advertising
, advertising
);
355 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
,
356 phydev
->advertising
, autoneg
== AUTONEG_ENABLE
);
358 phydev
->mdix_ctrl
= cmd
->base
.eth_tp_mdix_ctrl
;
360 /* Restart the PHY */
361 phy_start_aneg(phydev
);
365 EXPORT_SYMBOL(phy_ethtool_ksettings_set
);
367 void phy_ethtool_ksettings_get(struct phy_device
*phydev
,
368 struct ethtool_link_ksettings
*cmd
)
370 mutex_lock(&phydev
->lock
);
371 linkmode_copy(cmd
->link_modes
.supported
, phydev
->supported
);
372 linkmode_copy(cmd
->link_modes
.advertising
, phydev
->advertising
);
373 linkmode_copy(cmd
->link_modes
.lp_advertising
, phydev
->lp_advertising
);
375 cmd
->base
.speed
= phydev
->speed
;
376 cmd
->base
.duplex
= phydev
->duplex
;
377 if (phydev
->interface
== PHY_INTERFACE_MODE_MOCA
)
378 cmd
->base
.port
= PORT_BNC
;
380 cmd
->base
.port
= PORT_MII
;
381 cmd
->base
.transceiver
= phy_is_internal(phydev
) ?
382 XCVR_INTERNAL
: XCVR_EXTERNAL
;
383 cmd
->base
.phy_address
= phydev
->mdio
.addr
;
384 cmd
->base
.autoneg
= phydev
->autoneg
;
385 cmd
->base
.eth_tp_mdix_ctrl
= phydev
->mdix_ctrl
;
386 cmd
->base
.eth_tp_mdix
= phydev
->mdix
;
387 mutex_unlock(&phydev
->lock
);
389 EXPORT_SYMBOL(phy_ethtool_ksettings_get
);
392 * phy_mii_ioctl - generic PHY MII ioctl interface
393 * @phydev: the phy_device struct
394 * @ifr: &struct ifreq for socket ioctl's
395 * @cmd: ioctl cmd to execute
397 * Note that this function is currently incompatible with the
398 * PHYCONTROL layer. It changes registers without regard to
399 * current state. Use at own risk.
401 int phy_mii_ioctl(struct phy_device
*phydev
, struct ifreq
*ifr
, int cmd
)
403 struct mii_ioctl_data
*mii_data
= if_mii(ifr
);
404 u16 val
= mii_data
->val_in
;
405 bool change_autoneg
= false;
410 mii_data
->phy_id
= phydev
->mdio
.addr
;
414 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
415 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
416 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
417 devad
= MII_ADDR_C45
| devad
<< 16 | mii_data
->reg_num
;
419 prtad
= mii_data
->phy_id
;
420 devad
= mii_data
->reg_num
;
422 mii_data
->val_out
= mdiobus_read(phydev
->mdio
.bus
, prtad
,
427 if (mdio_phy_id_is_c45(mii_data
->phy_id
)) {
428 prtad
= mdio_phy_id_prtad(mii_data
->phy_id
);
429 devad
= mdio_phy_id_devad(mii_data
->phy_id
);
430 devad
= MII_ADDR_C45
| devad
<< 16 | mii_data
->reg_num
;
432 prtad
= mii_data
->phy_id
;
433 devad
= mii_data
->reg_num
;
435 if (prtad
== phydev
->mdio
.addr
) {
438 if ((val
& (BMCR_RESET
| BMCR_ANENABLE
)) == 0) {
439 if (phydev
->autoneg
== AUTONEG_ENABLE
)
440 change_autoneg
= true;
441 phydev
->autoneg
= AUTONEG_DISABLE
;
442 if (val
& BMCR_FULLDPLX
)
443 phydev
->duplex
= DUPLEX_FULL
;
445 phydev
->duplex
= DUPLEX_HALF
;
446 if (val
& BMCR_SPEED1000
)
447 phydev
->speed
= SPEED_1000
;
448 else if (val
& BMCR_SPEED100
)
449 phydev
->speed
= SPEED_100
;
450 else phydev
->speed
= SPEED_10
;
453 if (phydev
->autoneg
== AUTONEG_DISABLE
)
454 change_autoneg
= true;
455 phydev
->autoneg
= AUTONEG_ENABLE
;
459 mii_adv_mod_linkmode_adv_t(phydev
->advertising
,
461 change_autoneg
= true;
464 mii_ctrl1000_mod_linkmode_adv_t(phydev
->advertising
,
466 change_autoneg
= true;
474 mdiobus_write(phydev
->mdio
.bus
, prtad
, devad
, val
);
476 if (prtad
== phydev
->mdio
.addr
&&
479 return phy_init_hw(phydev
);
482 return phy_start_aneg(phydev
);
487 if (phydev
->drv
&& phydev
->drv
->hwtstamp
)
488 return phydev
->drv
->hwtstamp(phydev
, ifr
);
495 EXPORT_SYMBOL(phy_mii_ioctl
);
497 void phy_queue_state_machine(struct phy_device
*phydev
, unsigned long jiffies
)
499 mod_delayed_work(system_power_efficient_wq
, &phydev
->state_queue
,
502 EXPORT_SYMBOL(phy_queue_state_machine
);
504 static void phy_trigger_machine(struct phy_device
*phydev
)
506 phy_queue_state_machine(phydev
, 0);
509 static int phy_config_aneg(struct phy_device
*phydev
)
511 if (phydev
->drv
->config_aneg
)
512 return phydev
->drv
->config_aneg(phydev
);
514 /* Clause 45 PHYs that don't implement Clause 22 registers are not
515 * allowed to call genphy_config_aneg()
517 if (phydev
->is_c45
&& !(phydev
->c45_ids
.devices_in_package
& BIT(0)))
518 return genphy_c45_config_aneg(phydev
);
520 return genphy_config_aneg(phydev
);
524 * phy_check_link_status - check link status and set state accordingly
525 * @phydev: the phy_device struct
527 * Description: Check for link and whether autoneg was triggered / is running
528 * and set state accordingly
530 static int phy_check_link_status(struct phy_device
*phydev
)
534 WARN_ON(!mutex_is_locked(&phydev
->lock
));
536 /* Keep previous state if loopback is enabled because some PHYs
537 * report that Link is Down when loopback is enabled.
539 if (phydev
->loopback_enabled
)
542 err
= phy_read_status(phydev
);
546 if (phydev
->link
&& phydev
->state
!= PHY_RUNNING
) {
547 phydev
->state
= PHY_RUNNING
;
549 } else if (!phydev
->link
&& phydev
->state
!= PHY_NOLINK
) {
550 phydev
->state
= PHY_NOLINK
;
551 phy_link_down(phydev
, true);
558 * _phy_start_aneg - start auto-negotiation for this PHY device
559 * @phydev: the phy_device struct
561 * Description: Sanitizes the settings (if we're not autonegotiating
562 * them), and then calls the driver's config_aneg function.
563 * If the PHYCONTROL Layer is operating, we change the state to
564 * reflect the beginning of Auto-negotiation or forcing.
566 static int _phy_start_aneg(struct phy_device
*phydev
)
570 lockdep_assert_held(&phydev
->lock
);
575 if (AUTONEG_DISABLE
== phydev
->autoneg
)
576 phy_sanitize_settings(phydev
);
578 err
= phy_config_aneg(phydev
);
582 if (phy_is_started(phydev
))
583 err
= phy_check_link_status(phydev
);
589 * phy_start_aneg - start auto-negotiation for this PHY device
590 * @phydev: the phy_device struct
592 * Description: Sanitizes the settings (if we're not autonegotiating
593 * them), and then calls the driver's config_aneg function.
594 * If the PHYCONTROL Layer is operating, we change the state to
595 * reflect the beginning of Auto-negotiation or forcing.
597 int phy_start_aneg(struct phy_device
*phydev
)
601 mutex_lock(&phydev
->lock
);
602 err
= _phy_start_aneg(phydev
);
603 mutex_unlock(&phydev
->lock
);
607 EXPORT_SYMBOL(phy_start_aneg
);
609 static int phy_poll_aneg_done(struct phy_device
*phydev
)
611 unsigned int retries
= 100;
616 ret
= phy_aneg_done(phydev
);
617 } while (!ret
&& --retries
);
622 return ret
< 0 ? ret
: 0;
626 * phy_speed_down - set speed to lowest speed supported by both link partners
627 * @phydev: the phy_device struct
628 * @sync: perform action synchronously
630 * Description: Typically used to save energy when waiting for a WoL packet
632 * WARNING: Setting sync to false may cause the system being unable to suspend
633 * in case the PHY generates an interrupt when finishing the autonegotiation.
634 * This interrupt may wake up the system immediately after suspend.
635 * Therefore use sync = false only if you're sure it's safe with the respective
638 int phy_speed_down(struct phy_device
*phydev
, bool sync
)
640 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
643 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
646 linkmode_copy(adv_tmp
, phydev
->advertising
);
648 ret
= phy_speed_down_core(phydev
);
652 linkmode_copy(phydev
->adv_old
, adv_tmp
);
654 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
657 ret
= phy_config_aneg(phydev
);
661 return sync
? phy_poll_aneg_done(phydev
) : 0;
663 EXPORT_SYMBOL_GPL(phy_speed_down
);
666 * phy_speed_up - (re)set advertised speeds to all supported speeds
667 * @phydev: the phy_device struct
669 * Description: Used to revert the effect of phy_speed_down
671 int phy_speed_up(struct phy_device
*phydev
)
673 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp
);
675 if (phydev
->autoneg
!= AUTONEG_ENABLE
)
678 if (linkmode_empty(phydev
->adv_old
))
681 linkmode_copy(adv_tmp
, phydev
->advertising
);
682 linkmode_copy(phydev
->advertising
, phydev
->adv_old
);
683 linkmode_zero(phydev
->adv_old
);
685 if (linkmode_equal(phydev
->advertising
, adv_tmp
))
688 return phy_config_aneg(phydev
);
690 EXPORT_SYMBOL_GPL(phy_speed_up
);
693 * phy_start_machine - start PHY state machine tracking
694 * @phydev: the phy_device struct
696 * Description: The PHY infrastructure can run a state machine
697 * which tracks whether the PHY is starting up, negotiating,
698 * etc. This function starts the delayed workqueue which tracks
699 * the state of the PHY. If you want to maintain your own state machine,
700 * do not call this function.
702 void phy_start_machine(struct phy_device
*phydev
)
704 phy_trigger_machine(phydev
);
706 EXPORT_SYMBOL_GPL(phy_start_machine
);
709 * phy_stop_machine - stop the PHY state machine tracking
710 * @phydev: target phy_device struct
712 * Description: Stops the state machine delayed workqueue, sets the
713 * state to UP (unless it wasn't up yet). This function must be
714 * called BEFORE phy_detach.
716 void phy_stop_machine(struct phy_device
*phydev
)
718 cancel_delayed_work_sync(&phydev
->state_queue
);
720 mutex_lock(&phydev
->lock
);
721 if (phy_is_started(phydev
))
722 phydev
->state
= PHY_UP
;
723 mutex_unlock(&phydev
->lock
);
727 * phy_error - enter HALTED state for this PHY device
728 * @phydev: target phy_device struct
730 * Moves the PHY to the HALTED state in response to a read
731 * or write error, and tells the controller the link is down.
732 * Must not be called from interrupt context, or while the
733 * phydev->lock is held.
735 static void phy_error(struct phy_device
*phydev
)
739 mutex_lock(&phydev
->lock
);
740 phydev
->state
= PHY_HALTED
;
741 mutex_unlock(&phydev
->lock
);
743 phy_trigger_machine(phydev
);
747 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
748 * @phydev: target phy_device struct
750 static int phy_disable_interrupts(struct phy_device
*phydev
)
754 /* Disable PHY interrupts */
755 err
= phy_config_interrupt(phydev
, PHY_INTERRUPT_DISABLED
);
759 /* Clear the interrupt */
760 return phy_clear_interrupt(phydev
);
764 * phy_interrupt - PHY interrupt handler
765 * @irq: interrupt line
766 * @phy_dat: phy_device pointer
768 * Description: Handle PHY interrupt
770 static irqreturn_t
phy_interrupt(int irq
, void *phy_dat
)
772 struct phy_device
*phydev
= phy_dat
;
774 if (phydev
->drv
->did_interrupt
&& !phydev
->drv
->did_interrupt(phydev
))
777 if (phydev
->drv
->handle_interrupt
) {
778 if (phydev
->drv
->handle_interrupt(phydev
))
781 /* reschedule state queue work to run as soon as possible */
782 phy_trigger_machine(phydev
);
785 /* did_interrupt() may have cleared the interrupt already */
786 if (!phydev
->drv
->did_interrupt
&& phy_clear_interrupt(phydev
))
796 * phy_enable_interrupts - Enable the interrupts from the PHY side
797 * @phydev: target phy_device struct
799 static int phy_enable_interrupts(struct phy_device
*phydev
)
801 int err
= phy_clear_interrupt(phydev
);
806 return phy_config_interrupt(phydev
, PHY_INTERRUPT_ENABLED
);
810 * phy_request_interrupt - request and enable interrupt for a PHY device
811 * @phydev: target phy_device struct
813 * Description: Request and enable the interrupt for the given PHY.
814 * If this fails, then we set irq to PHY_POLL.
815 * This should only be called with a valid IRQ number.
817 void phy_request_interrupt(struct phy_device
*phydev
)
821 err
= request_threaded_irq(phydev
->irq
, NULL
, phy_interrupt
,
822 IRQF_ONESHOT
| IRQF_SHARED
,
823 phydev_name(phydev
), phydev
);
825 phydev_warn(phydev
, "Error %d requesting IRQ %d, falling back to polling\n",
827 phydev
->irq
= PHY_POLL
;
829 if (phy_enable_interrupts(phydev
)) {
830 phydev_warn(phydev
, "Can't enable interrupt, falling back to polling\n");
831 phy_free_interrupt(phydev
);
832 phydev
->irq
= PHY_POLL
;
836 EXPORT_SYMBOL(phy_request_interrupt
);
839 * phy_free_interrupt - disable and free interrupt for a PHY device
840 * @phydev: target phy_device struct
842 * Description: Disable and free the interrupt for the given PHY.
843 * This should only be called with a valid IRQ number.
845 void phy_free_interrupt(struct phy_device
*phydev
)
847 phy_disable_interrupts(phydev
);
848 free_irq(phydev
->irq
, phydev
);
850 EXPORT_SYMBOL(phy_free_interrupt
);
853 * phy_stop - Bring down the PHY link, and stop checking the status
854 * @phydev: target phy_device struct
856 void phy_stop(struct phy_device
*phydev
)
858 if (!phy_is_started(phydev
) && phydev
->state
!= PHY_DOWN
) {
859 WARN(1, "called from state %s\n",
860 phy_state_to_str(phydev
->state
));
864 mutex_lock(&phydev
->lock
);
866 phydev
->state
= PHY_HALTED
;
868 mutex_unlock(&phydev
->lock
);
870 phy_state_machine(&phydev
->state_queue
.work
);
871 phy_stop_machine(phydev
);
873 /* Cannot call flush_scheduled_work() here as desired because
874 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
875 * will not reenable interrupts.
878 EXPORT_SYMBOL(phy_stop
);
881 * phy_start - start or restart a PHY device
882 * @phydev: target phy_device struct
884 * Description: Indicates the attached device's readiness to
885 * handle PHY-related work. Used during startup to start the
886 * PHY, and after a call to phy_stop() to resume operation.
887 * Also used to indicate the MDIO bus has cleared an error
890 void phy_start(struct phy_device
*phydev
)
892 mutex_lock(&phydev
->lock
);
894 if (phydev
->state
!= PHY_READY
&& phydev
->state
!= PHY_HALTED
) {
895 WARN(1, "called from state %s\n",
896 phy_state_to_str(phydev
->state
));
900 /* if phy was suspended, bring the physical link up again */
901 __phy_resume(phydev
);
903 phydev
->state
= PHY_UP
;
905 phy_start_machine(phydev
);
907 mutex_unlock(&phydev
->lock
);
909 EXPORT_SYMBOL(phy_start
);
912 * phy_state_machine - Handle the state machine
913 * @work: work_struct that describes the work to be done
915 void phy_state_machine(struct work_struct
*work
)
917 struct delayed_work
*dwork
= to_delayed_work(work
);
918 struct phy_device
*phydev
=
919 container_of(dwork
, struct phy_device
, state_queue
);
920 bool needs_aneg
= false, do_suspend
= false;
921 enum phy_state old_state
;
924 mutex_lock(&phydev
->lock
);
926 old_state
= phydev
->state
;
928 switch (phydev
->state
) {
938 err
= phy_check_link_status(phydev
);
943 phy_link_down(phydev
, true);
949 mutex_unlock(&phydev
->lock
);
952 err
= phy_start_aneg(phydev
);
959 if (old_state
!= phydev
->state
) {
960 phydev_dbg(phydev
, "PHY state change %s -> %s\n",
961 phy_state_to_str(old_state
),
962 phy_state_to_str(phydev
->state
));
963 if (phydev
->drv
&& phydev
->drv
->link_change_notify
)
964 phydev
->drv
->link_change_notify(phydev
);
967 /* Only re-schedule a PHY state machine change if we are polling the
968 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
969 * between states from phy_mac_interrupt().
971 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
972 * state machine would be pointless and possibly error prone when
973 * called from phy_disconnect() synchronously.
975 mutex_lock(&phydev
->lock
);
976 if (phy_polling_mode(phydev
) && phy_is_started(phydev
))
977 phy_queue_state_machine(phydev
, PHY_STATE_TIME
);
978 mutex_unlock(&phydev
->lock
);
982 * phy_mac_interrupt - MAC says the link has changed
983 * @phydev: phy_device struct with changed link
985 * The MAC layer is able to indicate there has been a change in the PHY link
986 * status. Trigger the state machine and work a work queue.
988 void phy_mac_interrupt(struct phy_device
*phydev
)
990 /* Trigger a state machine change */
991 phy_trigger_machine(phydev
);
993 EXPORT_SYMBOL(phy_mac_interrupt
);
995 static void mmd_eee_adv_to_linkmode(unsigned long *advertising
, u16 eee_adv
)
997 linkmode_zero(advertising
);
999 if (eee_adv
& MDIO_EEE_100TX
)
1000 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT
,
1002 if (eee_adv
& MDIO_EEE_1000T
)
1003 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT
,
1005 if (eee_adv
& MDIO_EEE_10GT
)
1006 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT
,
1008 if (eee_adv
& MDIO_EEE_1000KX
)
1009 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
,
1011 if (eee_adv
& MDIO_EEE_10GKX4
)
1012 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
,
1014 if (eee_adv
& MDIO_EEE_10GKR
)
1015 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
,
1020 * phy_init_eee - init and check the EEE feature
1021 * @phydev: target phy_device struct
1022 * @clk_stop_enable: PHY may stop the clock during LPI
1024 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1025 * is supported by looking at the MMD registers 3.20 and 7.60/61
1026 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1029 int phy_init_eee(struct phy_device
*phydev
, bool clk_stop_enable
)
1034 /* According to 802.3az,the EEE is supported only in full duplex-mode.
1036 if (phydev
->duplex
== DUPLEX_FULL
) {
1037 __ETHTOOL_DECLARE_LINK_MODE_MASK(common
);
1038 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp
);
1039 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv
);
1040 int eee_lp
, eee_cap
, eee_adv
;
1044 /* Read phy status to properly get the right settings */
1045 status
= phy_read_status(phydev
);
1049 /* First check if the EEE ability is supported */
1050 eee_cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1054 cap
= mmd_eee_cap_to_ethtool_sup_t(eee_cap
);
1058 /* Check which link settings negotiated and verify it in
1059 * the EEE advertising registers.
1061 eee_lp
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1065 eee_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1069 mmd_eee_adv_to_linkmode(adv
, eee_adv
);
1070 mmd_eee_adv_to_linkmode(lp
, eee_lp
);
1071 linkmode_and(common
, adv
, lp
);
1073 if (!phy_check_valid(phydev
->speed
, phydev
->duplex
, common
))
1076 if (clk_stop_enable
)
1077 /* Configure the PHY to stop receiving xMII
1078 * clock while it is signaling LPI.
1080 phy_set_bits_mmd(phydev
, MDIO_MMD_PCS
, MDIO_CTRL1
,
1081 MDIO_PCS_CTRL1_CLKSTOP_EN
);
1083 return 0; /* EEE supported */
1086 return -EPROTONOSUPPORT
;
1088 EXPORT_SYMBOL(phy_init_eee
);
1091 * phy_get_eee_err - report the EEE wake error count
1092 * @phydev: target phy_device struct
1094 * Description: it is to report the number of time where the PHY
1095 * failed to complete its normal wake sequence.
1097 int phy_get_eee_err(struct phy_device
*phydev
)
1102 return phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_WK_ERR
);
1104 EXPORT_SYMBOL(phy_get_eee_err
);
1107 * phy_ethtool_get_eee - get EEE supported and status
1108 * @phydev: target phy_device struct
1109 * @data: ethtool_eee data
1111 * Description: it reportes the Supported/Advertisement/LP Advertisement
1114 int phy_ethtool_get_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1121 /* Get Supported EEE */
1122 val
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1125 data
->supported
= mmd_eee_cap_to_ethtool_sup_t(val
);
1127 /* Get advertisement EEE */
1128 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1131 data
->advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1132 data
->eee_enabled
= !!data
->advertised
;
1134 /* Get LP advertisement EEE */
1135 val
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_LPABLE
);
1138 data
->lp_advertised
= mmd_eee_adv_to_ethtool_adv_t(val
);
1140 data
->eee_active
= !!(data
->advertised
& data
->lp_advertised
);
1144 EXPORT_SYMBOL(phy_ethtool_get_eee
);
1147 * phy_ethtool_set_eee - set EEE supported and status
1148 * @phydev: target phy_device struct
1149 * @data: ethtool_eee data
1151 * Description: it is to program the Advertisement EEE register.
1153 int phy_ethtool_set_eee(struct phy_device
*phydev
, struct ethtool_eee
*data
)
1155 int cap
, old_adv
, adv
= 0, ret
;
1160 /* Get Supported EEE */
1161 cap
= phy_read_mmd(phydev
, MDIO_MMD_PCS
, MDIO_PCS_EEE_ABLE
);
1165 old_adv
= phy_read_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
);
1169 if (data
->eee_enabled
) {
1170 adv
= !data
->advertised
? cap
:
1171 ethtool_adv_to_mmd_eee_adv_t(data
->advertised
) & cap
;
1172 /* Mask prohibited EEE modes */
1173 adv
&= ~phydev
->eee_broken_modes
;
1176 if (old_adv
!= adv
) {
1177 ret
= phy_write_mmd(phydev
, MDIO_MMD_AN
, MDIO_AN_EEE_ADV
, adv
);
1181 /* Restart autonegotiation so the new modes get sent to the
1184 if (phydev
->autoneg
== AUTONEG_ENABLE
) {
1185 ret
= phy_restart_aneg(phydev
);
1193 EXPORT_SYMBOL(phy_ethtool_set_eee
);
1195 int phy_ethtool_set_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1197 if (phydev
->drv
&& phydev
->drv
->set_wol
)
1198 return phydev
->drv
->set_wol(phydev
, wol
);
1202 EXPORT_SYMBOL(phy_ethtool_set_wol
);
1204 void phy_ethtool_get_wol(struct phy_device
*phydev
, struct ethtool_wolinfo
*wol
)
1206 if (phydev
->drv
&& phydev
->drv
->get_wol
)
1207 phydev
->drv
->get_wol(phydev
, wol
);
1209 EXPORT_SYMBOL(phy_ethtool_get_wol
);
1211 int phy_ethtool_get_link_ksettings(struct net_device
*ndev
,
1212 struct ethtool_link_ksettings
*cmd
)
1214 struct phy_device
*phydev
= ndev
->phydev
;
1219 phy_ethtool_ksettings_get(phydev
, cmd
);
1223 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings
);
1225 int phy_ethtool_set_link_ksettings(struct net_device
*ndev
,
1226 const struct ethtool_link_ksettings
*cmd
)
1228 struct phy_device
*phydev
= ndev
->phydev
;
1233 return phy_ethtool_ksettings_set(phydev
, cmd
);
1235 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings
);
1237 int phy_ethtool_nway_reset(struct net_device
*ndev
)
1239 struct phy_device
*phydev
= ndev
->phydev
;
1247 return phy_restart_aneg(phydev
);
1249 EXPORT_SYMBOL(phy_ethtool_nway_reset
);