1814 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/* Framework for configuring and reading PHY devices3 * Based on code in sungem_phy.c and gianfar_phy.c4 *5 * Author: Andy Fleming6 *7 * Copyright (c) 2004 Freescale Semiconductor, Inc.8 * Copyright (c) 2006, 2007 Maciej W. Rozycki9 */10 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>21#include <linux/mm.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>31#include <linux/io.h>32#include <linux/uaccess.h>33#include <linux/atomic.h>34#include <linux/suspend.h>35#include <net/netlink.h>36#include <net/genetlink.h>37#include <net/sock.h>38 39#define PHY_STATE_TIME HZ40 41#define PHY_STATE_STR(_state) \42 case PHY_##_state: \43 return __stringify(_state); \44 45static const char *phy_state_to_str(enum phy_state st)46{47 switch (st) {48 PHY_STATE_STR(DOWN)49 PHY_STATE_STR(READY)50 PHY_STATE_STR(UP)51 PHY_STATE_STR(RUNNING)52 PHY_STATE_STR(NOLINK)53 PHY_STATE_STR(CABLETEST)54 PHY_STATE_STR(HALTED)55 PHY_STATE_STR(ERROR)56 }57 58 return NULL;59}60 61static void phy_process_state_change(struct phy_device *phydev,62 enum phy_state old_state)63{64 if (old_state != phydev->state) {65 phydev_dbg(phydev, "PHY state change %s -> %s\n",66 phy_state_to_str(old_state),67 phy_state_to_str(phydev->state));68 if (phydev->drv && phydev->drv->link_change_notify)69 phydev->drv->link_change_notify(phydev);70 }71}72 73static void phy_link_up(struct phy_device *phydev)74{75 phydev->phy_link_change(phydev, true);76 phy_led_trigger_change_speed(phydev);77}78 79static void phy_link_down(struct phy_device *phydev)80{81 phydev->phy_link_change(phydev, false);82 phy_led_trigger_change_speed(phydev);83 WRITE_ONCE(phydev->link_down_events, phydev->link_down_events + 1);84}85 86static const char *phy_pause_str(struct phy_device *phydev)87{88 bool local_pause, local_asym_pause;89 90 if (phydev->autoneg == AUTONEG_DISABLE)91 goto no_pause;92 93 local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,94 phydev->advertising);95 local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,96 phydev->advertising);97 98 if (local_pause && phydev->pause)99 return "rx/tx";100 101 if (local_asym_pause && phydev->asym_pause) {102 if (local_pause)103 return "rx";104 if (phydev->pause)105 return "tx";106 }107 108no_pause:109 return "off";110}111 112/**113 * phy_print_status - Convenience function to print out the current phy status114 * @phydev: the phy_device struct115 */116void phy_print_status(struct phy_device *phydev)117{118 if (phydev->link) {119 netdev_info(phydev->attached_dev,120 "Link is Up - %s/%s %s- flow control %s\n",121 phy_speed_to_str(phydev->speed),122 phy_duplex_to_str(phydev->duplex),123 phydev->downshifted_rate ? "(downshifted) " : "",124 phy_pause_str(phydev));125 } else {126 netdev_info(phydev->attached_dev, "Link is Down\n");127 }128}129EXPORT_SYMBOL(phy_print_status);130 131/**132 * phy_get_rate_matching - determine if rate matching is supported133 * @phydev: The phy device to return rate matching for134 * @iface: The interface mode to use135 *136 * This determines the type of rate matching (if any) that @phy supports137 * using @iface. @iface may be %PHY_INTERFACE_MODE_NA to determine if any138 * interface supports rate matching.139 *140 * Return: The type of rate matching @phy supports for @iface, or141 * %RATE_MATCH_NONE.142 */143int phy_get_rate_matching(struct phy_device *phydev,144 phy_interface_t iface)145{146 int ret = RATE_MATCH_NONE;147 148 if (phydev->drv->get_rate_matching) {149 mutex_lock(&phydev->lock);150 ret = phydev->drv->get_rate_matching(phydev, iface);151 mutex_unlock(&phydev->lock);152 }153 154 return ret;155}156EXPORT_SYMBOL_GPL(phy_get_rate_matching);157 158/**159 * phy_config_interrupt - configure the PHY device for the requested interrupts160 * @phydev: the phy_device struct161 * @interrupts: interrupt flags to configure for this @phydev162 *163 * Returns 0 on success or < 0 on error.164 */165static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)166{167 phydev->interrupts = interrupts ? 1 : 0;168 if (phydev->drv->config_intr)169 return phydev->drv->config_intr(phydev);170 171 return 0;172}173 174/**175 * phy_restart_aneg - restart auto-negotiation176 * @phydev: target phy_device struct177 *178 * Restart the autonegotiation on @phydev. Returns >= 0 on success or179 * negative errno on error.180 */181int phy_restart_aneg(struct phy_device *phydev)182{183 int ret;184 185 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))186 ret = genphy_c45_restart_aneg(phydev);187 else188 ret = genphy_restart_aneg(phydev);189 190 return ret;191}192EXPORT_SYMBOL_GPL(phy_restart_aneg);193 194/**195 * phy_aneg_done - return auto-negotiation status196 * @phydev: target phy_device struct197 *198 * Description: Return the auto-negotiation status from this @phydev199 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation200 * is still pending.201 */202int phy_aneg_done(struct phy_device *phydev)203{204 if (phydev->drv && phydev->drv->aneg_done)205 return phydev->drv->aneg_done(phydev);206 else if (phydev->is_c45)207 return genphy_c45_aneg_done(phydev);208 else209 return genphy_aneg_done(phydev);210}211EXPORT_SYMBOL(phy_aneg_done);212 213/**214 * phy_find_valid - find a PHY setting that matches the requested parameters215 * @speed: desired speed216 * @duplex: desired duplex217 * @supported: mask of supported link modes218 *219 * Locate a supported phy setting that is, in priority order:220 * - an exact match for the specified speed and duplex mode221 * - a match for the specified speed, or slower speed222 * - the slowest supported speed223 * Returns the matched phy_setting entry, or %NULL if no supported phy224 * settings were found.225 */226static const struct phy_setting *227phy_find_valid(int speed, int duplex, unsigned long *supported)228{229 return phy_lookup_setting(speed, duplex, supported, false);230}231 232/**233 * phy_supported_speeds - return all speeds currently supported by a phy device234 * @phy: The phy device to return supported speeds of.235 * @speeds: buffer to store supported speeds in.236 * @size: size of speeds buffer.237 *238 * Description: Returns the number of supported speeds, and fills the speeds239 * buffer with the supported speeds. If speeds buffer is too small to contain240 * all currently supported speeds, will return as many speeds as can fit.241 */242unsigned int phy_supported_speeds(struct phy_device *phy,243 unsigned int *speeds,244 unsigned int size)245{246 return phy_speeds(speeds, size, phy->supported);247}248 249/**250 * phy_check_valid - check if there is a valid PHY setting which matches251 * speed, duplex, and feature mask252 * @speed: speed to match253 * @duplex: duplex to match254 * @features: A mask of the valid settings255 *256 * Description: Returns true if there is a valid setting, false otherwise.257 */258bool phy_check_valid(int speed, int duplex, unsigned long *features)259{260 return !!phy_lookup_setting(speed, duplex, features, true);261}262EXPORT_SYMBOL(phy_check_valid);263 264/**265 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex266 * @phydev: the target phy_device struct267 *268 * Description: Make sure the PHY is set to supported speeds and269 * duplexes. Drop down by one in this order: 1000/FULL,270 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.271 */272static void phy_sanitize_settings(struct phy_device *phydev)273{274 const struct phy_setting *setting;275 276 setting = phy_find_valid(phydev->speed, phydev->duplex,277 phydev->supported);278 if (setting) {279 phydev->speed = setting->speed;280 phydev->duplex = setting->duplex;281 } else {282 /* We failed to find anything (no supported speeds?) */283 phydev->speed = SPEED_UNKNOWN;284 phydev->duplex = DUPLEX_UNKNOWN;285 }286}287 288void phy_ethtool_ksettings_get(struct phy_device *phydev,289 struct ethtool_link_ksettings *cmd)290{291 mutex_lock(&phydev->lock);292 linkmode_copy(cmd->link_modes.supported, phydev->supported);293 linkmode_copy(cmd->link_modes.advertising, phydev->advertising);294 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);295 296 cmd->base.speed = phydev->speed;297 cmd->base.duplex = phydev->duplex;298 cmd->base.master_slave_cfg = phydev->master_slave_get;299 cmd->base.master_slave_state = phydev->master_slave_state;300 cmd->base.rate_matching = phydev->rate_matching;301 if (phydev->interface == PHY_INTERFACE_MODE_MOCA)302 cmd->base.port = PORT_BNC;303 else304 cmd->base.port = phydev->port;305 cmd->base.transceiver = phy_is_internal(phydev) ?306 XCVR_INTERNAL : XCVR_EXTERNAL;307 cmd->base.phy_address = phydev->mdio.addr;308 cmd->base.autoneg = phydev->autoneg;309 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;310 cmd->base.eth_tp_mdix = phydev->mdix;311 mutex_unlock(&phydev->lock);312}313EXPORT_SYMBOL(phy_ethtool_ksettings_get);314 315/**316 * phy_mii_ioctl - generic PHY MII ioctl interface317 * @phydev: the phy_device struct318 * @ifr: &struct ifreq for socket ioctl's319 * @cmd: ioctl cmd to execute320 *321 * Note that this function is currently incompatible with the322 * PHYCONTROL layer. It changes registers without regard to323 * current state. Use at own risk.324 */325int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)326{327 struct mii_ioctl_data *mii_data = if_mii(ifr);328 struct kernel_hwtstamp_config kernel_cfg;329 struct netlink_ext_ack extack = {};330 u16 val = mii_data->val_in;331 bool change_autoneg = false;332 struct hwtstamp_config cfg;333 int prtad, devad;334 int ret;335 336 switch (cmd) {337 case SIOCGMIIPHY:338 mii_data->phy_id = phydev->mdio.addr;339 fallthrough;340 341 case SIOCGMIIREG:342 if (mdio_phy_id_is_c45(mii_data->phy_id)) {343 prtad = mdio_phy_id_prtad(mii_data->phy_id);344 devad = mdio_phy_id_devad(mii_data->phy_id);345 ret = mdiobus_c45_read(phydev->mdio.bus, prtad, devad,346 mii_data->reg_num);347 348 } else {349 ret = mdiobus_read(phydev->mdio.bus, mii_data->phy_id,350 mii_data->reg_num);351 }352 353 if (ret < 0)354 return ret;355 356 mii_data->val_out = ret;357 358 return 0;359 360 case SIOCSMIIREG: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 } else {365 prtad = mii_data->phy_id;366 devad = mii_data->reg_num;367 }368 if (prtad == phydev->mdio.addr) {369 switch (devad) {370 case MII_BMCR:371 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {372 if (phydev->autoneg == AUTONEG_ENABLE)373 change_autoneg = true;374 phydev->autoneg = AUTONEG_DISABLE;375 if (val & BMCR_FULLDPLX)376 phydev->duplex = DUPLEX_FULL;377 else378 phydev->duplex = DUPLEX_HALF;379 if (val & BMCR_SPEED1000)380 phydev->speed = SPEED_1000;381 else if (val & BMCR_SPEED100)382 phydev->speed = SPEED_100;383 else phydev->speed = SPEED_10;384 } else {385 if (phydev->autoneg == AUTONEG_DISABLE)386 change_autoneg = true;387 phydev->autoneg = AUTONEG_ENABLE;388 }389 break;390 case MII_ADVERTISE:391 mii_adv_mod_linkmode_adv_t(phydev->advertising,392 val);393 change_autoneg = true;394 break;395 case MII_CTRL1000:396 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,397 val);398 change_autoneg = true;399 break;400 default:401 /* do nothing */402 break;403 }404 }405 406 if (mdio_phy_id_is_c45(mii_data->phy_id))407 mdiobus_c45_write(phydev->mdio.bus, prtad, devad,408 mii_data->reg_num, val);409 else410 mdiobus_write(phydev->mdio.bus, prtad, devad, val);411 412 if (prtad == phydev->mdio.addr &&413 devad == MII_BMCR &&414 val & BMCR_RESET)415 return phy_init_hw(phydev);416 417 if (change_autoneg)418 return phy_start_aneg(phydev);419 420 return 0;421 422 case SIOCSHWTSTAMP:423 if (phydev->mii_ts && phydev->mii_ts->hwtstamp) {424 if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))425 return -EFAULT;426 427 hwtstamp_config_to_kernel(&kernel_cfg, &cfg);428 ret = phydev->mii_ts->hwtstamp(phydev->mii_ts, &kernel_cfg, &extack);429 if (ret)430 return ret;431 432 hwtstamp_config_from_kernel(&cfg, &kernel_cfg);433 if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)))434 return -EFAULT;435 436 return 0;437 }438 fallthrough;439 440 default:441 return -EOPNOTSUPP;442 }443}444EXPORT_SYMBOL(phy_mii_ioctl);445 446/**447 * phy_do_ioctl - generic ndo_eth_ioctl implementation448 * @dev: the net_device struct449 * @ifr: &struct ifreq for socket ioctl's450 * @cmd: ioctl cmd to execute451 */452int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)453{454 if (!dev->phydev)455 return -ENODEV;456 457 return phy_mii_ioctl(dev->phydev, ifr, cmd);458}459EXPORT_SYMBOL(phy_do_ioctl);460 461/**462 * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first463 *464 * @dev: the net_device struct465 * @ifr: &struct ifreq for socket ioctl's466 * @cmd: ioctl cmd to execute467 *468 * Same as phy_do_ioctl, but ensures that net_device is running before469 * handling the ioctl.470 */471int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)472{473 if (!netif_running(dev))474 return -ENODEV;475 476 return phy_do_ioctl(dev, ifr, cmd);477}478EXPORT_SYMBOL(phy_do_ioctl_running);479 480/**481 * __phy_hwtstamp_get - Get hardware timestamping configuration from PHY482 *483 * @phydev: the PHY device structure484 * @config: structure holding the timestamping configuration485 *486 * Query the PHY device for its current hardware timestamping configuration.487 */488int __phy_hwtstamp_get(struct phy_device *phydev,489 struct kernel_hwtstamp_config *config)490{491 if (!phydev)492 return -ENODEV;493 494 return -EOPNOTSUPP;495}496 497/**498 * __phy_hwtstamp_set - Modify PHY hardware timestamping configuration499 *500 * @phydev: the PHY device structure501 * @config: structure holding the timestamping configuration502 * @extack: netlink extended ack structure, for error reporting503 */504int __phy_hwtstamp_set(struct phy_device *phydev,505 struct kernel_hwtstamp_config *config,506 struct netlink_ext_ack *extack)507{508 if (!phydev)509 return -ENODEV;510 511 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)512 return phydev->mii_ts->hwtstamp(phydev->mii_ts, config, extack);513 514 return -EOPNOTSUPP;515}516 517/**518 * phy_queue_state_machine - Trigger the state machine to run soon519 *520 * @phydev: the phy_device struct521 * @jiffies: Run the state machine after these jiffies522 */523void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)524{525 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,526 jiffies);527}528EXPORT_SYMBOL(phy_queue_state_machine);529 530/**531 * phy_trigger_machine - Trigger the state machine to run now532 *533 * @phydev: the phy_device struct534 */535void phy_trigger_machine(struct phy_device *phydev)536{537 phy_queue_state_machine(phydev, 0);538}539EXPORT_SYMBOL(phy_trigger_machine);540 541static void phy_abort_cable_test(struct phy_device *phydev)542{543 int err;544 545 ethnl_cable_test_finished(phydev);546 547 err = phy_init_hw(phydev);548 if (err)549 phydev_err(phydev, "Error while aborting cable test");550}551 552/**553 * phy_ethtool_get_strings - Get the statistic counter names554 *555 * @phydev: the phy_device struct556 * @data: Where to put the strings557 */558int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)559{560 if (!phydev->drv)561 return -EIO;562 563 mutex_lock(&phydev->lock);564 phydev->drv->get_strings(phydev, data);565 mutex_unlock(&phydev->lock);566 567 return 0;568}569EXPORT_SYMBOL(phy_ethtool_get_strings);570 571/**572 * phy_ethtool_get_sset_count - Get the number of statistic counters573 *574 * @phydev: the phy_device struct575 */576int phy_ethtool_get_sset_count(struct phy_device *phydev)577{578 int ret;579 580 if (!phydev->drv)581 return -EIO;582 583 if (phydev->drv->get_sset_count &&584 phydev->drv->get_strings &&585 phydev->drv->get_stats) {586 mutex_lock(&phydev->lock);587 ret = phydev->drv->get_sset_count(phydev);588 mutex_unlock(&phydev->lock);589 590 return ret;591 }592 593 return -EOPNOTSUPP;594}595EXPORT_SYMBOL(phy_ethtool_get_sset_count);596 597/**598 * phy_ethtool_get_stats - Get the statistic counters599 *600 * @phydev: the phy_device struct601 * @stats: What counters to get602 * @data: Where to store the counters603 */604int phy_ethtool_get_stats(struct phy_device *phydev,605 struct ethtool_stats *stats, u64 *data)606{607 if (!phydev->drv)608 return -EIO;609 610 mutex_lock(&phydev->lock);611 phydev->drv->get_stats(phydev, stats, data);612 mutex_unlock(&phydev->lock);613 614 return 0;615}616EXPORT_SYMBOL(phy_ethtool_get_stats);617 618/**619 * phy_ethtool_get_plca_cfg - Get PLCA RS configuration620 * @phydev: the phy_device struct621 * @plca_cfg: where to store the retrieved configuration622 *623 * Retrieve the PLCA configuration from the PHY. Return 0 on success or a624 * negative value if an error occurred.625 */626int phy_ethtool_get_plca_cfg(struct phy_device *phydev,627 struct phy_plca_cfg *plca_cfg)628{629 int ret;630 631 if (!phydev->drv) {632 ret = -EIO;633 goto out;634 }635 636 if (!phydev->drv->get_plca_cfg) {637 ret = -EOPNOTSUPP;638 goto out;639 }640 641 mutex_lock(&phydev->lock);642 ret = phydev->drv->get_plca_cfg(phydev, plca_cfg);643 644 mutex_unlock(&phydev->lock);645out:646 return ret;647}648 649/**650 * plca_check_valid - Check PLCA configuration before enabling651 * @phydev: the phy_device struct652 * @plca_cfg: current PLCA configuration653 * @extack: extack for reporting useful error messages654 *655 * Checks whether the PLCA and PHY configuration are consistent and it is safe656 * to enable PLCA. Returns 0 on success or a negative value if the PLCA or PHY657 * configuration is not consistent.658 */659static int plca_check_valid(struct phy_device *phydev,660 const struct phy_plca_cfg *plca_cfg,661 struct netlink_ext_ack *extack)662{663 int ret = 0;664 665 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,666 phydev->advertising)) {667 ret = -EOPNOTSUPP;668 NL_SET_ERR_MSG(extack,669 "Point to Multi-Point mode is not enabled");670 } else if (plca_cfg->node_id >= 255) {671 NL_SET_ERR_MSG(extack, "PLCA node ID is not set");672 ret = -EINVAL;673 }674 675 return ret;676}677 678/**679 * phy_ethtool_set_plca_cfg - Set PLCA RS configuration680 * @phydev: the phy_device struct681 * @plca_cfg: new PLCA configuration to apply682 * @extack: extack for reporting useful error messages683 *684 * Sets the PLCA configuration in the PHY. Return 0 on success or a685 * negative value if an error occurred.686 */687int phy_ethtool_set_plca_cfg(struct phy_device *phydev,688 const struct phy_plca_cfg *plca_cfg,689 struct netlink_ext_ack *extack)690{691 struct phy_plca_cfg *curr_plca_cfg;692 int ret;693 694 if (!phydev->drv) {695 ret = -EIO;696 goto out;697 }698 699 if (!phydev->drv->set_plca_cfg ||700 !phydev->drv->get_plca_cfg) {701 ret = -EOPNOTSUPP;702 goto out;703 }704 705 curr_plca_cfg = kmalloc(sizeof(*curr_plca_cfg), GFP_KERNEL);706 if (!curr_plca_cfg) {707 ret = -ENOMEM;708 goto out;709 }710 711 mutex_lock(&phydev->lock);712 713 ret = phydev->drv->get_plca_cfg(phydev, curr_plca_cfg);714 if (ret)715 goto out_drv;716 717 if (curr_plca_cfg->enabled < 0 && plca_cfg->enabled >= 0) {718 NL_SET_ERR_MSG(extack,719 "PHY does not support changing the PLCA 'enable' attribute");720 ret = -EINVAL;721 goto out_drv;722 }723 724 if (curr_plca_cfg->node_id < 0 && plca_cfg->node_id >= 0) {725 NL_SET_ERR_MSG(extack,726 "PHY does not support changing the PLCA 'local node ID' attribute");727 ret = -EINVAL;728 goto out_drv;729 }730 731 if (curr_plca_cfg->node_cnt < 0 && plca_cfg->node_cnt >= 0) {732 NL_SET_ERR_MSG(extack,733 "PHY does not support changing the PLCA 'node count' attribute");734 ret = -EINVAL;735 goto out_drv;736 }737 738 if (curr_plca_cfg->to_tmr < 0 && plca_cfg->to_tmr >= 0) {739 NL_SET_ERR_MSG(extack,740 "PHY does not support changing the PLCA 'TO timer' attribute");741 ret = -EINVAL;742 goto out_drv;743 }744 745 if (curr_plca_cfg->burst_cnt < 0 && plca_cfg->burst_cnt >= 0) {746 NL_SET_ERR_MSG(extack,747 "PHY does not support changing the PLCA 'burst count' attribute");748 ret = -EINVAL;749 goto out_drv;750 }751 752 if (curr_plca_cfg->burst_tmr < 0 && plca_cfg->burst_tmr >= 0) {753 NL_SET_ERR_MSG(extack,754 "PHY does not support changing the PLCA 'burst timer' attribute");755 ret = -EINVAL;756 goto out_drv;757 }758 759 // if enabling PLCA, perform a few sanity checks760 if (plca_cfg->enabled > 0) {761 // allow setting node_id concurrently with enabled762 if (plca_cfg->node_id >= 0)763 curr_plca_cfg->node_id = plca_cfg->node_id;764 765 ret = plca_check_valid(phydev, curr_plca_cfg, extack);766 if (ret)767 goto out_drv;768 }769 770 ret = phydev->drv->set_plca_cfg(phydev, plca_cfg);771 772out_drv:773 kfree(curr_plca_cfg);774 mutex_unlock(&phydev->lock);775out:776 return ret;777}778 779/**780 * phy_ethtool_get_plca_status - Get PLCA RS status information781 * @phydev: the phy_device struct782 * @plca_st: where to store the retrieved status information783 *784 * Retrieve the PLCA status information from the PHY. Return 0 on success or a785 * negative value if an error occurred.786 */787int phy_ethtool_get_plca_status(struct phy_device *phydev,788 struct phy_plca_status *plca_st)789{790 int ret;791 792 if (!phydev->drv) {793 ret = -EIO;794 goto out;795 }796 797 if (!phydev->drv->get_plca_status) {798 ret = -EOPNOTSUPP;799 goto out;800 }801 802 mutex_lock(&phydev->lock);803 ret = phydev->drv->get_plca_status(phydev, plca_st);804 805 mutex_unlock(&phydev->lock);806out:807 return ret;808}809 810/**811 * phy_start_cable_test - Start a cable test812 *813 * @phydev: the phy_device struct814 * @extack: extack for reporting useful error messages815 */816int phy_start_cable_test(struct phy_device *phydev,817 struct netlink_ext_ack *extack)818{819 struct net_device *dev = phydev->attached_dev;820 int err = -ENOMEM;821 822 if (!(phydev->drv &&823 phydev->drv->cable_test_start &&824 phydev->drv->cable_test_get_status)) {825 NL_SET_ERR_MSG(extack,826 "PHY driver does not support cable testing");827 return -EOPNOTSUPP;828 }829 830 mutex_lock(&phydev->lock);831 if (phydev->state == PHY_CABLETEST) {832 NL_SET_ERR_MSG(extack,833 "PHY already performing a test");834 err = -EBUSY;835 goto out;836 }837 838 if (phydev->state < PHY_UP ||839 phydev->state > PHY_CABLETEST) {840 NL_SET_ERR_MSG(extack,841 "PHY not configured. Try setting interface up");842 err = -EBUSY;843 goto out;844 }845 846 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);847 if (err)848 goto out;849 850 /* Mark the carrier down until the test is complete */851 phy_link_down(phydev);852 853 netif_testing_on(dev);854 err = phydev->drv->cable_test_start(phydev);855 if (err) {856 netif_testing_off(dev);857 phy_link_up(phydev);858 goto out_free;859 }860 861 phydev->state = PHY_CABLETEST;862 863 if (phy_polling_mode(phydev))864 phy_trigger_machine(phydev);865 866 mutex_unlock(&phydev->lock);867 868 return 0;869 870out_free:871 ethnl_cable_test_free(phydev);872out:873 mutex_unlock(&phydev->lock);874 875 return err;876}877EXPORT_SYMBOL(phy_start_cable_test);878 879/**880 * phy_start_cable_test_tdr - Start a raw TDR cable test881 *882 * @phydev: the phy_device struct883 * @extack: extack for reporting useful error messages884 * @config: Configuration of the test to run885 */886int phy_start_cable_test_tdr(struct phy_device *phydev,887 struct netlink_ext_ack *extack,888 const struct phy_tdr_config *config)889{890 struct net_device *dev = phydev->attached_dev;891 int err = -ENOMEM;892 893 if (!(phydev->drv &&894 phydev->drv->cable_test_tdr_start &&895 phydev->drv->cable_test_get_status)) {896 NL_SET_ERR_MSG(extack,897 "PHY driver does not support cable test TDR");898 return -EOPNOTSUPP;899 }900 901 mutex_lock(&phydev->lock);902 if (phydev->state == PHY_CABLETEST) {903 NL_SET_ERR_MSG(extack,904 "PHY already performing a test");905 err = -EBUSY;906 goto out;907 }908 909 if (phydev->state < PHY_UP ||910 phydev->state > PHY_CABLETEST) {911 NL_SET_ERR_MSG(extack,912 "PHY not configured. Try setting interface up");913 err = -EBUSY;914 goto out;915 }916 917 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);918 if (err)919 goto out;920 921 /* Mark the carrier down until the test is complete */922 phy_link_down(phydev);923 924 netif_testing_on(dev);925 err = phydev->drv->cable_test_tdr_start(phydev, config);926 if (err) {927 netif_testing_off(dev);928 phy_link_up(phydev);929 goto out_free;930 }931 932 phydev->state = PHY_CABLETEST;933 934 if (phy_polling_mode(phydev))935 phy_trigger_machine(phydev);936 937 mutex_unlock(&phydev->lock);938 939 return 0;940 941out_free:942 ethnl_cable_test_free(phydev);943out:944 mutex_unlock(&phydev->lock);945 946 return err;947}948EXPORT_SYMBOL(phy_start_cable_test_tdr);949 950int phy_config_aneg(struct phy_device *phydev)951{952 if (phydev->drv->config_aneg)953 return phydev->drv->config_aneg(phydev);954 955 /* Clause 45 PHYs that don't implement Clause 22 registers are not956 * allowed to call genphy_config_aneg()957 */958 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))959 return genphy_c45_config_aneg(phydev);960 961 return genphy_config_aneg(phydev);962}963EXPORT_SYMBOL(phy_config_aneg);964 965/**966 * phy_check_link_status - check link status and set state accordingly967 * @phydev: the phy_device struct968 *969 * Description: Check for link and whether autoneg was triggered / is running970 * and set state accordingly971 */972static int phy_check_link_status(struct phy_device *phydev)973{974 int err;975 976 lockdep_assert_held(&phydev->lock);977 978 /* Keep previous state if loopback is enabled because some PHYs979 * report that Link is Down when loopback is enabled.980 */981 if (phydev->loopback_enabled)982 return 0;983 984 err = phy_read_status(phydev);985 if (err)986 return err;987 988 if (phydev->link && phydev->state != PHY_RUNNING) {989 phy_check_downshift(phydev);990 phydev->state = PHY_RUNNING;991 err = genphy_c45_eee_is_active(phydev,992 NULL, NULL, NULL);993 if (err <= 0)994 phydev->enable_tx_lpi = false;995 else996 phydev->enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled;997 998 phy_link_up(phydev);999 } else if (!phydev->link && phydev->state != PHY_NOLINK) {1000 phydev->state = PHY_NOLINK;1001 phydev->enable_tx_lpi = false;1002 phy_link_down(phydev);1003 }1004 1005 return 0;1006}1007 1008/**1009 * _phy_start_aneg - start auto-negotiation for this PHY device1010 * @phydev: the phy_device struct1011 *1012 * Description: Sanitizes the settings (if we're not autonegotiating1013 * them), and then calls the driver's config_aneg function.1014 * If the PHYCONTROL Layer is operating, we change the state to1015 * reflect the beginning of Auto-negotiation or forcing.1016 */1017int _phy_start_aneg(struct phy_device *phydev)1018{1019 int err;1020 1021 lockdep_assert_held(&phydev->lock);1022 1023 if (!phydev->drv)1024 return -EIO;1025 1026 if (AUTONEG_DISABLE == phydev->autoneg)1027 phy_sanitize_settings(phydev);1028 1029 err = phy_config_aneg(phydev);1030 if (err < 0)1031 return err;1032 1033 if (phy_is_started(phydev))1034 err = phy_check_link_status(phydev);1035 1036 return err;1037}1038EXPORT_SYMBOL(_phy_start_aneg);1039 1040/**1041 * phy_start_aneg - start auto-negotiation for this PHY device1042 * @phydev: the phy_device struct1043 *1044 * Description: Sanitizes the settings (if we're not autonegotiating1045 * them), and then calls the driver's config_aneg function.1046 * If the PHYCONTROL Layer is operating, we change the state to1047 * reflect the beginning of Auto-negotiation or forcing.1048 */1049int phy_start_aneg(struct phy_device *phydev)1050{1051 int err;1052 1053 mutex_lock(&phydev->lock);1054 err = _phy_start_aneg(phydev);1055 mutex_unlock(&phydev->lock);1056 1057 return err;1058}1059EXPORT_SYMBOL(phy_start_aneg);1060 1061static int phy_poll_aneg_done(struct phy_device *phydev)1062{1063 unsigned int retries = 100;1064 int ret;1065 1066 do {1067 msleep(100);1068 ret = phy_aneg_done(phydev);1069 } while (!ret && --retries);1070 1071 if (!ret)1072 return -ETIMEDOUT;1073 1074 return ret < 0 ? ret : 0;1075}1076 1077int phy_ethtool_ksettings_set(struct phy_device *phydev,1078 const struct ethtool_link_ksettings *cmd)1079{1080 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);1081 u8 autoneg = cmd->base.autoneg;1082 u8 duplex = cmd->base.duplex;1083 u32 speed = cmd->base.speed;1084 1085 if (cmd->base.phy_address != phydev->mdio.addr)1086 return -EINVAL;1087 1088 linkmode_copy(advertising, cmd->link_modes.advertising);1089 1090 /* We make sure that we don't pass unsupported values in to the PHY */1091 linkmode_and(advertising, advertising, phydev->supported);1092 1093 /* Verify the settings we care about. */1094 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)1095 return -EINVAL;1096 1097 if (autoneg == AUTONEG_ENABLE &&1098 (linkmode_empty(advertising) ||1099 !linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,1100 phydev->supported)))1101 return -EINVAL;1102 1103 if (autoneg == AUTONEG_DISABLE &&1104 ((speed != SPEED_1000 &&1105 speed != SPEED_100 &&1106 speed != SPEED_10) ||1107 (duplex != DUPLEX_HALF &&1108 duplex != DUPLEX_FULL)))1109 return -EINVAL;1110 1111 mutex_lock(&phydev->lock);1112 phydev->autoneg = autoneg;1113 1114 if (autoneg == AUTONEG_DISABLE) {1115 phydev->speed = speed;1116 phydev->duplex = duplex;1117 }1118 1119 linkmode_copy(phydev->advertising, advertising);1120 1121 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,1122 phydev->advertising, autoneg == AUTONEG_ENABLE);1123 1124 phydev->master_slave_set = cmd->base.master_slave_cfg;1125 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;1126 1127 /* Restart the PHY */1128 if (phy_is_started(phydev)) {1129 phydev->state = PHY_UP;1130 phy_trigger_machine(phydev);1131 } else {1132 _phy_start_aneg(phydev);1133 }1134 1135 mutex_unlock(&phydev->lock);1136 return 0;1137}1138EXPORT_SYMBOL(phy_ethtool_ksettings_set);1139 1140/**1141 * phy_speed_down - set speed to lowest speed supported by both link partners1142 * @phydev: the phy_device struct1143 * @sync: perform action synchronously1144 *1145 * Description: Typically used to save energy when waiting for a WoL packet1146 *1147 * WARNING: Setting sync to false may cause the system being unable to suspend1148 * in case the PHY generates an interrupt when finishing the autonegotiation.1149 * This interrupt may wake up the system immediately after suspend.1150 * Therefore use sync = false only if you're sure it's safe with the respective1151 * network chip.1152 */1153int phy_speed_down(struct phy_device *phydev, bool sync)1154{1155 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);1156 int ret = 0;1157 1158 mutex_lock(&phydev->lock);1159 1160 if (phydev->autoneg != AUTONEG_ENABLE)1161 goto out;1162 1163 linkmode_copy(adv_tmp, phydev->advertising);1164 1165 ret = phy_speed_down_core(phydev);1166 if (ret)1167 goto out;1168 1169 linkmode_copy(phydev->adv_old, adv_tmp);1170 1171 if (linkmode_equal(phydev->advertising, adv_tmp)) {1172 ret = 0;1173 goto out;1174 }1175 1176 ret = phy_config_aneg(phydev);1177 if (ret)1178 goto out;1179 1180 ret = sync ? phy_poll_aneg_done(phydev) : 0;1181out:1182 mutex_unlock(&phydev->lock);1183 1184 return ret;1185}1186EXPORT_SYMBOL_GPL(phy_speed_down);1187 1188/**1189 * phy_speed_up - (re)set advertised speeds to all supported speeds1190 * @phydev: the phy_device struct1191 *1192 * Description: Used to revert the effect of phy_speed_down1193 */1194int phy_speed_up(struct phy_device *phydev)1195{1196 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);1197 int ret = 0;1198 1199 mutex_lock(&phydev->lock);1200 1201 if (phydev->autoneg != AUTONEG_ENABLE)1202 goto out;1203 1204 if (linkmode_empty(phydev->adv_old))1205 goto out;1206 1207 linkmode_copy(adv_tmp, phydev->advertising);1208 linkmode_copy(phydev->advertising, phydev->adv_old);1209 linkmode_zero(phydev->adv_old);1210 1211 if (linkmode_equal(phydev->advertising, adv_tmp))1212 goto out;1213 1214 ret = phy_config_aneg(phydev);1215out:1216 mutex_unlock(&phydev->lock);1217 1218 return ret;1219}1220EXPORT_SYMBOL_GPL(phy_speed_up);1221 1222/**1223 * phy_start_machine - start PHY state machine tracking1224 * @phydev: the phy_device struct1225 *1226 * Description: The PHY infrastructure can run a state machine1227 * which tracks whether the PHY is starting up, negotiating,1228 * etc. This function starts the delayed workqueue which tracks1229 * the state of the PHY. If you want to maintain your own state machine,1230 * do not call this function.1231 */1232void phy_start_machine(struct phy_device *phydev)1233{1234 phy_trigger_machine(phydev);1235}1236EXPORT_SYMBOL_GPL(phy_start_machine);1237 1238/**1239 * phy_stop_machine - stop the PHY state machine tracking1240 * @phydev: target phy_device struct1241 *1242 * Description: Stops the state machine delayed workqueue, sets the1243 * state to UP (unless it wasn't up yet). This function must be1244 * called BEFORE phy_detach.1245 */1246void phy_stop_machine(struct phy_device *phydev)1247{1248 cancel_delayed_work_sync(&phydev->state_queue);1249 1250 mutex_lock(&phydev->lock);1251 if (phy_is_started(phydev))1252 phydev->state = PHY_UP;1253 mutex_unlock(&phydev->lock);1254}1255 1256static void phy_process_error(struct phy_device *phydev)1257{1258 /* phydev->lock must be held for the state change to be safe */1259 if (!mutex_is_locked(&phydev->lock))1260 phydev_err(phydev, "PHY-device data unsafe context\n");1261 1262 phydev->state = PHY_ERROR;1263 1264 phy_trigger_machine(phydev);1265}1266 1267static void phy_error_precise(struct phy_device *phydev,1268 const void *func, int err)1269{1270 WARN(1, "%pS: returned: %d\n", func, err);1271 phy_process_error(phydev);1272}1273 1274/**1275 * phy_error - enter ERROR state for this PHY device1276 * @phydev: target phy_device struct1277 *1278 * Moves the PHY to the ERROR state in response to a read1279 * or write error, and tells the controller the link is down.1280 * Must be called with phydev->lock held.1281 */1282void phy_error(struct phy_device *phydev)1283{1284 WARN_ON(1);1285 phy_process_error(phydev);1286}1287EXPORT_SYMBOL(phy_error);1288 1289/**1290 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side1291 * @phydev: target phy_device struct1292 */1293int phy_disable_interrupts(struct phy_device *phydev)1294{1295 /* Disable PHY interrupts */1296 return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);1297}1298 1299/**1300 * phy_interrupt - PHY interrupt handler1301 * @irq: interrupt line1302 * @phy_dat: phy_device pointer1303 *1304 * Description: Handle PHY interrupt1305 */1306static irqreturn_t phy_interrupt(int irq, void *phy_dat)1307{1308 struct phy_device *phydev = phy_dat;1309 irqreturn_t ret;1310 1311 /* Wakeup interrupts may occur during a system sleep transition.1312 * Postpone handling until the PHY has resumed.1313 */1314 if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {1315 struct net_device *netdev = phydev->attached_dev;1316 1317 if (netdev) {1318 struct device *parent = netdev->dev.parent;1319 1320 if (netdev->ethtool->wol_enabled)1321 pm_system_wakeup();1322 else if (device_may_wakeup(&netdev->dev))1323 pm_wakeup_dev_event(&netdev->dev, 0, true);1324 else if (parent && device_may_wakeup(parent))1325 pm_wakeup_dev_event(parent, 0, true);1326 }1327 1328 phydev->irq_rerun = 1;1329 disable_irq_nosync(irq);1330 return IRQ_HANDLED;1331 }1332 1333 mutex_lock(&phydev->lock);1334 ret = phydev->drv->handle_interrupt(phydev);1335 mutex_unlock(&phydev->lock);1336 1337 return ret;1338}1339 1340/**1341 * phy_enable_interrupts - Enable the interrupts from the PHY side1342 * @phydev: target phy_device struct1343 */1344static int phy_enable_interrupts(struct phy_device *phydev)1345{1346 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);1347}1348 1349/**1350 * phy_request_interrupt - request and enable interrupt for a PHY device1351 * @phydev: target phy_device struct1352 *1353 * Description: Request and enable the interrupt for the given PHY.1354 * If this fails, then we set irq to PHY_POLL.1355 * This should only be called with a valid IRQ number.1356 */1357void phy_request_interrupt(struct phy_device *phydev)1358{1359 int err;1360 1361 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,1362 IRQF_ONESHOT | IRQF_SHARED,1363 phydev_name(phydev), phydev);1364 if (err) {1365 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",1366 err, phydev->irq);1367 phydev->irq = PHY_POLL;1368 } else {1369 if (phy_enable_interrupts(phydev)) {1370 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");1371 phy_free_interrupt(phydev);1372 phydev->irq = PHY_POLL;1373 }1374 }1375}1376EXPORT_SYMBOL(phy_request_interrupt);1377 1378/**1379 * phy_free_interrupt - disable and free interrupt for a PHY device1380 * @phydev: target phy_device struct1381 *1382 * Description: Disable and free the interrupt for the given PHY.1383 * This should only be called with a valid IRQ number.1384 */1385void phy_free_interrupt(struct phy_device *phydev)1386{1387 phy_disable_interrupts(phydev);1388 free_irq(phydev->irq, phydev);1389}1390EXPORT_SYMBOL(phy_free_interrupt);1391 1392enum phy_state_work {1393 PHY_STATE_WORK_NONE,1394 PHY_STATE_WORK_ANEG,1395 PHY_STATE_WORK_SUSPEND,1396};1397 1398static enum phy_state_work _phy_state_machine(struct phy_device *phydev)1399{1400 enum phy_state_work state_work = PHY_STATE_WORK_NONE;1401 struct net_device *dev = phydev->attached_dev;1402 enum phy_state old_state = phydev->state;1403 const void *func = NULL;1404 bool finished = false;1405 int err = 0;1406 1407 switch (phydev->state) {1408 case PHY_DOWN:1409 case PHY_READY:1410 break;1411 case PHY_UP:1412 state_work = PHY_STATE_WORK_ANEG;1413 break;1414 case PHY_NOLINK:1415 case PHY_RUNNING:1416 err = phy_check_link_status(phydev);1417 func = &phy_check_link_status;1418 break;1419 case PHY_CABLETEST:1420 err = phydev->drv->cable_test_get_status(phydev, &finished);1421 if (err) {1422 phy_abort_cable_test(phydev);1423 netif_testing_off(dev);1424 state_work = PHY_STATE_WORK_ANEG;1425 phydev->state = PHY_UP;1426 break;1427 }1428 1429 if (finished) {1430 ethnl_cable_test_finished(phydev);1431 netif_testing_off(dev);1432 state_work = PHY_STATE_WORK_ANEG;1433 phydev->state = PHY_UP;1434 }1435 break;1436 case PHY_HALTED:1437 case PHY_ERROR:1438 if (phydev->link) {1439 phydev->link = 0;1440 phy_link_down(phydev);1441 }1442 state_work = PHY_STATE_WORK_SUSPEND;1443 break;1444 }1445 1446 if (state_work == PHY_STATE_WORK_ANEG) {1447 err = _phy_start_aneg(phydev);1448 func = &_phy_start_aneg;1449 }1450 1451 if (err == -ENODEV)1452 return state_work;1453 1454 if (err < 0)1455 phy_error_precise(phydev, func, err);1456 1457 phy_process_state_change(phydev, old_state);1458 1459 /* Only re-schedule a PHY state machine change if we are polling the1460 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving1461 * between states from phy_mac_interrupt().1462 *1463 * In state PHY_HALTED the PHY gets suspended, so rescheduling the1464 * state machine would be pointless and possibly error prone when1465 * called from phy_disconnect() synchronously.1466 */1467 if (phy_polling_mode(phydev) && phy_is_started(phydev))1468 phy_queue_state_machine(phydev, PHY_STATE_TIME);1469 1470 return state_work;1471}1472 1473/* unlocked part of the PHY state machine */1474static void _phy_state_machine_post_work(struct phy_device *phydev,1475 enum phy_state_work state_work)1476{1477 if (state_work == PHY_STATE_WORK_SUSPEND)1478 phy_suspend(phydev);1479}1480 1481/**1482 * phy_state_machine - Handle the state machine1483 * @work: work_struct that describes the work to be done1484 */1485void phy_state_machine(struct work_struct *work)1486{1487 struct delayed_work *dwork = to_delayed_work(work);1488 struct phy_device *phydev =1489 container_of(dwork, struct phy_device, state_queue);1490 enum phy_state_work state_work;1491 1492 mutex_lock(&phydev->lock);1493 state_work = _phy_state_machine(phydev);1494 mutex_unlock(&phydev->lock);1495 1496 _phy_state_machine_post_work(phydev, state_work);1497}1498 1499/**1500 * phy_stop - Bring down the PHY link, and stop checking the status1501 * @phydev: target phy_device struct1502 */1503void phy_stop(struct phy_device *phydev)1504{1505 struct net_device *dev = phydev->attached_dev;1506 enum phy_state_work state_work;1507 enum phy_state old_state;1508 1509 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN &&1510 phydev->state != PHY_ERROR) {1511 WARN(1, "called from state %s\n",1512 phy_state_to_str(phydev->state));1513 return;1514 }1515 1516 mutex_lock(&phydev->lock);1517 old_state = phydev->state;1518 1519 if (phydev->state == PHY_CABLETEST) {1520 phy_abort_cable_test(phydev);1521 netif_testing_off(dev);1522 }1523 1524 if (phydev->sfp_bus)1525 sfp_upstream_stop(phydev->sfp_bus);1526 1527 phydev->state = PHY_HALTED;1528 phy_process_state_change(phydev, old_state);1529 1530 state_work = _phy_state_machine(phydev);1531 mutex_unlock(&phydev->lock);1532 1533 _phy_state_machine_post_work(phydev, state_work);1534 phy_stop_machine(phydev);1535 1536 /* Cannot call flush_scheduled_work() here as desired because1537 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler1538 * will not reenable interrupts.1539 */1540}1541EXPORT_SYMBOL(phy_stop);1542 1543/**1544 * phy_start - start or restart a PHY device1545 * @phydev: target phy_device struct1546 *1547 * Description: Indicates the attached device's readiness to1548 * handle PHY-related work. Used during startup to start the1549 * PHY, and after a call to phy_stop() to resume operation.1550 * Also used to indicate the MDIO bus has cleared an error1551 * condition.1552 */1553void phy_start(struct phy_device *phydev)1554{1555 mutex_lock(&phydev->lock);1556 1557 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {1558 WARN(1, "called from state %s\n",1559 phy_state_to_str(phydev->state));1560 goto out;1561 }1562 1563 if (phydev->sfp_bus)1564 sfp_upstream_start(phydev->sfp_bus);1565 1566 /* if phy was suspended, bring the physical link up again */1567 __phy_resume(phydev);1568 1569 phydev->state = PHY_UP;1570 1571 phy_start_machine(phydev);1572out:1573 mutex_unlock(&phydev->lock);1574}1575EXPORT_SYMBOL(phy_start);1576 1577/**1578 * phy_mac_interrupt - MAC says the link has changed1579 * @phydev: phy_device struct with changed link1580 *1581 * The MAC layer is able to indicate there has been a change in the PHY link1582 * status. Trigger the state machine and work a work queue.1583 */1584void phy_mac_interrupt(struct phy_device *phydev)1585{1586 /* Trigger a state machine change */1587 phy_trigger_machine(phydev);1588}1589EXPORT_SYMBOL(phy_mac_interrupt);1590 1591/**1592 * phy_init_eee - init and check the EEE feature1593 * @phydev: target phy_device struct1594 * @clk_stop_enable: PHY may stop the clock during LPI1595 *1596 * Description: it checks if the Energy-Efficient Ethernet (EEE)1597 * is supported by looking at the MMD registers 3.20 and 7.60/611598 * and it programs the MMD register 3.0 setting the "Clock stop enable"1599 * bit if required.1600 */1601int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)1602{1603 int ret;1604 1605 if (!phydev->drv)1606 return -EIO;1607 1608 ret = genphy_c45_eee_is_active(phydev, NULL, NULL, NULL);1609 if (ret < 0)1610 return ret;1611 if (!ret)1612 return -EPROTONOSUPPORT;1613 1614 if (clk_stop_enable)1615 /* Configure the PHY to stop receiving xMII1616 * clock while it is signaling LPI.1617 */1618 ret = phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,1619 MDIO_PCS_CTRL1_CLKSTOP_EN);1620 1621 return ret < 0 ? ret : 0;1622}1623EXPORT_SYMBOL(phy_init_eee);1624 1625/**1626 * phy_get_eee_err - report the EEE wake error count1627 * @phydev: target phy_device struct1628 *1629 * Description: it is to report the number of time where the PHY1630 * failed to complete its normal wake sequence.1631 */1632int phy_get_eee_err(struct phy_device *phydev)1633{1634 int ret;1635 1636 if (!phydev->drv)1637 return -EIO;1638 1639 mutex_lock(&phydev->lock);1640 ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);1641 mutex_unlock(&phydev->lock);1642 1643 return ret;1644}1645EXPORT_SYMBOL(phy_get_eee_err);1646 1647/**1648 * phy_ethtool_get_eee - get EEE supported and status1649 * @phydev: target phy_device struct1650 * @data: ethtool_keee data1651 *1652 * Description: reports the Supported/Advertisement/LP Advertisement1653 * capabilities, etc.1654 */1655int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)1656{1657 int ret;1658 1659 if (!phydev->drv)1660 return -EIO;1661 1662 mutex_lock(&phydev->lock);1663 ret = genphy_c45_ethtool_get_eee(phydev, data);1664 eeecfg_to_eee(data, &phydev->eee_cfg);1665 mutex_unlock(&phydev->lock);1666 1667 return ret;1668}1669EXPORT_SYMBOL(phy_ethtool_get_eee);1670 1671/**1672 * phy_ethtool_set_eee_noneg - Adjusts MAC LPI configuration without PHY1673 * renegotiation1674 * @phydev: pointer to the target PHY device structure1675 * @data: pointer to the ethtool_keee structure containing the new EEE settings1676 *1677 * This function updates the Energy Efficient Ethernet (EEE) configuration1678 * for cases where only the MAC's Low Power Idle (LPI) configuration changes,1679 * without triggering PHY renegotiation. It ensures that the MAC is properly1680 * informed of the new LPI settings by cycling the link down and up, which1681 * is necessary for the MAC to adopt the new configuration. This adjustment1682 * is done only if there is a change in the tx_lpi_enabled or tx_lpi_timer1683 * configuration.1684 */1685static void phy_ethtool_set_eee_noneg(struct phy_device *phydev,1686 struct ethtool_keee *data)1687{1688 if (phydev->eee_cfg.tx_lpi_enabled != data->tx_lpi_enabled ||1689 phydev->eee_cfg.tx_lpi_timer != data->tx_lpi_timer) {1690 eee_to_eeecfg(&phydev->eee_cfg, data);1691 phydev->enable_tx_lpi = eeecfg_mac_can_tx_lpi(&phydev->eee_cfg);1692 if (phydev->link) {1693 phydev->link = false;1694 phy_link_down(phydev);1695 phydev->link = true;1696 phy_link_up(phydev);1697 }1698 }1699}1700 1701/**1702 * phy_ethtool_set_eee - set EEE supported and status1703 * @phydev: target phy_device struct1704 * @data: ethtool_keee data1705 *1706 * Description: it is to program the Advertisement EEE register.1707 */1708int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)1709{1710 int ret;1711 1712 if (!phydev->drv)1713 return -EIO;1714 1715 mutex_lock(&phydev->lock);1716 ret = genphy_c45_ethtool_set_eee(phydev, data);1717 if (ret >= 0) {1718 if (ret == 0)1719 phy_ethtool_set_eee_noneg(phydev, data);1720 eee_to_eeecfg(&phydev->eee_cfg, data);1721 }1722 mutex_unlock(&phydev->lock);1723 1724 return ret < 0 ? ret : 0;1725}1726EXPORT_SYMBOL(phy_ethtool_set_eee);1727 1728/**1729 * phy_ethtool_set_wol - Configure Wake On LAN1730 *1731 * @phydev: target phy_device struct1732 * @wol: Configuration requested1733 */1734int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)1735{1736 int ret;1737 1738 if (phydev->drv && phydev->drv->set_wol) {1739 mutex_lock(&phydev->lock);1740 ret = phydev->drv->set_wol(phydev, wol);1741 mutex_unlock(&phydev->lock);1742 1743 return ret;1744 }1745 1746 return -EOPNOTSUPP;1747}1748EXPORT_SYMBOL(phy_ethtool_set_wol);1749 1750/**1751 * phy_ethtool_get_wol - Get the current Wake On LAN configuration1752 *1753 * @phydev: target phy_device struct1754 * @wol: Store the current configuration here1755 */1756void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)1757{1758 if (phydev->drv && phydev->drv->get_wol) {1759 mutex_lock(&phydev->lock);1760 phydev->drv->get_wol(phydev, wol);1761 mutex_unlock(&phydev->lock);1762 }1763}1764EXPORT_SYMBOL(phy_ethtool_get_wol);1765 1766int phy_ethtool_get_link_ksettings(struct net_device *ndev,1767 struct ethtool_link_ksettings *cmd)1768{1769 struct phy_device *phydev = ndev->phydev;1770 1771 if (!phydev)1772 return -ENODEV;1773 1774 phy_ethtool_ksettings_get(phydev, cmd);1775 1776 return 0;1777}1778EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);1779 1780int phy_ethtool_set_link_ksettings(struct net_device *ndev,1781 const struct ethtool_link_ksettings *cmd)1782{1783 struct phy_device *phydev = ndev->phydev;1784 1785 if (!phydev)1786 return -ENODEV;1787 1788 return phy_ethtool_ksettings_set(phydev, cmd);1789}1790EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);1791 1792/**1793 * phy_ethtool_nway_reset - Restart auto negotiation1794 * @ndev: Network device to restart autoneg for1795 */1796int phy_ethtool_nway_reset(struct net_device *ndev)1797{1798 struct phy_device *phydev = ndev->phydev;1799 int ret;1800 1801 if (!phydev)1802 return -ENODEV;1803 1804 if (!phydev->drv)1805 return -EIO;1806 1807 mutex_lock(&phydev->lock);1808 ret = phy_restart_aneg(phydev);1809 mutex_unlock(&phydev->lock);1810 1811 return ret;1812}1813EXPORT_SYMBOL(phy_ethtool_nway_reset);1814