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,
557 const struct phy_tdr_config *config)
559 struct net_device *dev = phydev->attached_dev;
563 phydev->drv->cable_test_tdr_start &&
564 phydev->drv->cable_test_get_status)) {
565 NL_SET_ERR_MSG(extack,
566 "PHY driver does not support cable test TDR");
570 mutex_lock(&phydev->lock);
571 if (phydev->state == PHY_CABLETEST) {
572 NL_SET_ERR_MSG(extack,
573 "PHY already performing a test");
578 if (phydev->state < PHY_UP ||
579 phydev->state > PHY_CABLETEST) {
580 NL_SET_ERR_MSG(extack,
581 "PHY not configured. Try setting interface up");
586 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
590 /* Mark the carrier down until the test is complete */
591 phy_link_down(phydev);
593 netif_testing_on(dev);
594 err = phydev->drv->cable_test_tdr_start(phydev, config);
596 netif_testing_off(dev);
601 phydev->state = PHY_CABLETEST;
603 if (phy_polling_mode(phydev))
604 phy_trigger_machine(phydev);
606 mutex_unlock(&phydev->lock);
611 ethnl_cable_test_free(phydev);
613 mutex_unlock(&phydev->lock);
617 EXPORT_SYMBOL(phy_start_cable_test_tdr);
619 static int phy_config_aneg(struct phy_device *phydev)
621 if (phydev->drv->config_aneg)
622 return phydev->drv->config_aneg(phydev);
624 /* Clause 45 PHYs that don't implement Clause 22 registers are not
625 * allowed to call genphy_config_aneg()
627 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
628 return genphy_c45_config_aneg(phydev);
630 return genphy_config_aneg(phydev);
634 * phy_check_link_status - check link status and set state accordingly
635 * @phydev: the phy_device struct
637 * Description: Check for link and whether autoneg was triggered / is running
638 * and set state accordingly
640 static int phy_check_link_status(struct phy_device *phydev)
644 WARN_ON(!mutex_is_locked(&phydev->lock));
646 /* Keep previous state if loopback is enabled because some PHYs
647 * report that Link is Down when loopback is enabled.
649 if (phydev->loopback_enabled)
652 err = phy_read_status(phydev);
656 if (phydev->link && phydev->state != PHY_RUNNING) {
657 phy_check_downshift(phydev);
658 phydev->state = PHY_RUNNING;
660 } else if (!phydev->link && phydev->state != PHY_NOLINK) {
661 phydev->state = PHY_NOLINK;
662 phy_link_down(phydev);
669 * phy_start_aneg - start auto-negotiation for this PHY device
670 * @phydev: the phy_device struct
672 * Description: Sanitizes the settings (if we're not autonegotiating
673 * them), and then calls the driver's config_aneg function.
674 * If the PHYCONTROL Layer is operating, we change the state to
675 * reflect the beginning of Auto-negotiation or forcing.
677 int phy_start_aneg(struct phy_device *phydev)
684 mutex_lock(&phydev->lock);
686 if (AUTONEG_DISABLE == phydev->autoneg)
687 phy_sanitize_settings(phydev);
689 err = phy_config_aneg(phydev);
693 if (phy_is_started(phydev))
694 err = phy_check_link_status(phydev);
696 mutex_unlock(&phydev->lock);
700 EXPORT_SYMBOL(phy_start_aneg);
702 static int phy_poll_aneg_done(struct phy_device *phydev)
704 unsigned int retries = 100;
709 ret = phy_aneg_done(phydev);
710 } while (!ret && --retries);
715 return ret < 0 ? ret : 0;
719 * phy_speed_down - set speed to lowest speed supported by both link partners
720 * @phydev: the phy_device struct
721 * @sync: perform action synchronously
723 * Description: Typically used to save energy when waiting for a WoL packet
725 * WARNING: Setting sync to false may cause the system being unable to suspend
726 * in case the PHY generates an interrupt when finishing the autonegotiation.
727 * This interrupt may wake up the system immediately after suspend.
728 * Therefore use sync = false only if you're sure it's safe with the respective
731 int phy_speed_down(struct phy_device *phydev, bool sync)
733 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
736 if (phydev->autoneg != AUTONEG_ENABLE)
739 linkmode_copy(adv_tmp, phydev->advertising);
741 ret = phy_speed_down_core(phydev);
745 linkmode_copy(phydev->adv_old, adv_tmp);
747 if (linkmode_equal(phydev->advertising, adv_tmp))
750 ret = phy_config_aneg(phydev);
754 return sync ? phy_poll_aneg_done(phydev) : 0;
756 EXPORT_SYMBOL_GPL(phy_speed_down);
759 * phy_speed_up - (re)set advertised speeds to all supported speeds
760 * @phydev: the phy_device struct
762 * Description: Used to revert the effect of phy_speed_down
764 int phy_speed_up(struct phy_device *phydev)
766 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
768 if (phydev->autoneg != AUTONEG_ENABLE)
771 if (linkmode_empty(phydev->adv_old))
774 linkmode_copy(adv_tmp, phydev->advertising);
775 linkmode_copy(phydev->advertising, phydev->adv_old);
776 linkmode_zero(phydev->adv_old);
778 if (linkmode_equal(phydev->advertising, adv_tmp))
781 return phy_config_aneg(phydev);
783 EXPORT_SYMBOL_GPL(phy_speed_up);
786 * phy_start_machine - start PHY state machine tracking
787 * @phydev: the phy_device struct
789 * Description: The PHY infrastructure can run a state machine
790 * which tracks whether the PHY is starting up, negotiating,
791 * etc. This function starts the delayed workqueue which tracks
792 * the state of the PHY. If you want to maintain your own state machine,
793 * do not call this function.
795 void phy_start_machine(struct phy_device *phydev)
797 phy_trigger_machine(phydev);
799 EXPORT_SYMBOL_GPL(phy_start_machine);
802 * phy_stop_machine - stop the PHY state machine tracking
803 * @phydev: target phy_device struct
805 * Description: Stops the state machine delayed workqueue, sets the
806 * state to UP (unless it wasn't up yet). This function must be
807 * called BEFORE phy_detach.
809 void phy_stop_machine(struct phy_device *phydev)
811 cancel_delayed_work_sync(&phydev->state_queue);
813 mutex_lock(&phydev->lock);
814 if (phy_is_started(phydev))
815 phydev->state = PHY_UP;
816 mutex_unlock(&phydev->lock);
820 * phy_error - enter HALTED state for this PHY device
821 * @phydev: target phy_device struct
823 * Moves the PHY to the HALTED state in response to a read
824 * or write error, and tells the controller the link is down.
825 * Must not be called from interrupt context, or while the
826 * phydev->lock is held.
828 static void phy_error(struct phy_device *phydev)
832 mutex_lock(&phydev->lock);
833 phydev->state = PHY_HALTED;
834 mutex_unlock(&phydev->lock);
836 phy_trigger_machine(phydev);
840 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
841 * @phydev: target phy_device struct
843 static int phy_disable_interrupts(struct phy_device *phydev)
847 /* Disable PHY interrupts */
848 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
852 /* Clear the interrupt */
853 return phy_clear_interrupt(phydev);
857 * phy_interrupt - PHY interrupt handler
858 * @irq: interrupt line
859 * @phy_dat: phy_device pointer
861 * Description: Handle PHY interrupt
863 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
865 struct phy_device *phydev = phy_dat;
866 struct phy_driver *drv = phydev->drv;
868 if (drv->handle_interrupt)
869 return drv->handle_interrupt(phydev);
871 if (drv->did_interrupt && !drv->did_interrupt(phydev))
874 /* reschedule state queue work to run as soon as possible */
875 phy_trigger_machine(phydev);
877 /* did_interrupt() may have cleared the interrupt already */
878 if (!drv->did_interrupt && phy_clear_interrupt(phydev)) {
887 * phy_enable_interrupts - Enable the interrupts from the PHY side
888 * @phydev: target phy_device struct
890 static int phy_enable_interrupts(struct phy_device *phydev)
892 int err = phy_clear_interrupt(phydev);
897 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
901 * phy_request_interrupt - request and enable interrupt for a PHY device
902 * @phydev: target phy_device struct
904 * Description: Request and enable the interrupt for the given PHY.
905 * If this fails, then we set irq to PHY_POLL.
906 * This should only be called with a valid IRQ number.
908 void phy_request_interrupt(struct phy_device *phydev)
912 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
913 IRQF_ONESHOT | IRQF_SHARED,
914 phydev_name(phydev), phydev);
916 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
918 phydev->irq = PHY_POLL;
920 if (phy_enable_interrupts(phydev)) {
921 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
922 phy_free_interrupt(phydev);
923 phydev->irq = PHY_POLL;
927 EXPORT_SYMBOL(phy_request_interrupt);
930 * phy_free_interrupt - disable and free interrupt for a PHY device
931 * @phydev: target phy_device struct
933 * Description: Disable and free the interrupt for the given PHY.
934 * This should only be called with a valid IRQ number.
936 void phy_free_interrupt(struct phy_device *phydev)
938 phy_disable_interrupts(phydev);
939 free_irq(phydev->irq, phydev);
941 EXPORT_SYMBOL(phy_free_interrupt);
944 * phy_stop - Bring down the PHY link, and stop checking the status
945 * @phydev: target phy_device struct
947 void phy_stop(struct phy_device *phydev)
949 struct net_device *dev = phydev->attached_dev;
951 if (!phy_is_started(phydev)) {
952 WARN(1, "called from state %s\n",
953 phy_state_to_str(phydev->state));
957 mutex_lock(&phydev->lock);
959 if (phydev->state == PHY_CABLETEST) {
960 phy_abort_cable_test(phydev);
961 netif_testing_off(dev);
965 sfp_upstream_stop(phydev->sfp_bus);
967 phydev->state = PHY_HALTED;
969 mutex_unlock(&phydev->lock);
971 phy_state_machine(&phydev->state_queue.work);
972 phy_stop_machine(phydev);
974 /* Cannot call flush_scheduled_work() here as desired because
975 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
976 * will not reenable interrupts.
979 EXPORT_SYMBOL(phy_stop);
982 * phy_start - start or restart a PHY device
983 * @phydev: target phy_device struct
985 * Description: Indicates the attached device's readiness to
986 * handle PHY-related work. Used during startup to start the
987 * PHY, and after a call to phy_stop() to resume operation.
988 * Also used to indicate the MDIO bus has cleared an error
991 void phy_start(struct phy_device *phydev)
993 mutex_lock(&phydev->lock);
995 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
996 WARN(1, "called from state %s\n",
997 phy_state_to_str(phydev->state));
1001 if (phydev->sfp_bus)
1002 sfp_upstream_start(phydev->sfp_bus);
1004 /* if phy was suspended, bring the physical link up again */
1005 __phy_resume(phydev);
1007 phydev->state = PHY_UP;
1009 phy_start_machine(phydev);
1011 mutex_unlock(&phydev->lock);
1013 EXPORT_SYMBOL(phy_start);
1016 * phy_state_machine - Handle the state machine
1017 * @work: work_struct that describes the work to be done
1019 void phy_state_machine(struct work_struct *work)
1021 struct delayed_work *dwork = to_delayed_work(work);
1022 struct phy_device *phydev =
1023 container_of(dwork, struct phy_device, state_queue);
1024 struct net_device *dev = phydev->attached_dev;
1025 bool needs_aneg = false, do_suspend = false;
1026 enum phy_state old_state;
1027 bool finished = false;
1030 mutex_lock(&phydev->lock);
1032 old_state = phydev->state;
1034 switch (phydev->state) {
1044 err = phy_check_link_status(phydev);
1047 err = phydev->drv->cable_test_get_status(phydev, &finished);
1049 phy_abort_cable_test(phydev);
1050 netif_testing_off(dev);
1052 phydev->state = PHY_UP;
1057 ethnl_cable_test_finished(phydev);
1058 netif_testing_off(dev);
1060 phydev->state = PHY_UP;
1066 phy_link_down(phydev);
1072 mutex_unlock(&phydev->lock);
1075 err = phy_start_aneg(phydev);
1076 else if (do_suspend)
1077 phy_suspend(phydev);
1082 if (old_state != phydev->state) {
1083 phydev_dbg(phydev, "PHY state change %s -> %s\n",
1084 phy_state_to_str(old_state),
1085 phy_state_to_str(phydev->state));
1086 if (phydev->drv && phydev->drv->link_change_notify)
1087 phydev->drv->link_change_notify(phydev);
1090 /* Only re-schedule a PHY state machine change if we are polling the
1091 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
1092 * between states from phy_mac_interrupt().
1094 * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1095 * state machine would be pointless and possibly error prone when
1096 * called from phy_disconnect() synchronously.
1098 mutex_lock(&phydev->lock);
1099 if (phy_polling_mode(phydev) && phy_is_started(phydev))
1100 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1101 mutex_unlock(&phydev->lock);
1105 * phy_mac_interrupt - MAC says the link has changed
1106 * @phydev: phy_device struct with changed link
1108 * The MAC layer is able to indicate there has been a change in the PHY link
1109 * status. Trigger the state machine and work a work queue.
1111 void phy_mac_interrupt(struct phy_device *phydev)
1113 /* Trigger a state machine change */
1114 phy_trigger_machine(phydev);
1116 EXPORT_SYMBOL(phy_mac_interrupt);
1118 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1120 linkmode_zero(advertising);
1122 if (eee_adv & MDIO_EEE_100TX)
1123 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1125 if (eee_adv & MDIO_EEE_1000T)
1126 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1128 if (eee_adv & MDIO_EEE_10GT)
1129 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1131 if (eee_adv & MDIO_EEE_1000KX)
1132 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1134 if (eee_adv & MDIO_EEE_10GKX4)
1135 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1137 if (eee_adv & MDIO_EEE_10GKR)
1138 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1143 * phy_init_eee - init and check the EEE feature
1144 * @phydev: target phy_device struct
1145 * @clk_stop_enable: PHY may stop the clock during LPI
1147 * Description: it checks if the Energy-Efficient Ethernet (EEE)
1148 * is supported by looking at the MMD registers 3.20 and 7.60/61
1149 * and it programs the MMD register 3.0 setting the "Clock stop enable"
1152 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1157 /* According to 802.3az,the EEE is supported only in full duplex-mode.
1159 if (phydev->duplex == DUPLEX_FULL) {
1160 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1161 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1162 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1163 int eee_lp, eee_cap, eee_adv;
1167 /* Read phy status to properly get the right settings */
1168 status = phy_read_status(phydev);
1172 /* First check if the EEE ability is supported */
1173 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1177 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1181 /* Check which link settings negotiated and verify it in
1182 * the EEE advertising registers.
1184 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1188 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1192 mmd_eee_adv_to_linkmode(adv, eee_adv);
1193 mmd_eee_adv_to_linkmode(lp, eee_lp);
1194 linkmode_and(common, adv, lp);
1196 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1199 if (clk_stop_enable)
1200 /* Configure the PHY to stop receiving xMII
1201 * clock while it is signaling LPI.
1203 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1204 MDIO_PCS_CTRL1_CLKSTOP_EN);
1206 return 0; /* EEE supported */
1209 return -EPROTONOSUPPORT;
1211 EXPORT_SYMBOL(phy_init_eee);
1214 * phy_get_eee_err - report the EEE wake error count
1215 * @phydev: target phy_device struct
1217 * Description: it is to report the number of time where the PHY
1218 * failed to complete its normal wake sequence.
1220 int phy_get_eee_err(struct phy_device *phydev)
1225 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1227 EXPORT_SYMBOL(phy_get_eee_err);
1230 * phy_ethtool_get_eee - get EEE supported and status
1231 * @phydev: target phy_device struct
1232 * @data: ethtool_eee data
1234 * Description: it reportes the Supported/Advertisement/LP Advertisement
1237 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1244 /* Get Supported EEE */
1245 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1248 data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1250 /* Get advertisement EEE */
1251 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1254 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1255 data->eee_enabled = !!data->advertised;
1257 /* Get LP advertisement EEE */
1258 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1261 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1263 data->eee_active = !!(data->advertised & data->lp_advertised);
1267 EXPORT_SYMBOL(phy_ethtool_get_eee);
1270 * phy_ethtool_set_eee - set EEE supported and status
1271 * @phydev: target phy_device struct
1272 * @data: ethtool_eee data
1274 * Description: it is to program the Advertisement EEE register.
1276 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1278 int cap, old_adv, adv = 0, ret;
1283 /* Get Supported EEE */
1284 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1288 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1292 if (data->eee_enabled) {
1293 adv = !data->advertised ? cap :
1294 ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1295 /* Mask prohibited EEE modes */
1296 adv &= ~phydev->eee_broken_modes;
1299 if (old_adv != adv) {
1300 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1304 /* Restart autonegotiation so the new modes get sent to the
1307 if (phydev->autoneg == AUTONEG_ENABLE) {
1308 ret = phy_restart_aneg(phydev);
1316 EXPORT_SYMBOL(phy_ethtool_set_eee);
1318 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1320 if (phydev->drv && phydev->drv->set_wol)
1321 return phydev->drv->set_wol(phydev, wol);
1325 EXPORT_SYMBOL(phy_ethtool_set_wol);
1327 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1329 if (phydev->drv && phydev->drv->get_wol)
1330 phydev->drv->get_wol(phydev, wol);
1332 EXPORT_SYMBOL(phy_ethtool_get_wol);
1334 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1335 struct ethtool_link_ksettings *cmd)
1337 struct phy_device *phydev = ndev->phydev;
1342 phy_ethtool_ksettings_get(phydev, cmd);
1346 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1348 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1349 const struct ethtool_link_ksettings *cmd)
1351 struct phy_device *phydev = ndev->phydev;
1356 return phy_ethtool_ksettings_set(phydev, cmd);
1358 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1360 int phy_ethtool_nway_reset(struct net_device *ndev)
1362 struct phy_device *phydev = ndev->phydev;
1370 return phy_restart_aneg(phydev);
1372 EXPORT_SYMBOL(phy_ethtool_nway_reset);