Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /* Framework for configuring and reading PHY devices
0003  * Based on code in sungem_phy.c and gianfar_phy.c
0004  *
0005  * Author: Andy Fleming
0006  *
0007  * Copyright (c) 2004 Freescale Semiconductor, Inc.
0008  * Copyright (c) 2006, 2007  Maciej W. Rozycki
0009  */
0010 
0011 #include <linux/kernel.h>
0012 #include <linux/string.h>
0013 #include <linux/errno.h>
0014 #include <linux/unistd.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/delay.h>
0017 #include <linux/netdevice.h>
0018 #include <linux/netlink.h>
0019 #include <linux/etherdevice.h>
0020 #include <linux/skbuff.h>
0021 #include <linux/mm.h>
0022 #include <linux/module.h>
0023 #include <linux/mii.h>
0024 #include <linux/ethtool.h>
0025 #include <linux/ethtool_netlink.h>
0026 #include <linux/phy.h>
0027 #include <linux/phy_led_triggers.h>
0028 #include <linux/sfp.h>
0029 #include <linux/workqueue.h>
0030 #include <linux/mdio.h>
0031 #include <linux/io.h>
0032 #include <linux/uaccess.h>
0033 #include <linux/atomic.h>
0034 #include <linux/suspend.h>
0035 #include <net/netlink.h>
0036 #include <net/genetlink.h>
0037 #include <net/sock.h>
0038 
0039 #define PHY_STATE_TIME  HZ
0040 
0041 #define PHY_STATE_STR(_state)           \
0042     case PHY_##_state:          \
0043         return __stringify(_state); \
0044 
0045 static const char *phy_state_to_str(enum phy_state st)
0046 {
0047     switch (st) {
0048     PHY_STATE_STR(DOWN)
0049     PHY_STATE_STR(READY)
0050     PHY_STATE_STR(UP)
0051     PHY_STATE_STR(RUNNING)
0052     PHY_STATE_STR(NOLINK)
0053     PHY_STATE_STR(CABLETEST)
0054     PHY_STATE_STR(HALTED)
0055     }
0056 
0057     return NULL;
0058 }
0059 
0060 static void phy_link_up(struct phy_device *phydev)
0061 {
0062     phydev->phy_link_change(phydev, true);
0063     phy_led_trigger_change_speed(phydev);
0064 }
0065 
0066 static void phy_link_down(struct phy_device *phydev)
0067 {
0068     phydev->phy_link_change(phydev, false);
0069     phy_led_trigger_change_speed(phydev);
0070 }
0071 
0072 static const char *phy_pause_str(struct phy_device *phydev)
0073 {
0074     bool local_pause, local_asym_pause;
0075 
0076     if (phydev->autoneg == AUTONEG_DISABLE)
0077         goto no_pause;
0078 
0079     local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
0080                     phydev->advertising);
0081     local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
0082                          phydev->advertising);
0083 
0084     if (local_pause && phydev->pause)
0085         return "rx/tx";
0086 
0087     if (local_asym_pause && phydev->asym_pause) {
0088         if (local_pause)
0089             return "rx";
0090         if (phydev->pause)
0091             return "tx";
0092     }
0093 
0094 no_pause:
0095     return "off";
0096 }
0097 
0098 /**
0099  * phy_print_status - Convenience function to print out the current phy status
0100  * @phydev: the phy_device struct
0101  */
0102 void phy_print_status(struct phy_device *phydev)
0103 {
0104     if (phydev->link) {
0105         netdev_info(phydev->attached_dev,
0106             "Link is Up - %s/%s %s- flow control %s\n",
0107             phy_speed_to_str(phydev->speed),
0108             phy_duplex_to_str(phydev->duplex),
0109             phydev->downshifted_rate ? "(downshifted) " : "",
0110             phy_pause_str(phydev));
0111     } else  {
0112         netdev_info(phydev->attached_dev, "Link is Down\n");
0113     }
0114 }
0115 EXPORT_SYMBOL(phy_print_status);
0116 
0117 /**
0118  * phy_config_interrupt - configure the PHY device for the requested interrupts
0119  * @phydev: the phy_device struct
0120  * @interrupts: interrupt flags to configure for this @phydev
0121  *
0122  * Returns 0 on success or < 0 on error.
0123  */
0124 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
0125 {
0126     phydev->interrupts = interrupts ? 1 : 0;
0127     if (phydev->drv->config_intr)
0128         return phydev->drv->config_intr(phydev);
0129 
0130     return 0;
0131 }
0132 
0133 /**
0134  * phy_restart_aneg - restart auto-negotiation
0135  * @phydev: target phy_device struct
0136  *
0137  * Restart the autonegotiation on @phydev.  Returns >= 0 on success or
0138  * negative errno on error.
0139  */
0140 int phy_restart_aneg(struct phy_device *phydev)
0141 {
0142     int ret;
0143 
0144     if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
0145         ret = genphy_c45_restart_aneg(phydev);
0146     else
0147         ret = genphy_restart_aneg(phydev);
0148 
0149     return ret;
0150 }
0151 EXPORT_SYMBOL_GPL(phy_restart_aneg);
0152 
0153 /**
0154  * phy_aneg_done - return auto-negotiation status
0155  * @phydev: target phy_device struct
0156  *
0157  * Description: Return the auto-negotiation status from this @phydev
0158  * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
0159  * is still pending.
0160  */
0161 int phy_aneg_done(struct phy_device *phydev)
0162 {
0163     if (phydev->drv && phydev->drv->aneg_done)
0164         return phydev->drv->aneg_done(phydev);
0165     else if (phydev->is_c45)
0166         return genphy_c45_aneg_done(phydev);
0167     else
0168         return genphy_aneg_done(phydev);
0169 }
0170 EXPORT_SYMBOL(phy_aneg_done);
0171 
0172 /**
0173  * phy_find_valid - find a PHY setting that matches the requested parameters
0174  * @speed: desired speed
0175  * @duplex: desired duplex
0176  * @supported: mask of supported link modes
0177  *
0178  * Locate a supported phy setting that is, in priority order:
0179  * - an exact match for the specified speed and duplex mode
0180  * - a match for the specified speed, or slower speed
0181  * - the slowest supported speed
0182  * Returns the matched phy_setting entry, or %NULL if no supported phy
0183  * settings were found.
0184  */
0185 static const struct phy_setting *
0186 phy_find_valid(int speed, int duplex, unsigned long *supported)
0187 {
0188     return phy_lookup_setting(speed, duplex, supported, false);
0189 }
0190 
0191 /**
0192  * phy_supported_speeds - return all speeds currently supported by a phy device
0193  * @phy: The phy device to return supported speeds of.
0194  * @speeds: buffer to store supported speeds in.
0195  * @size:   size of speeds buffer.
0196  *
0197  * Description: Returns the number of supported speeds, and fills the speeds
0198  * buffer with the supported speeds. If speeds buffer is too small to contain
0199  * all currently supported speeds, will return as many speeds as can fit.
0200  */
0201 unsigned int phy_supported_speeds(struct phy_device *phy,
0202                   unsigned int *speeds,
0203                   unsigned int size)
0204 {
0205     return phy_speeds(speeds, size, phy->supported);
0206 }
0207 
0208 /**
0209  * phy_check_valid - check if there is a valid PHY setting which matches
0210  *           speed, duplex, and feature mask
0211  * @speed: speed to match
0212  * @duplex: duplex to match
0213  * @features: A mask of the valid settings
0214  *
0215  * Description: Returns true if there is a valid setting, false otherwise.
0216  */
0217 static inline bool phy_check_valid(int speed, int duplex,
0218                    unsigned long *features)
0219 {
0220     return !!phy_lookup_setting(speed, duplex, features, true);
0221 }
0222 
0223 /**
0224  * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
0225  * @phydev: the target phy_device struct
0226  *
0227  * Description: Make sure the PHY is set to supported speeds and
0228  *   duplexes.  Drop down by one in this order:  1000/FULL,
0229  *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
0230  */
0231 static void phy_sanitize_settings(struct phy_device *phydev)
0232 {
0233     const struct phy_setting *setting;
0234 
0235     setting = phy_find_valid(phydev->speed, phydev->duplex,
0236                  phydev->supported);
0237     if (setting) {
0238         phydev->speed = setting->speed;
0239         phydev->duplex = setting->duplex;
0240     } else {
0241         /* We failed to find anything (no supported speeds?) */
0242         phydev->speed = SPEED_UNKNOWN;
0243         phydev->duplex = DUPLEX_UNKNOWN;
0244     }
0245 }
0246 
0247 void phy_ethtool_ksettings_get(struct phy_device *phydev,
0248                    struct ethtool_link_ksettings *cmd)
0249 {
0250     mutex_lock(&phydev->lock);
0251     linkmode_copy(cmd->link_modes.supported, phydev->supported);
0252     linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
0253     linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
0254 
0255     cmd->base.speed = phydev->speed;
0256     cmd->base.duplex = phydev->duplex;
0257     cmd->base.master_slave_cfg = phydev->master_slave_get;
0258     cmd->base.master_slave_state = phydev->master_slave_state;
0259     if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
0260         cmd->base.port = PORT_BNC;
0261     else
0262         cmd->base.port = phydev->port;
0263     cmd->base.transceiver = phy_is_internal(phydev) ?
0264                 XCVR_INTERNAL : XCVR_EXTERNAL;
0265     cmd->base.phy_address = phydev->mdio.addr;
0266     cmd->base.autoneg = phydev->autoneg;
0267     cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
0268     cmd->base.eth_tp_mdix = phydev->mdix;
0269     mutex_unlock(&phydev->lock);
0270 }
0271 EXPORT_SYMBOL(phy_ethtool_ksettings_get);
0272 
0273 /**
0274  * phy_mii_ioctl - generic PHY MII ioctl interface
0275  * @phydev: the phy_device struct
0276  * @ifr: &struct ifreq for socket ioctl's
0277  * @cmd: ioctl cmd to execute
0278  *
0279  * Note that this function is currently incompatible with the
0280  * PHYCONTROL layer.  It changes registers without regard to
0281  * current state.  Use at own risk.
0282  */
0283 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
0284 {
0285     struct mii_ioctl_data *mii_data = if_mii(ifr);
0286     u16 val = mii_data->val_in;
0287     bool change_autoneg = false;
0288     int prtad, devad;
0289 
0290     switch (cmd) {
0291     case SIOCGMIIPHY:
0292         mii_data->phy_id = phydev->mdio.addr;
0293         fallthrough;
0294 
0295     case SIOCGMIIREG:
0296         if (mdio_phy_id_is_c45(mii_data->phy_id)) {
0297             prtad = mdio_phy_id_prtad(mii_data->phy_id);
0298             devad = mdio_phy_id_devad(mii_data->phy_id);
0299             mii_data->val_out = mdiobus_c45_read(
0300                 phydev->mdio.bus, prtad, devad,
0301                 mii_data->reg_num);
0302         } else {
0303             mii_data->val_out = mdiobus_read(
0304                 phydev->mdio.bus, mii_data->phy_id,
0305                 mii_data->reg_num);
0306         }
0307         return 0;
0308 
0309     case SIOCSMIIREG:
0310         if (mdio_phy_id_is_c45(mii_data->phy_id)) {
0311             prtad = mdio_phy_id_prtad(mii_data->phy_id);
0312             devad = mdio_phy_id_devad(mii_data->phy_id);
0313         } else {
0314             prtad = mii_data->phy_id;
0315             devad = mii_data->reg_num;
0316         }
0317         if (prtad == phydev->mdio.addr) {
0318             switch (devad) {
0319             case MII_BMCR:
0320                 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
0321                     if (phydev->autoneg == AUTONEG_ENABLE)
0322                         change_autoneg = true;
0323                     phydev->autoneg = AUTONEG_DISABLE;
0324                     if (val & BMCR_FULLDPLX)
0325                         phydev->duplex = DUPLEX_FULL;
0326                     else
0327                         phydev->duplex = DUPLEX_HALF;
0328                     if (val & BMCR_SPEED1000)
0329                         phydev->speed = SPEED_1000;
0330                     else if (val & BMCR_SPEED100)
0331                         phydev->speed = SPEED_100;
0332                     else phydev->speed = SPEED_10;
0333                 } else {
0334                     if (phydev->autoneg == AUTONEG_DISABLE)
0335                         change_autoneg = true;
0336                     phydev->autoneg = AUTONEG_ENABLE;
0337                 }
0338                 break;
0339             case MII_ADVERTISE:
0340                 mii_adv_mod_linkmode_adv_t(phydev->advertising,
0341                                val);
0342                 change_autoneg = true;
0343                 break;
0344             case MII_CTRL1000:
0345                 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
0346                                     val);
0347                 change_autoneg = true;
0348                 break;
0349             default:
0350                 /* do nothing */
0351                 break;
0352             }
0353         }
0354 
0355         if (mdio_phy_id_is_c45(mii_data->phy_id))
0356             mdiobus_c45_write(phydev->mdio.bus, prtad, devad,
0357                       mii_data->reg_num, val);
0358         else
0359             mdiobus_write(phydev->mdio.bus, prtad, devad, val);
0360 
0361         if (prtad == phydev->mdio.addr &&
0362             devad == MII_BMCR &&
0363             val & BMCR_RESET)
0364             return phy_init_hw(phydev);
0365 
0366         if (change_autoneg)
0367             return phy_start_aneg(phydev);
0368 
0369         return 0;
0370 
0371     case SIOCSHWTSTAMP:
0372         if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
0373             return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
0374         fallthrough;
0375 
0376     default:
0377         return -EOPNOTSUPP;
0378     }
0379 }
0380 EXPORT_SYMBOL(phy_mii_ioctl);
0381 
0382 /**
0383  * phy_do_ioctl - generic ndo_eth_ioctl implementation
0384  * @dev: the net_device struct
0385  * @ifr: &struct ifreq for socket ioctl's
0386  * @cmd: ioctl cmd to execute
0387  */
0388 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
0389 {
0390     if (!dev->phydev)
0391         return -ENODEV;
0392 
0393     return phy_mii_ioctl(dev->phydev, ifr, cmd);
0394 }
0395 EXPORT_SYMBOL(phy_do_ioctl);
0396 
0397 /**
0398  * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first
0399  *
0400  * @dev: the net_device struct
0401  * @ifr: &struct ifreq for socket ioctl's
0402  * @cmd: ioctl cmd to execute
0403  *
0404  * Same as phy_do_ioctl, but ensures that net_device is running before
0405  * handling the ioctl.
0406  */
0407 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
0408 {
0409     if (!netif_running(dev))
0410         return -ENODEV;
0411 
0412     return phy_do_ioctl(dev, ifr, cmd);
0413 }
0414 EXPORT_SYMBOL(phy_do_ioctl_running);
0415 
0416 /**
0417  * phy_queue_state_machine - Trigger the state machine to run soon
0418  *
0419  * @phydev: the phy_device struct
0420  * @jiffies: Run the state machine after these jiffies
0421  */
0422 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
0423 {
0424     mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
0425              jiffies);
0426 }
0427 EXPORT_SYMBOL(phy_queue_state_machine);
0428 
0429 /**
0430  * phy_trigger_machine - Trigger the state machine to run now
0431  *
0432  * @phydev: the phy_device struct
0433  */
0434 void phy_trigger_machine(struct phy_device *phydev)
0435 {
0436     phy_queue_state_machine(phydev, 0);
0437 }
0438 EXPORT_SYMBOL(phy_trigger_machine);
0439 
0440 static void phy_abort_cable_test(struct phy_device *phydev)
0441 {
0442     int err;
0443 
0444     ethnl_cable_test_finished(phydev);
0445 
0446     err = phy_init_hw(phydev);
0447     if (err)
0448         phydev_err(phydev, "Error while aborting cable test");
0449 }
0450 
0451 /**
0452  * phy_ethtool_get_strings - Get the statistic counter names
0453  *
0454  * @phydev: the phy_device struct
0455  * @data: Where to put the strings
0456  */
0457 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
0458 {
0459     if (!phydev->drv)
0460         return -EIO;
0461 
0462     mutex_lock(&phydev->lock);
0463     phydev->drv->get_strings(phydev, data);
0464     mutex_unlock(&phydev->lock);
0465 
0466     return 0;
0467 }
0468 EXPORT_SYMBOL(phy_ethtool_get_strings);
0469 
0470 /**
0471  * phy_ethtool_get_sset_count - Get the number of statistic counters
0472  *
0473  * @phydev: the phy_device struct
0474  */
0475 int phy_ethtool_get_sset_count(struct phy_device *phydev)
0476 {
0477     int ret;
0478 
0479     if (!phydev->drv)
0480         return -EIO;
0481 
0482     if (phydev->drv->get_sset_count &&
0483         phydev->drv->get_strings &&
0484         phydev->drv->get_stats) {
0485         mutex_lock(&phydev->lock);
0486         ret = phydev->drv->get_sset_count(phydev);
0487         mutex_unlock(&phydev->lock);
0488 
0489         return ret;
0490     }
0491 
0492     return -EOPNOTSUPP;
0493 }
0494 EXPORT_SYMBOL(phy_ethtool_get_sset_count);
0495 
0496 /**
0497  * phy_ethtool_get_stats - Get the statistic counters
0498  *
0499  * @phydev: the phy_device struct
0500  * @stats: What counters to get
0501  * @data: Where to store the counters
0502  */
0503 int phy_ethtool_get_stats(struct phy_device *phydev,
0504               struct ethtool_stats *stats, u64 *data)
0505 {
0506     if (!phydev->drv)
0507         return -EIO;
0508 
0509     mutex_lock(&phydev->lock);
0510     phydev->drv->get_stats(phydev, stats, data);
0511     mutex_unlock(&phydev->lock);
0512 
0513     return 0;
0514 }
0515 EXPORT_SYMBOL(phy_ethtool_get_stats);
0516 
0517 /**
0518  * phy_start_cable_test - Start a cable test
0519  *
0520  * @phydev: the phy_device struct
0521  * @extack: extack for reporting useful error messages
0522  */
0523 int phy_start_cable_test(struct phy_device *phydev,
0524              struct netlink_ext_ack *extack)
0525 {
0526     struct net_device *dev = phydev->attached_dev;
0527     int err = -ENOMEM;
0528 
0529     if (!(phydev->drv &&
0530           phydev->drv->cable_test_start &&
0531           phydev->drv->cable_test_get_status)) {
0532         NL_SET_ERR_MSG(extack,
0533                    "PHY driver does not support cable testing");
0534         return -EOPNOTSUPP;
0535     }
0536 
0537     mutex_lock(&phydev->lock);
0538     if (phydev->state == PHY_CABLETEST) {
0539         NL_SET_ERR_MSG(extack,
0540                    "PHY already performing a test");
0541         err = -EBUSY;
0542         goto out;
0543     }
0544 
0545     if (phydev->state < PHY_UP ||
0546         phydev->state > PHY_CABLETEST) {
0547         NL_SET_ERR_MSG(extack,
0548                    "PHY not configured. Try setting interface up");
0549         err = -EBUSY;
0550         goto out;
0551     }
0552 
0553     err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
0554     if (err)
0555         goto out;
0556 
0557     /* Mark the carrier down until the test is complete */
0558     phy_link_down(phydev);
0559 
0560     netif_testing_on(dev);
0561     err = phydev->drv->cable_test_start(phydev);
0562     if (err) {
0563         netif_testing_off(dev);
0564         phy_link_up(phydev);
0565         goto out_free;
0566     }
0567 
0568     phydev->state = PHY_CABLETEST;
0569 
0570     if (phy_polling_mode(phydev))
0571         phy_trigger_machine(phydev);
0572 
0573     mutex_unlock(&phydev->lock);
0574 
0575     return 0;
0576 
0577 out_free:
0578     ethnl_cable_test_free(phydev);
0579 out:
0580     mutex_unlock(&phydev->lock);
0581 
0582     return err;
0583 }
0584 EXPORT_SYMBOL(phy_start_cable_test);
0585 
0586 /**
0587  * phy_start_cable_test_tdr - Start a raw TDR cable test
0588  *
0589  * @phydev: the phy_device struct
0590  * @extack: extack for reporting useful error messages
0591  * @config: Configuration of the test to run
0592  */
0593 int phy_start_cable_test_tdr(struct phy_device *phydev,
0594                  struct netlink_ext_ack *extack,
0595                  const struct phy_tdr_config *config)
0596 {
0597     struct net_device *dev = phydev->attached_dev;
0598     int err = -ENOMEM;
0599 
0600     if (!(phydev->drv &&
0601           phydev->drv->cable_test_tdr_start &&
0602           phydev->drv->cable_test_get_status)) {
0603         NL_SET_ERR_MSG(extack,
0604                    "PHY driver does not support cable test TDR");
0605         return -EOPNOTSUPP;
0606     }
0607 
0608     mutex_lock(&phydev->lock);
0609     if (phydev->state == PHY_CABLETEST) {
0610         NL_SET_ERR_MSG(extack,
0611                    "PHY already performing a test");
0612         err = -EBUSY;
0613         goto out;
0614     }
0615 
0616     if (phydev->state < PHY_UP ||
0617         phydev->state > PHY_CABLETEST) {
0618         NL_SET_ERR_MSG(extack,
0619                    "PHY not configured. Try setting interface up");
0620         err = -EBUSY;
0621         goto out;
0622     }
0623 
0624     err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
0625     if (err)
0626         goto out;
0627 
0628     /* Mark the carrier down until the test is complete */
0629     phy_link_down(phydev);
0630 
0631     netif_testing_on(dev);
0632     err = phydev->drv->cable_test_tdr_start(phydev, config);
0633     if (err) {
0634         netif_testing_off(dev);
0635         phy_link_up(phydev);
0636         goto out_free;
0637     }
0638 
0639     phydev->state = PHY_CABLETEST;
0640 
0641     if (phy_polling_mode(phydev))
0642         phy_trigger_machine(phydev);
0643 
0644     mutex_unlock(&phydev->lock);
0645 
0646     return 0;
0647 
0648 out_free:
0649     ethnl_cable_test_free(phydev);
0650 out:
0651     mutex_unlock(&phydev->lock);
0652 
0653     return err;
0654 }
0655 EXPORT_SYMBOL(phy_start_cable_test_tdr);
0656 
0657 int phy_config_aneg(struct phy_device *phydev)
0658 {
0659     if (phydev->drv->config_aneg)
0660         return phydev->drv->config_aneg(phydev);
0661 
0662     /* Clause 45 PHYs that don't implement Clause 22 registers are not
0663      * allowed to call genphy_config_aneg()
0664      */
0665     if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
0666         return genphy_c45_config_aneg(phydev);
0667 
0668     return genphy_config_aneg(phydev);
0669 }
0670 EXPORT_SYMBOL(phy_config_aneg);
0671 
0672 /**
0673  * phy_check_link_status - check link status and set state accordingly
0674  * @phydev: the phy_device struct
0675  *
0676  * Description: Check for link and whether autoneg was triggered / is running
0677  * and set state accordingly
0678  */
0679 static int phy_check_link_status(struct phy_device *phydev)
0680 {
0681     int err;
0682 
0683     lockdep_assert_held(&phydev->lock);
0684 
0685     /* Keep previous state if loopback is enabled because some PHYs
0686      * report that Link is Down when loopback is enabled.
0687      */
0688     if (phydev->loopback_enabled)
0689         return 0;
0690 
0691     err = phy_read_status(phydev);
0692     if (err)
0693         return err;
0694 
0695     if (phydev->link && phydev->state != PHY_RUNNING) {
0696         phy_check_downshift(phydev);
0697         phydev->state = PHY_RUNNING;
0698         phy_link_up(phydev);
0699     } else if (!phydev->link && phydev->state != PHY_NOLINK) {
0700         phydev->state = PHY_NOLINK;
0701         phy_link_down(phydev);
0702     }
0703 
0704     return 0;
0705 }
0706 
0707 /**
0708  * _phy_start_aneg - start auto-negotiation for this PHY device
0709  * @phydev: the phy_device struct
0710  *
0711  * Description: Sanitizes the settings (if we're not autonegotiating
0712  *   them), and then calls the driver's config_aneg function.
0713  *   If the PHYCONTROL Layer is operating, we change the state to
0714  *   reflect the beginning of Auto-negotiation or forcing.
0715  */
0716 static int _phy_start_aneg(struct phy_device *phydev)
0717 {
0718     int err;
0719 
0720     lockdep_assert_held(&phydev->lock);
0721 
0722     if (!phydev->drv)
0723         return -EIO;
0724 
0725     if (AUTONEG_DISABLE == phydev->autoneg)
0726         phy_sanitize_settings(phydev);
0727 
0728     err = phy_config_aneg(phydev);
0729     if (err < 0)
0730         return err;
0731 
0732     if (phy_is_started(phydev))
0733         err = phy_check_link_status(phydev);
0734 
0735     return err;
0736 }
0737 
0738 /**
0739  * phy_start_aneg - start auto-negotiation for this PHY device
0740  * @phydev: the phy_device struct
0741  *
0742  * Description: Sanitizes the settings (if we're not autonegotiating
0743  *   them), and then calls the driver's config_aneg function.
0744  *   If the PHYCONTROL Layer is operating, we change the state to
0745  *   reflect the beginning of Auto-negotiation or forcing.
0746  */
0747 int phy_start_aneg(struct phy_device *phydev)
0748 {
0749     int err;
0750 
0751     mutex_lock(&phydev->lock);
0752     err = _phy_start_aneg(phydev);
0753     mutex_unlock(&phydev->lock);
0754 
0755     return err;
0756 }
0757 EXPORT_SYMBOL(phy_start_aneg);
0758 
0759 static int phy_poll_aneg_done(struct phy_device *phydev)
0760 {
0761     unsigned int retries = 100;
0762     int ret;
0763 
0764     do {
0765         msleep(100);
0766         ret = phy_aneg_done(phydev);
0767     } while (!ret && --retries);
0768 
0769     if (!ret)
0770         return -ETIMEDOUT;
0771 
0772     return ret < 0 ? ret : 0;
0773 }
0774 
0775 int phy_ethtool_ksettings_set(struct phy_device *phydev,
0776                   const struct ethtool_link_ksettings *cmd)
0777 {
0778     __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
0779     u8 autoneg = cmd->base.autoneg;
0780     u8 duplex = cmd->base.duplex;
0781     u32 speed = cmd->base.speed;
0782 
0783     if (cmd->base.phy_address != phydev->mdio.addr)
0784         return -EINVAL;
0785 
0786     linkmode_copy(advertising, cmd->link_modes.advertising);
0787 
0788     /* We make sure that we don't pass unsupported values in to the PHY */
0789     linkmode_and(advertising, advertising, phydev->supported);
0790 
0791     /* Verify the settings we care about. */
0792     if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
0793         return -EINVAL;
0794 
0795     if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
0796         return -EINVAL;
0797 
0798     if (autoneg == AUTONEG_DISABLE &&
0799         ((speed != SPEED_1000 &&
0800           speed != SPEED_100 &&
0801           speed != SPEED_10) ||
0802          (duplex != DUPLEX_HALF &&
0803           duplex != DUPLEX_FULL)))
0804         return -EINVAL;
0805 
0806     mutex_lock(&phydev->lock);
0807     phydev->autoneg = autoneg;
0808 
0809     if (autoneg == AUTONEG_DISABLE) {
0810         phydev->speed = speed;
0811         phydev->duplex = duplex;
0812     }
0813 
0814     linkmode_copy(phydev->advertising, advertising);
0815 
0816     linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
0817              phydev->advertising, autoneg == AUTONEG_ENABLE);
0818 
0819     phydev->master_slave_set = cmd->base.master_slave_cfg;
0820     phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
0821 
0822     /* Restart the PHY */
0823     if (phy_is_started(phydev)) {
0824         phydev->state = PHY_UP;
0825         phy_trigger_machine(phydev);
0826     } else {
0827         _phy_start_aneg(phydev);
0828     }
0829 
0830     mutex_unlock(&phydev->lock);
0831     return 0;
0832 }
0833 EXPORT_SYMBOL(phy_ethtool_ksettings_set);
0834 
0835 /**
0836  * phy_speed_down - set speed to lowest speed supported by both link partners
0837  * @phydev: the phy_device struct
0838  * @sync: perform action synchronously
0839  *
0840  * Description: Typically used to save energy when waiting for a WoL packet
0841  *
0842  * WARNING: Setting sync to false may cause the system being unable to suspend
0843  * in case the PHY generates an interrupt when finishing the autonegotiation.
0844  * This interrupt may wake up the system immediately after suspend.
0845  * Therefore use sync = false only if you're sure it's safe with the respective
0846  * network chip.
0847  */
0848 int phy_speed_down(struct phy_device *phydev, bool sync)
0849 {
0850     __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
0851     int ret;
0852 
0853     if (phydev->autoneg != AUTONEG_ENABLE)
0854         return 0;
0855 
0856     linkmode_copy(adv_tmp, phydev->advertising);
0857 
0858     ret = phy_speed_down_core(phydev);
0859     if (ret)
0860         return ret;
0861 
0862     linkmode_copy(phydev->adv_old, adv_tmp);
0863 
0864     if (linkmode_equal(phydev->advertising, adv_tmp))
0865         return 0;
0866 
0867     ret = phy_config_aneg(phydev);
0868     if (ret)
0869         return ret;
0870 
0871     return sync ? phy_poll_aneg_done(phydev) : 0;
0872 }
0873 EXPORT_SYMBOL_GPL(phy_speed_down);
0874 
0875 /**
0876  * phy_speed_up - (re)set advertised speeds to all supported speeds
0877  * @phydev: the phy_device struct
0878  *
0879  * Description: Used to revert the effect of phy_speed_down
0880  */
0881 int phy_speed_up(struct phy_device *phydev)
0882 {
0883     __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
0884 
0885     if (phydev->autoneg != AUTONEG_ENABLE)
0886         return 0;
0887 
0888     if (linkmode_empty(phydev->adv_old))
0889         return 0;
0890 
0891     linkmode_copy(adv_tmp, phydev->advertising);
0892     linkmode_copy(phydev->advertising, phydev->adv_old);
0893     linkmode_zero(phydev->adv_old);
0894 
0895     if (linkmode_equal(phydev->advertising, adv_tmp))
0896         return 0;
0897 
0898     return phy_config_aneg(phydev);
0899 }
0900 EXPORT_SYMBOL_GPL(phy_speed_up);
0901 
0902 /**
0903  * phy_start_machine - start PHY state machine tracking
0904  * @phydev: the phy_device struct
0905  *
0906  * Description: The PHY infrastructure can run a state machine
0907  *   which tracks whether the PHY is starting up, negotiating,
0908  *   etc.  This function starts the delayed workqueue which tracks
0909  *   the state of the PHY. If you want to maintain your own state machine,
0910  *   do not call this function.
0911  */
0912 void phy_start_machine(struct phy_device *phydev)
0913 {
0914     phy_trigger_machine(phydev);
0915 }
0916 EXPORT_SYMBOL_GPL(phy_start_machine);
0917 
0918 /**
0919  * phy_stop_machine - stop the PHY state machine tracking
0920  * @phydev: target phy_device struct
0921  *
0922  * Description: Stops the state machine delayed workqueue, sets the
0923  *   state to UP (unless it wasn't up yet). This function must be
0924  *   called BEFORE phy_detach.
0925  */
0926 void phy_stop_machine(struct phy_device *phydev)
0927 {
0928     cancel_delayed_work_sync(&phydev->state_queue);
0929 
0930     mutex_lock(&phydev->lock);
0931     if (phy_is_started(phydev))
0932         phydev->state = PHY_UP;
0933     mutex_unlock(&phydev->lock);
0934 }
0935 
0936 /**
0937  * phy_error - enter HALTED state for this PHY device
0938  * @phydev: target phy_device struct
0939  *
0940  * Moves the PHY to the HALTED state in response to a read
0941  * or write error, and tells the controller the link is down.
0942  * Must not be called from interrupt context, or while the
0943  * phydev->lock is held.
0944  */
0945 void phy_error(struct phy_device *phydev)
0946 {
0947     WARN_ON(1);
0948 
0949     mutex_lock(&phydev->lock);
0950     phydev->state = PHY_HALTED;
0951     mutex_unlock(&phydev->lock);
0952 
0953     phy_trigger_machine(phydev);
0954 }
0955 EXPORT_SYMBOL(phy_error);
0956 
0957 /**
0958  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
0959  * @phydev: target phy_device struct
0960  */
0961 int phy_disable_interrupts(struct phy_device *phydev)
0962 {
0963     /* Disable PHY interrupts */
0964     return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
0965 }
0966 
0967 /**
0968  * phy_interrupt - PHY interrupt handler
0969  * @irq: interrupt line
0970  * @phy_dat: phy_device pointer
0971  *
0972  * Description: Handle PHY interrupt
0973  */
0974 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
0975 {
0976     struct phy_device *phydev = phy_dat;
0977     struct phy_driver *drv = phydev->drv;
0978     irqreturn_t ret;
0979 
0980     /* Wakeup interrupts may occur during a system sleep transition.
0981      * Postpone handling until the PHY has resumed.
0982      */
0983     if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
0984         struct net_device *netdev = phydev->attached_dev;
0985 
0986         if (netdev) {
0987             struct device *parent = netdev->dev.parent;
0988 
0989             if (netdev->wol_enabled)
0990                 pm_system_wakeup();
0991             else if (device_may_wakeup(&netdev->dev))
0992                 pm_wakeup_dev_event(&netdev->dev, 0, true);
0993             else if (parent && device_may_wakeup(parent))
0994                 pm_wakeup_dev_event(parent, 0, true);
0995         }
0996 
0997         phydev->irq_rerun = 1;
0998         disable_irq_nosync(irq);
0999         return IRQ_HANDLED;
1000     }
1001 
1002     mutex_lock(&phydev->lock);
1003     ret = drv->handle_interrupt(phydev);
1004     mutex_unlock(&phydev->lock);
1005 
1006     return ret;
1007 }
1008 
1009 /**
1010  * phy_enable_interrupts - Enable the interrupts from the PHY side
1011  * @phydev: target phy_device struct
1012  */
1013 static int phy_enable_interrupts(struct phy_device *phydev)
1014 {
1015     return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1016 }
1017 
1018 /**
1019  * phy_request_interrupt - request and enable interrupt for a PHY device
1020  * @phydev: target phy_device struct
1021  *
1022  * Description: Request and enable the interrupt for the given PHY.
1023  *   If this fails, then we set irq to PHY_POLL.
1024  *   This should only be called with a valid IRQ number.
1025  */
1026 void phy_request_interrupt(struct phy_device *phydev)
1027 {
1028     int err;
1029 
1030     err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1031                    IRQF_ONESHOT | IRQF_SHARED,
1032                    phydev_name(phydev), phydev);
1033     if (err) {
1034         phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1035                 err, phydev->irq);
1036         phydev->irq = PHY_POLL;
1037     } else {
1038         if (phy_enable_interrupts(phydev)) {
1039             phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1040             phy_free_interrupt(phydev);
1041             phydev->irq = PHY_POLL;
1042         }
1043     }
1044 }
1045 EXPORT_SYMBOL(phy_request_interrupt);
1046 
1047 /**
1048  * phy_free_interrupt - disable and free interrupt for a PHY device
1049  * @phydev: target phy_device struct
1050  *
1051  * Description: Disable and free the interrupt for the given PHY.
1052  *   This should only be called with a valid IRQ number.
1053  */
1054 void phy_free_interrupt(struct phy_device *phydev)
1055 {
1056     phy_disable_interrupts(phydev);
1057     free_irq(phydev->irq, phydev);
1058 }
1059 EXPORT_SYMBOL(phy_free_interrupt);
1060 
1061 /**
1062  * phy_stop - Bring down the PHY link, and stop checking the status
1063  * @phydev: target phy_device struct
1064  */
1065 void phy_stop(struct phy_device *phydev)
1066 {
1067     struct net_device *dev = phydev->attached_dev;
1068 
1069     if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1070         WARN(1, "called from state %s\n",
1071              phy_state_to_str(phydev->state));
1072         return;
1073     }
1074 
1075     mutex_lock(&phydev->lock);
1076 
1077     if (phydev->state == PHY_CABLETEST) {
1078         phy_abort_cable_test(phydev);
1079         netif_testing_off(dev);
1080     }
1081 
1082     if (phydev->sfp_bus)
1083         sfp_upstream_stop(phydev->sfp_bus);
1084 
1085     phydev->state = PHY_HALTED;
1086 
1087     mutex_unlock(&phydev->lock);
1088 
1089     phy_state_machine(&phydev->state_queue.work);
1090     phy_stop_machine(phydev);
1091 
1092     /* Cannot call flush_scheduled_work() here as desired because
1093      * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1094      * will not reenable interrupts.
1095      */
1096 }
1097 EXPORT_SYMBOL(phy_stop);
1098 
1099 /**
1100  * phy_start - start or restart a PHY device
1101  * @phydev: target phy_device struct
1102  *
1103  * Description: Indicates the attached device's readiness to
1104  *   handle PHY-related work.  Used during startup to start the
1105  *   PHY, and after a call to phy_stop() to resume operation.
1106  *   Also used to indicate the MDIO bus has cleared an error
1107  *   condition.
1108  */
1109 void phy_start(struct phy_device *phydev)
1110 {
1111     mutex_lock(&phydev->lock);
1112 
1113     if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1114         WARN(1, "called from state %s\n",
1115              phy_state_to_str(phydev->state));
1116         goto out;
1117     }
1118 
1119     if (phydev->sfp_bus)
1120         sfp_upstream_start(phydev->sfp_bus);
1121 
1122     /* if phy was suspended, bring the physical link up again */
1123     __phy_resume(phydev);
1124 
1125     phydev->state = PHY_UP;
1126 
1127     phy_start_machine(phydev);
1128 out:
1129     mutex_unlock(&phydev->lock);
1130 }
1131 EXPORT_SYMBOL(phy_start);
1132 
1133 /**
1134  * phy_state_machine - Handle the state machine
1135  * @work: work_struct that describes the work to be done
1136  */
1137 void phy_state_machine(struct work_struct *work)
1138 {
1139     struct delayed_work *dwork = to_delayed_work(work);
1140     struct phy_device *phydev =
1141             container_of(dwork, struct phy_device, state_queue);
1142     struct net_device *dev = phydev->attached_dev;
1143     bool needs_aneg = false, do_suspend = false;
1144     enum phy_state old_state;
1145     bool finished = false;
1146     int err = 0;
1147 
1148     mutex_lock(&phydev->lock);
1149 
1150     old_state = phydev->state;
1151 
1152     switch (phydev->state) {
1153     case PHY_DOWN:
1154     case PHY_READY:
1155         break;
1156     case PHY_UP:
1157         needs_aneg = true;
1158 
1159         break;
1160     case PHY_NOLINK:
1161     case PHY_RUNNING:
1162         err = phy_check_link_status(phydev);
1163         break;
1164     case PHY_CABLETEST:
1165         err = phydev->drv->cable_test_get_status(phydev, &finished);
1166         if (err) {
1167             phy_abort_cable_test(phydev);
1168             netif_testing_off(dev);
1169             needs_aneg = true;
1170             phydev->state = PHY_UP;
1171             break;
1172         }
1173 
1174         if (finished) {
1175             ethnl_cable_test_finished(phydev);
1176             netif_testing_off(dev);
1177             needs_aneg = true;
1178             phydev->state = PHY_UP;
1179         }
1180         break;
1181     case PHY_HALTED:
1182         if (phydev->link) {
1183             phydev->link = 0;
1184             phy_link_down(phydev);
1185         }
1186         do_suspend = true;
1187         break;
1188     }
1189 
1190     mutex_unlock(&phydev->lock);
1191 
1192     if (needs_aneg)
1193         err = phy_start_aneg(phydev);
1194     else if (do_suspend)
1195         phy_suspend(phydev);
1196 
1197     if (err == -ENODEV)
1198         return;
1199 
1200     if (err < 0)
1201         phy_error(phydev);
1202 
1203     if (old_state != phydev->state) {
1204         phydev_dbg(phydev, "PHY state change %s -> %s\n",
1205                phy_state_to_str(old_state),
1206                phy_state_to_str(phydev->state));
1207         if (phydev->drv && phydev->drv->link_change_notify)
1208             phydev->drv->link_change_notify(phydev);
1209     }
1210 
1211     /* Only re-schedule a PHY state machine change if we are polling the
1212      * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving
1213      * between states from phy_mac_interrupt().
1214      *
1215      * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1216      * state machine would be pointless and possibly error prone when
1217      * called from phy_disconnect() synchronously.
1218      */
1219     mutex_lock(&phydev->lock);
1220     if (phy_polling_mode(phydev) && phy_is_started(phydev))
1221         phy_queue_state_machine(phydev, PHY_STATE_TIME);
1222     mutex_unlock(&phydev->lock);
1223 }
1224 
1225 /**
1226  * phy_mac_interrupt - MAC says the link has changed
1227  * @phydev: phy_device struct with changed link
1228  *
1229  * The MAC layer is able to indicate there has been a change in the PHY link
1230  * status. Trigger the state machine and work a work queue.
1231  */
1232 void phy_mac_interrupt(struct phy_device *phydev)
1233 {
1234     /* Trigger a state machine change */
1235     phy_trigger_machine(phydev);
1236 }
1237 EXPORT_SYMBOL(phy_mac_interrupt);
1238 
1239 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1240 {
1241     linkmode_zero(advertising);
1242 
1243     if (eee_adv & MDIO_EEE_100TX)
1244         linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1245                  advertising);
1246     if (eee_adv & MDIO_EEE_1000T)
1247         linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1248                  advertising);
1249     if (eee_adv & MDIO_EEE_10GT)
1250         linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1251                  advertising);
1252     if (eee_adv & MDIO_EEE_1000KX)
1253         linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1254                  advertising);
1255     if (eee_adv & MDIO_EEE_10GKX4)
1256         linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1257                  advertising);
1258     if (eee_adv & MDIO_EEE_10GKR)
1259         linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1260                  advertising);
1261 }
1262 
1263 /**
1264  * phy_init_eee - init and check the EEE feature
1265  * @phydev: target phy_device struct
1266  * @clk_stop_enable: PHY may stop the clock during LPI
1267  *
1268  * Description: it checks if the Energy-Efficient Ethernet (EEE)
1269  * is supported by looking at the MMD registers 3.20 and 7.60/61
1270  * and it programs the MMD register 3.0 setting the "Clock stop enable"
1271  * bit if required.
1272  */
1273 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1274 {
1275     if (!phydev->drv)
1276         return -EIO;
1277 
1278     /* According to 802.3az,the EEE is supported only in full duplex-mode.
1279      */
1280     if (phydev->duplex == DUPLEX_FULL) {
1281         __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1282         __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1283         __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1284         int eee_lp, eee_cap, eee_adv;
1285         int status;
1286         u32 cap;
1287 
1288         /* Read phy status to properly get the right settings */
1289         status = phy_read_status(phydev);
1290         if (status)
1291             return status;
1292 
1293         /* First check if the EEE ability is supported */
1294         eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1295         if (eee_cap <= 0)
1296             goto eee_exit_err;
1297 
1298         cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1299         if (!cap)
1300             goto eee_exit_err;
1301 
1302         /* Check which link settings negotiated and verify it in
1303          * the EEE advertising registers.
1304          */
1305         eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1306         if (eee_lp <= 0)
1307             goto eee_exit_err;
1308 
1309         eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1310         if (eee_adv <= 0)
1311             goto eee_exit_err;
1312 
1313         mmd_eee_adv_to_linkmode(adv, eee_adv);
1314         mmd_eee_adv_to_linkmode(lp, eee_lp);
1315         linkmode_and(common, adv, lp);
1316 
1317         if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1318             goto eee_exit_err;
1319 
1320         if (clk_stop_enable)
1321             /* Configure the PHY to stop receiving xMII
1322              * clock while it is signaling LPI.
1323              */
1324             phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1325                      MDIO_PCS_CTRL1_CLKSTOP_EN);
1326 
1327         return 0; /* EEE supported */
1328     }
1329 eee_exit_err:
1330     return -EPROTONOSUPPORT;
1331 }
1332 EXPORT_SYMBOL(phy_init_eee);
1333 
1334 /**
1335  * phy_get_eee_err - report the EEE wake error count
1336  * @phydev: target phy_device struct
1337  *
1338  * Description: it is to report the number of time where the PHY
1339  * failed to complete its normal wake sequence.
1340  */
1341 int phy_get_eee_err(struct phy_device *phydev)
1342 {
1343     if (!phydev->drv)
1344         return -EIO;
1345 
1346     return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1347 }
1348 EXPORT_SYMBOL(phy_get_eee_err);
1349 
1350 /**
1351  * phy_ethtool_get_eee - get EEE supported and status
1352  * @phydev: target phy_device struct
1353  * @data: ethtool_eee data
1354  *
1355  * Description: it reportes the Supported/Advertisement/LP Advertisement
1356  * capabilities.
1357  */
1358 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1359 {
1360     int val;
1361 
1362     if (!phydev->drv)
1363         return -EIO;
1364 
1365     /* Get Supported EEE */
1366     val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1367     if (val < 0)
1368         return val;
1369     data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1370 
1371     /* Get advertisement EEE */
1372     val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1373     if (val < 0)
1374         return val;
1375     data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1376     data->eee_enabled = !!data->advertised;
1377 
1378     /* Get LP advertisement EEE */
1379     val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1380     if (val < 0)
1381         return val;
1382     data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1383 
1384     data->eee_active = !!(data->advertised & data->lp_advertised);
1385 
1386     return 0;
1387 }
1388 EXPORT_SYMBOL(phy_ethtool_get_eee);
1389 
1390 /**
1391  * phy_ethtool_set_eee - set EEE supported and status
1392  * @phydev: target phy_device struct
1393  * @data: ethtool_eee data
1394  *
1395  * Description: it is to program the Advertisement EEE register.
1396  */
1397 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1398 {
1399     int cap, old_adv, adv = 0, ret;
1400 
1401     if (!phydev->drv)
1402         return -EIO;
1403 
1404     /* Get Supported EEE */
1405     cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1406     if (cap < 0)
1407         return cap;
1408 
1409     old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1410     if (old_adv < 0)
1411         return old_adv;
1412 
1413     if (data->eee_enabled) {
1414         adv = !data->advertised ? cap :
1415               ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1416         /* Mask prohibited EEE modes */
1417         adv &= ~phydev->eee_broken_modes;
1418     }
1419 
1420     if (old_adv != adv) {
1421         ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1422         if (ret < 0)
1423             return ret;
1424 
1425         /* Restart autonegotiation so the new modes get sent to the
1426          * link partner.
1427          */
1428         if (phydev->autoneg == AUTONEG_ENABLE) {
1429             ret = phy_restart_aneg(phydev);
1430             if (ret < 0)
1431                 return ret;
1432         }
1433     }
1434 
1435     return 0;
1436 }
1437 EXPORT_SYMBOL(phy_ethtool_set_eee);
1438 
1439 /**
1440  * phy_ethtool_set_wol - Configure Wake On LAN
1441  *
1442  * @phydev: target phy_device struct
1443  * @wol: Configuration requested
1444  */
1445 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1446 {
1447     if (phydev->drv && phydev->drv->set_wol)
1448         return phydev->drv->set_wol(phydev, wol);
1449 
1450     return -EOPNOTSUPP;
1451 }
1452 EXPORT_SYMBOL(phy_ethtool_set_wol);
1453 
1454 /**
1455  * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1456  *
1457  * @phydev: target phy_device struct
1458  * @wol: Store the current configuration here
1459  */
1460 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1461 {
1462     if (phydev->drv && phydev->drv->get_wol)
1463         phydev->drv->get_wol(phydev, wol);
1464 }
1465 EXPORT_SYMBOL(phy_ethtool_get_wol);
1466 
1467 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1468                    struct ethtool_link_ksettings *cmd)
1469 {
1470     struct phy_device *phydev = ndev->phydev;
1471 
1472     if (!phydev)
1473         return -ENODEV;
1474 
1475     phy_ethtool_ksettings_get(phydev, cmd);
1476 
1477     return 0;
1478 }
1479 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1480 
1481 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1482                    const struct ethtool_link_ksettings *cmd)
1483 {
1484     struct phy_device *phydev = ndev->phydev;
1485 
1486     if (!phydev)
1487         return -ENODEV;
1488 
1489     return phy_ethtool_ksettings_set(phydev, cmd);
1490 }
1491 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1492 
1493 /**
1494  * phy_ethtool_nway_reset - Restart auto negotiation
1495  * @ndev: Network device to restart autoneg for
1496  */
1497 int phy_ethtool_nway_reset(struct net_device *ndev)
1498 {
1499     struct phy_device *phydev = ndev->phydev;
1500 
1501     if (!phydev)
1502         return -ENODEV;
1503 
1504     if (!phydev->drv)
1505         return -EIO;
1506 
1507     return phy_restart_aneg(phydev);
1508 }
1509 EXPORT_SYMBOL(phy_ethtool_nway_reset);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!