drivers/net/phy/phy.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /* Framework for configuring and reading PHY devices
   3  * Based on code in sungem_phy.c and gianfar_phy.c
   4  *
   5  * Author: Andy Fleming
   6  *
   7  * Copyright (c) 2004 Freescale Semiconductor, Inc.
   8  * Copyright (c) 2006, 2007  Maciej W. Rozycki
   9  */
  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 <net/netlink.h>
  35 #include <net/genetlink.h>
  36 #include <net/sock.h>
  37
  38 #define PHY_STATE_TIME  HZ
  39
  40 #define PHY_STATE_STR(_state)                   \
  41         case PHY_##_state:                      \
  42                 return __stringify(_state);     \
  43
  44 static const char *phy_state_to_str(enum phy_state st)
  45 {
  46         switch (st) {
  47         PHY_STATE_STR(DOWN)
  48         PHY_STATE_STR(READY)
  49         PHY_STATE_STR(UP)
  50         PHY_STATE_STR(RUNNING)
  51         PHY_STATE_STR(NOLINK)
  52         PHY_STATE_STR(CABLETEST)
  53         PHY_STATE_STR(HALTED)
  54         }
  55
  56         return NULL;
  57 }
  58
  59 static void phy_link_up(struct phy_device *phydev)
  60 {
  61         phydev->phy_link_change(phydev, true);
  62         phy_led_trigger_change_speed(phydev);
  63 }
  64
  65 static void phy_link_down(struct phy_device *phydev)
  66 {
  67         phydev->phy_link_change(phydev, false);
  68         phy_led_trigger_change_speed(phydev);
  69 }
  70
  71 static const char *phy_pause_str(struct phy_device *phydev)
  72 {
  73         bool local_pause, local_asym_pause;
  74
  75         if (phydev->autoneg == AUTONEG_DISABLE)
  76                 goto no_pause;
  77
  78         local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
  79                                         phydev->advertising);
  80         local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
  81                                              phydev->advertising);
  82
  83         if (local_pause && phydev->pause)
  84                 return "rx/tx";
  85
  86         if (local_asym_pause && phydev->asym_pause) {
  87                 if (local_pause)
  88                         return "rx";
  89                 if (phydev->pause)
  90                         return "tx";
  91         }
  92
  93 no_pause:
  94         return "off";
  95 }
  96
  97 /**
  98  * phy_print_status - Convenience function to print out the current phy status
  99  * @phydev: the phy_device struct
 100  */
 101 void phy_print_status(struct phy_device *phydev)
 102 {
 103         if (phydev->link) {
 104                 netdev_info(phydev->attached_dev,
 105                         "Link is Up - %s/%s %s- flow control %s\n",
 106                         phy_speed_to_str(phydev->speed),
 107                         phy_duplex_to_str(phydev->duplex),
 108                         phydev->downshifted_rate ? "(downshifted) " : "",
 109                         phy_pause_str(phydev));
 110         } else  {
 111                 netdev_info(phydev->attached_dev, "Link is Down\n");
 112         }
 113 }
 114 EXPORT_SYMBOL(phy_print_status);
 115
 116 /**
 117  * phy_clear_interrupt - Ack the phy device's interrupt
 118  * @phydev: the phy_device struct
 119  *
 120  * If the @phydev driver has an ack_interrupt function, call it to
 121  * ack and clear the phy device's interrupt.
 122  *
 123  * Returns 0 on success or < 0 on error.
 124  */
 125 static int phy_clear_interrupt(struct phy_device *phydev)
 126 {
 127         int ret = 0;
 128
 129         if (phydev->drv->ack_interrupt) {
 130                 mutex_lock(&phydev->lock);
 131                 ret = phydev->drv->ack_interrupt(phydev);
 132                 mutex_unlock(&phydev->lock);
 133         }
 134
 135         return ret;
 136 }
 137
 138 /**
 139  * phy_config_interrupt - configure the PHY device for the requested interrupts
 140  * @phydev: the phy_device struct
 141  * @interrupts: interrupt flags to configure for this @phydev
 142  *
 143  * Returns 0 on success or < 0 on error.
 144  */
 145 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts)
 146 {
 147         phydev->interrupts = interrupts ? 1 : 0;
 148         if (phydev->drv->config_intr)
 149                 return phydev->drv->config_intr(phydev);
 150
 151         return 0;
 152 }
 153
 154 /**
 155  * phy_restart_aneg - restart auto-negotiation
 156  * @phydev: target phy_device struct
 157  *
 158  * Restart the autonegotiation on @phydev.  Returns >= 0 on success or
 159  * negative errno on error.
 160  */
 161 int phy_restart_aneg(struct phy_device *phydev)
 162 {
 163         int ret;
 164
 165         if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
 166                 ret = genphy_c45_restart_aneg(phydev);
 167         else
 168                 ret = genphy_restart_aneg(phydev);
 169
 170         return ret;
 171 }
 172 EXPORT_SYMBOL_GPL(phy_restart_aneg);
 173
 174 /**
 175  * phy_aneg_done - return auto-negotiation status
 176  * @phydev: target phy_device struct
 177  *
 178  * Description: Return the auto-negotiation status from this @phydev
 179  * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation
 180  * is still pending.
 181  */
 182 int phy_aneg_done(struct phy_device *phydev)
 183 {
 184         if (phydev->drv && phydev->drv->aneg_done)
 185                 return phydev->drv->aneg_done(phydev);
 186         else if (phydev->is_c45)
 187                 return genphy_c45_aneg_done(phydev);
 188         else
 189                 return genphy_aneg_done(phydev);
 190 }
 191 EXPORT_SYMBOL(phy_aneg_done);
 192
 193 /**
 194  * phy_find_valid - find a PHY setting that matches the requested parameters
 195  * @speed: desired speed
 196  * @duplex: desired duplex
 197  * @supported: mask of supported link modes
 198  *
 199  * Locate a supported phy setting that is, in priority order:
 200  * - an exact match for the specified speed and duplex mode
 201  * - a match for the specified speed, or slower speed
 202  * - the slowest supported speed
 203  * Returns the matched phy_setting entry, or %NULL if no supported phy
 204  * settings were found.
 205  */
 206 static const struct phy_setting *
 207 phy_find_valid(int speed, int duplex, unsigned long *supported)
 208 {
 209         return phy_lookup_setting(speed, duplex, supported, false);
 210 }
 211
 212 /**
 213  * phy_supported_speeds - return all speeds currently supported by a phy device
 214  * @phy: The phy device to return supported speeds of.
 215  * @speeds: buffer to store supported speeds in.
 216  * @size:   size of speeds buffer.
 217  *
 218  * Description: Returns the number of supported speeds, and fills the speeds
 219  * buffer with the supported speeds. If speeds buffer is too small to contain
 220  * all currently supported speeds, will return as many speeds as can fit.
 221  */
 222 unsigned int phy_supported_speeds(struct phy_device *phy,
 223                                   unsigned int *speeds,
 224                                   unsigned int size)
 225 {
 226         return phy_speeds(speeds, size, phy->supported);
 227 }
 228
 229 /**
 230  * phy_check_valid - check if there is a valid PHY setting which matches
 231  *                   speed, duplex, and feature mask
 232  * @speed: speed to match
 233  * @duplex: duplex to match
 234  * @features: A mask of the valid settings
 235  *
 236  * Description: Returns true if there is a valid setting, false otherwise.
 237  */
 238 static inline bool phy_check_valid(int speed, int duplex,
 239                                    unsigned long *features)
 240 {
 241         return !!phy_lookup_setting(speed, duplex, features, true);
 242 }
 243
 244 /**
 245  * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex
 246  * @phydev: the target phy_device struct
 247  *
 248  * Description: Make sure the PHY is set to supported speeds and
 249  *   duplexes.  Drop down by one in this order:  1000/FULL,
 250  *   1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF.
 251  */
 252 static void phy_sanitize_settings(struct phy_device *phydev)
 253 {
 254         const struct phy_setting *setting;
 255
 256         setting = phy_find_valid(phydev->speed, phydev->duplex,
 257                                  phydev->supported);
 258         if (setting) {
 259                 phydev->speed = setting->speed;
 260                 phydev->duplex = setting->duplex;
 261         } else {
 262                 /* We failed to find anything (no supported speeds?) */
 263                 phydev->speed = SPEED_UNKNOWN;
 264                 phydev->duplex = DUPLEX_UNKNOWN;
 265         }
 266 }
 267
 268 void phy_ethtool_ksettings_get(struct phy_device *phydev,
 269                                struct ethtool_link_ksettings *cmd)
 270 {
 271         mutex_lock(&phydev->lock);
 272         linkmode_copy(cmd->link_modes.supported, phydev->supported);
 273         linkmode_copy(cmd->link_modes.advertising, phydev->advertising);
 274         linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising);
 275
 276         cmd->base.speed = phydev->speed;
 277         cmd->base.duplex = phydev->duplex;
 278         cmd->base.master_slave_cfg = phydev->master_slave_get;
 279         cmd->base.master_slave_state = phydev->master_slave_state;
 280         if (phydev->interface == PHY_INTERFACE_MODE_MOCA)
 281                 cmd->base.port = PORT_BNC;
 282         else
 283                 cmd->base.port = phydev->port;
 284         cmd->base.transceiver = phy_is_internal(phydev) ?
 285                                 XCVR_INTERNAL : XCVR_EXTERNAL;
 286         cmd->base.phy_address = phydev->mdio.addr;
 287         cmd->base.autoneg = phydev->autoneg;
 288         cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl;
 289         cmd->base.eth_tp_mdix = phydev->mdix;
 290         mutex_unlock(&phydev->lock);
 291 }
 292 EXPORT_SYMBOL(phy_ethtool_ksettings_get);
 293
 294 /**
 295  * phy_mii_ioctl - generic PHY MII ioctl interface
 296  * @phydev: the phy_device struct
 297  * @ifr: &struct ifreq for socket ioctl's
 298  * @cmd: ioctl cmd to execute
 299  *
 300  * Note that this function is currently incompatible with the
 301  * PHYCONTROL layer.  It changes registers without regard to
 302  * current state.  Use at own risk.
 303  */
 304 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)
 305 {
 306         struct mii_ioctl_data *mii_data = if_mii(ifr);
 307         u16 val = mii_data->val_in;
 308         bool change_autoneg = false;
 309         int prtad, devad;
 310
 311         switch (cmd) {
 312         case SIOCGMIIPHY:
 313                 mii_data->phy_id = phydev->mdio.addr;
 314                 fallthrough;
 315
 316         case SIOCGMIIREG:
 317                 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
 318                         prtad = mdio_phy_id_prtad(mii_data->phy_id);
 319                         devad = mdio_phy_id_devad(mii_data->phy_id);
 320                         devad = mdiobus_c45_addr(devad, mii_data->reg_num);
 321                 } else {
 322                         prtad = mii_data->phy_id;
 323                         devad = mii_data->reg_num;
 324                 }
 325                 mii_data->val_out = mdiobus_read(phydev->mdio.bus, prtad,
 326                                                  devad);
 327                 return 0;
 328
 329         case SIOCSMIIREG:
 330                 if (mdio_phy_id_is_c45(mii_data->phy_id)) {
 331                         prtad = mdio_phy_id_prtad(mii_data->phy_id);
 332                         devad = mdio_phy_id_devad(mii_data->phy_id);
 333                         devad = mdiobus_c45_addr(devad, mii_data->reg_num);
 334                 } else {
 335                         prtad = mii_data->phy_id;
 336                         devad = mii_data->reg_num;
 337                 }
 338                 if (prtad == phydev->mdio.addr) {
 339                         switch (devad) {
 340                         case MII_BMCR:
 341                                 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) {
 342                                         if (phydev->autoneg == AUTONEG_ENABLE)
 343                                                 change_autoneg = true;
 344                                         phydev->autoneg = AUTONEG_DISABLE;
 345                                         if (val & BMCR_FULLDPLX)
 346                                                 phydev->duplex = DUPLEX_FULL;
 347                                         else
 348                                                 phydev->duplex = DUPLEX_HALF;
 349                                         if (val & BMCR_SPEED1000)
 350                                                 phydev->speed = SPEED_1000;
 351                                         else if (val & BMCR_SPEED100)
 352                                                 phydev->speed = SPEED_100;
 353                                         else phydev->speed = SPEED_10;
 354                                 }
 355                                 else {
 356                                         if (phydev->autoneg == AUTONEG_DISABLE)
 357                                                 change_autoneg = true;
 358                                         phydev->autoneg = AUTONEG_ENABLE;
 359                                 }
 360                                 break;
 361                         case MII_ADVERTISE:
 362                                 mii_adv_mod_linkmode_adv_t(phydev->advertising,
 363                                                            val);
 364                                 change_autoneg = true;
 365                                 break;
 366                         case MII_CTRL1000:
 367                                 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising,
 368                                                                 val);
 369                                 change_autoneg = true;
 370                                 break;
 371                         default:
 372                                 /* do nothing */
 373                                 break;
 374                         }
 375                 }
 376
 377                 mdiobus_write(phydev->mdio.bus, prtad, devad, val);
 378
 379                 if (prtad == phydev->mdio.addr &&
 380                     devad == MII_BMCR &&
 381                     val & BMCR_RESET)
 382                         return phy_init_hw(phydev);
 383
 384                 if (change_autoneg)
 385                         return phy_start_aneg(phydev);
 386
 387                 return 0;
 388
 389         case SIOCSHWTSTAMP:
 390                 if (phydev->mii_ts && phydev->mii_ts->hwtstamp)
 391                         return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
 392                 fallthrough;
 393
 394         default:
 395                 return -EOPNOTSUPP;
 396         }
 397 }
 398 EXPORT_SYMBOL(phy_mii_ioctl);
 399
 400 /**
 401  * phy_do_ioctl - generic ndo_do_ioctl implementation
 402  * @dev: the net_device struct
 403  * @ifr: &struct ifreq for socket ioctl's
 404  * @cmd: ioctl cmd to execute
 405  */
 406 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 407 {
 408         if (!dev->phydev)
 409                 return -ENODEV;
 410
 411         return phy_mii_ioctl(dev->phydev, ifr, cmd);
 412 }
 413 EXPORT_SYMBOL(phy_do_ioctl);
 414
 415 /**
 416  * phy_do_ioctl_running - generic ndo_do_ioctl implementation but test first
 417  *
 418  * @dev: the net_device struct
 419  * @ifr: &struct ifreq for socket ioctl's
 420  * @cmd: ioctl cmd to execute
 421  *
 422  * Same as phy_do_ioctl, but ensures that net_device is running before
 423  * handling the ioctl.
 424  */
 425 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)
 426 {
 427         if (!netif_running(dev))
 428                 return -ENODEV;
 429
 430         return phy_do_ioctl(dev, ifr, cmd);
 431 }
 432 EXPORT_SYMBOL(phy_do_ioctl_running);
 433
 434 /**
 435  * phy_queue_state_machine - Trigger the state machine to run soon
 436  *
 437  * @phydev: the phy_device struct
 438  * @jiffies: Run the state machine after these jiffies
 439  */
 440 void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)
 441 {
 442         mod_delayed_work(system_power_efficient_wq, &phydev->state_queue,
 443                          jiffies);
 444 }
 445 EXPORT_SYMBOL(phy_queue_state_machine);
 446
 447 /**
 448  * phy_queue_state_machine - Trigger the state machine to run now
 449  *
 450  * @phydev: the phy_device struct
 451  */
 452 static void phy_trigger_machine(struct phy_device *phydev)
 453 {
 454         phy_queue_state_machine(phydev, 0);
 455 }
 456
 457 static void phy_abort_cable_test(struct phy_device *phydev)
 458 {
 459         int err;
 460
 461         ethnl_cable_test_finished(phydev);
 462
 463         err = phy_init_hw(phydev);
 464         if (err)
 465                 phydev_err(phydev, "Error while aborting cable test");
 466 }
 467
 468 /**
 469  * phy_ethtool_get_strings - Get the statistic counter names
 470  *
 471  * @phydev: the phy_device struct
 472  * @data: Where to put the strings
 473  */
 474 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)
 475 {
 476         if (!phydev->drv)
 477                 return -EIO;
 478
 479         mutex_lock(&phydev->lock);
 480         phydev->drv->get_strings(phydev, data);
 481         mutex_unlock(&phydev->lock);
 482
 483         return 0;
 484 }
 485 EXPORT_SYMBOL(phy_ethtool_get_strings);
 486
 487 /**
 488  * phy_ethtool_get_sset_count - Get the number of statistic counters
 489  *
 490  * @phydev: the phy_device struct
 491  */
 492 int phy_ethtool_get_sset_count(struct phy_device *phydev)
 493 {
 494         int ret;
 495
 496         if (!phydev->drv)
 497                 return -EIO;
 498
 499         if (phydev->drv->get_sset_count &&
 500             phydev->drv->get_strings &&
 501             phydev->drv->get_stats) {
 502                 mutex_lock(&phydev->lock);
 503                 ret = phydev->drv->get_sset_count(phydev);
 504                 mutex_unlock(&phydev->lock);
 505
 506                 return ret;
 507         }
 508
 509         return -EOPNOTSUPP;
 510 }
 511 EXPORT_SYMBOL(phy_ethtool_get_sset_count);
 512
 513 /**
 514  * phy_ethtool_get_stats - Get the statistic counters
 515  *
 516  * @phydev: the phy_device struct
 517  * @stats: What counters to get
 518  * @data: Where to store the counters
 519  */
 520 int phy_ethtool_get_stats(struct phy_device *phydev,
 521                           struct ethtool_stats *stats, u64 *data)
 522 {
 523         if (!phydev->drv)
 524                 return -EIO;
 525
 526         mutex_lock(&phydev->lock);
 527         phydev->drv->get_stats(phydev, stats, data);
 528         mutex_unlock(&phydev->lock);
 529
 530         return 0;
 531 }
 532 EXPORT_SYMBOL(phy_ethtool_get_stats);
 533
 534 /**
 535  * phy_start_cable_test - Start a cable test
 536  *
 537  * @phydev: the phy_device struct
 538  * @extack: extack for reporting useful error messages
 539  */
 540 int phy_start_cable_test(struct phy_device *phydev,
 541                          struct netlink_ext_ack *extack)
 542 {
 543         struct net_device *dev = phydev->attached_dev;
 544         int err = -ENOMEM;
 545
 546         if (!(phydev->drv &&
 547               phydev->drv->cable_test_start &&
 548               phydev->drv->cable_test_get_status)) {
 549                 NL_SET_ERR_MSG(extack,
 550                                "PHY driver does not support cable testing");
 551                 return -EOPNOTSUPP;
 552         }
 553
 554         mutex_lock(&phydev->lock);
 555         if (phydev->state == PHY_CABLETEST) {
 556                 NL_SET_ERR_MSG(extack,
 557                                "PHY already performing a test");
 558                 err = -EBUSY;
 559                 goto out;
 560         }
 561
 562         if (phydev->state < PHY_UP ||
 563             phydev->state > PHY_CABLETEST) {
 564                 NL_SET_ERR_MSG(extack,
 565                                "PHY not configured. Try setting interface up");
 566                 err = -EBUSY;
 567                 goto out;
 568         }
 569
 570         err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF);
 571         if (err)
 572                 goto out;
 573
 574         /* Mark the carrier down until the test is complete */
 575         phy_link_down(phydev);
 576
 577         netif_testing_on(dev);
 578         err = phydev->drv->cable_test_start(phydev);
 579         if (err) {
 580                 netif_testing_off(dev);
 581                 phy_link_up(phydev);
 582                 goto out_free;
 583         }
 584
 585         phydev->state = PHY_CABLETEST;
 586
 587         if (phy_polling_mode(phydev))
 588                 phy_trigger_machine(phydev);
 589
 590         mutex_unlock(&phydev->lock);
 591
 592         return 0;
 593
 594 out_free:
 595         ethnl_cable_test_free(phydev);
 596 out:
 597         mutex_unlock(&phydev->lock);
 598
 599         return err;
 600 }
 601 EXPORT_SYMBOL(phy_start_cable_test);
 602
 603 /**
 604  * phy_start_cable_test_tdr - Start a raw TDR cable test
 605  *
 606  * @phydev: the phy_device struct
 607  * @extack: extack for reporting useful error messages
 608  * @config: Configuration of the test to run
 609  */
 610 int phy_start_cable_test_tdr(struct phy_device *phydev,
 611                              struct netlink_ext_ack *extack,
 612                              const struct phy_tdr_config *config)
 613 {
 614         struct net_device *dev = phydev->attached_dev;
 615         int err = -ENOMEM;
 616
 617         if (!(phydev->drv &&
 618               phydev->drv->cable_test_tdr_start &&
 619               phydev->drv->cable_test_get_status)) {
 620                 NL_SET_ERR_MSG(extack,
 621                                "PHY driver does not support cable test TDR");
 622                 return -EOPNOTSUPP;
 623         }
 624
 625         mutex_lock(&phydev->lock);
 626         if (phydev->state == PHY_CABLETEST) {
 627                 NL_SET_ERR_MSG(extack,
 628                                "PHY already performing a test");
 629                 err = -EBUSY;
 630                 goto out;
 631         }
 632
 633         if (phydev->state < PHY_UP ||
 634             phydev->state > PHY_CABLETEST) {
 635                 NL_SET_ERR_MSG(extack,
 636                                "PHY not configured. Try setting interface up");
 637                 err = -EBUSY;
 638                 goto out;
 639         }
 640
 641         err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF);
 642         if (err)
 643                 goto out;
 644
 645         /* Mark the carrier down until the test is complete */
 646         phy_link_down(phydev);
 647
 648         netif_testing_on(dev);
 649         err = phydev->drv->cable_test_tdr_start(phydev, config);
 650         if (err) {
 651                 netif_testing_off(dev);
 652                 phy_link_up(phydev);
 653                 goto out_free;
 654         }
 655
 656         phydev->state = PHY_CABLETEST;
 657
 658         if (phy_polling_mode(phydev))
 659                 phy_trigger_machine(phydev);
 660
 661         mutex_unlock(&phydev->lock);
 662
 663         return 0;
 664
 665 out_free:
 666         ethnl_cable_test_free(phydev);
 667 out:
 668         mutex_unlock(&phydev->lock);
 669
 670         return err;
 671 }
 672 EXPORT_SYMBOL(phy_start_cable_test_tdr);
 673
 674 static int phy_config_aneg(struct phy_device *phydev)
 675 {
 676         if (phydev->drv->config_aneg)
 677                 return phydev->drv->config_aneg(phydev);
 678
 679         /* Clause 45 PHYs that don't implement Clause 22 registers are not
 680          * allowed to call genphy_config_aneg()
 681          */
 682         if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0)))
 683                 return genphy_c45_config_aneg(phydev);
 684
 685         return genphy_config_aneg(phydev);
 686 }
 687
 688 /**
 689  * phy_check_link_status - check link status and set state accordingly
 690  * @phydev: the phy_device struct
 691  *
 692  * Description: Check for link and whether autoneg was triggered / is running
 693  * and set state accordingly
 694  */
 695 static int phy_check_link_status(struct phy_device *phydev)
 696 {
 697         int err;
 698
 699         WARN_ON(!mutex_is_locked(&phydev->lock));
 700
 701         /* Keep previous state if loopback is enabled because some PHYs
 702          * report that Link is Down when loopback is enabled.
 703          */
 704         if (phydev->loopback_enabled)
 705                 return 0;
 706
 707         err = phy_read_status(phydev);
 708         if (err)
 709                 return err;
 710
 711         if (phydev->link && phydev->state != PHY_RUNNING) {
 712                 phy_check_downshift(phydev);
 713                 phydev->state = PHY_RUNNING;
 714                 phy_link_up(phydev);
 715         } else if (!phydev->link && phydev->state != PHY_NOLINK) {
 716                 phydev->state = PHY_NOLINK;
 717                 phy_link_down(phydev);
 718         }
 719
 720         return 0;
 721 }
 722
 723 /**
 724  * _phy_start_aneg - start auto-negotiation for this PHY device
 725  * @phydev: the phy_device struct
 726  *
 727  * Description: Sanitizes the settings (if we're not autonegotiating
 728  *   them), and then calls the driver's config_aneg function.
 729  *   If the PHYCONTROL Layer is operating, we change the state to
 730  *   reflect the beginning of Auto-negotiation or forcing.
 731  */
 732 static int _phy_start_aneg(struct phy_device *phydev)
 733 {
 734         int err;
 735
 736         lockdep_assert_held(&phydev->lock);
 737
 738         if (!phydev->drv)
 739                 return -EIO;
 740
 741         if (AUTONEG_DISABLE == phydev->autoneg)
 742                 phy_sanitize_settings(phydev);
 743
 744         err = phy_config_aneg(phydev);
 745         if (err < 0)
 746                 return err;
 747
 748         if (phy_is_started(phydev))
 749                 err = phy_check_link_status(phydev);
 750
 751         return err;
 752 }
 753
 754 /**
 755  * phy_start_aneg - start auto-negotiation for this PHY device
 756  * @phydev: the phy_device struct
 757  *
 758  * Description: Sanitizes the settings (if we're not autonegotiating
 759  *   them), and then calls the driver's config_aneg function.
 760  *   If the PHYCONTROL Layer is operating, we change the state to
 761  *   reflect the beginning of Auto-negotiation or forcing.
 762  */
 763 int phy_start_aneg(struct phy_device *phydev)
 764 {
 765         int err;
 766
 767         mutex_lock(&phydev->lock);
 768         err = _phy_start_aneg(phydev);
 769         mutex_unlock(&phydev->lock);
 770
 771         return err;
 772 }
 773 EXPORT_SYMBOL(phy_start_aneg);
 774
 775 static int phy_poll_aneg_done(struct phy_device *phydev)
 776 {
 777         unsigned int retries = 100;
 778         int ret;
 779
 780         do {
 781                 msleep(100);
 782                 ret = phy_aneg_done(phydev);
 783         } while (!ret && --retries);
 784
 785         if (!ret)
 786                 return -ETIMEDOUT;
 787
 788         return ret < 0 ? ret : 0;
 789 }
 790
 791 int phy_ethtool_ksettings_set(struct phy_device *phydev,
 792                               const struct ethtool_link_ksettings *cmd)
 793 {
 794         __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
 795         u8 autoneg = cmd->base.autoneg;
 796         u8 duplex = cmd->base.duplex;
 797         u32 speed = cmd->base.speed;
 798
 799         if (cmd->base.phy_address != phydev->mdio.addr)
 800                 return -EINVAL;
 801
 802         linkmode_copy(advertising, cmd->link_modes.advertising);
 803
 804         /* We make sure that we don't pass unsupported values in to the PHY */
 805         linkmode_and(advertising, advertising, phydev->supported);
 806
 807         /* Verify the settings we care about. */
 808         if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE)
 809                 return -EINVAL;
 810
 811         if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising))
 812                 return -EINVAL;
 813
 814         if (autoneg == AUTONEG_DISABLE &&
 815             ((speed != SPEED_1000 &&
 816               speed != SPEED_100 &&
 817               speed != SPEED_10) ||
 818              (duplex != DUPLEX_HALF &&
 819               duplex != DUPLEX_FULL)))
 820                 return -EINVAL;
 821
 822         mutex_lock(&phydev->lock);
 823         phydev->autoneg = autoneg;
 824
 825         if (autoneg == AUTONEG_DISABLE) {
 826                 phydev->speed = speed;
 827                 phydev->duplex = duplex;
 828         }
 829
 830         linkmode_copy(phydev->advertising, advertising);
 831
 832         linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
 833                          phydev->advertising, autoneg == AUTONEG_ENABLE);
 834
 835         phydev->master_slave_set = cmd->base.master_slave_cfg;
 836         phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl;
 837
 838         /* Restart the PHY */
 839         if (phy_is_started(phydev)) {
 840                 phydev->state = PHY_UP;
 841                 phy_trigger_machine(phydev);
 842         } else {
 843                 _phy_start_aneg(phydev);
 844         }
 845
 846         mutex_unlock(&phydev->lock);
 847         return 0;
 848 }
 849 EXPORT_SYMBOL(phy_ethtool_ksettings_set);
 850
 851 /**
 852  * phy_speed_down - set speed to lowest speed supported by both link partners
 853  * @phydev: the phy_device struct
 854  * @sync: perform action synchronously
 855  *
 856  * Description: Typically used to save energy when waiting for a WoL packet
 857  *
 858  * WARNING: Setting sync to false may cause the system being unable to suspend
 859  * in case the PHY generates an interrupt when finishing the autonegotiation.
 860  * This interrupt may wake up the system immediately after suspend.
 861  * Therefore use sync = false only if you're sure it's safe with the respective
 862  * network chip.
 863  */
 864 int phy_speed_down(struct phy_device *phydev, bool sync)
 865 {
 866         __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
 867         int ret;
 868
 869         if (phydev->autoneg != AUTONEG_ENABLE)
 870                 return 0;
 871
 872         linkmode_copy(adv_tmp, phydev->advertising);
 873
 874         ret = phy_speed_down_core(phydev);
 875         if (ret)
 876                 return ret;
 877
 878         linkmode_copy(phydev->adv_old, adv_tmp);
 879
 880         if (linkmode_equal(phydev->advertising, adv_tmp))
 881                 return 0;
 882
 883         ret = phy_config_aneg(phydev);
 884         if (ret)
 885                 return ret;
 886
 887         return sync ? phy_poll_aneg_done(phydev) : 0;
 888 }
 889 EXPORT_SYMBOL_GPL(phy_speed_down);
 890
 891 /**
 892  * phy_speed_up - (re)set advertised speeds to all supported speeds
 893  * @phydev: the phy_device struct
 894  *
 895  * Description: Used to revert the effect of phy_speed_down
 896  */
 897 int phy_speed_up(struct phy_device *phydev)
 898 {
 899         __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp);
 900
 901         if (phydev->autoneg != AUTONEG_ENABLE)
 902                 return 0;
 903
 904         if (linkmode_empty(phydev->adv_old))
 905                 return 0;
 906
 907         linkmode_copy(adv_tmp, phydev->advertising);
 908         linkmode_copy(phydev->advertising, phydev->adv_old);
 909         linkmode_zero(phydev->adv_old);
 910
 911         if (linkmode_equal(phydev->advertising, adv_tmp))
 912                 return 0;
 913
 914         return phy_config_aneg(phydev);
 915 }
 916 EXPORT_SYMBOL_GPL(phy_speed_up);
 917
 918 /**
 919  * phy_start_machine - start PHY state machine tracking
 920  * @phydev: the phy_device struct
 921  *
 922  * Description: The PHY infrastructure can run a state machine
 923  *   which tracks whether the PHY is starting up, negotiating,
 924  *   etc.  This function starts the delayed workqueue which tracks
 925  *   the state of the PHY. If you want to maintain your own state machine,
 926  *   do not call this function.
 927  */
 928 void phy_start_machine(struct phy_device *phydev)
 929 {
 930         phy_trigger_machine(phydev);
 931 }
 932 EXPORT_SYMBOL_GPL(phy_start_machine);
 933
 934 /**
 935  * phy_stop_machine - stop the PHY state machine tracking
 936  * @phydev: target phy_device struct
 937  *
 938  * Description: Stops the state machine delayed workqueue, sets the
 939  *   state to UP (unless it wasn't up yet). This function must be
 940  *   called BEFORE phy_detach.
 941  */
 942 void phy_stop_machine(struct phy_device *phydev)
 943 {
 944         cancel_delayed_work_sync(&phydev->state_queue);
 945
 946         mutex_lock(&phydev->lock);
 947         if (phy_is_started(phydev))
 948                 phydev->state = PHY_UP;
 949         mutex_unlock(&phydev->lock);
 950 }
 951
 952 /**
 953  * phy_error - enter HALTED state for this PHY device
 954  * @phydev: target phy_device struct
 955  *
 956  * Moves the PHY to the HALTED state in response to a read
 957  * or write error, and tells the controller the link is down.
 958  * Must not be called from interrupt context, or while the
 959  * phydev->lock is held.
 960  */
 961 static void phy_error(struct phy_device *phydev)
 962 {
 963         WARN_ON(1);
 964
 965         mutex_lock(&phydev->lock);
 966         phydev->state = PHY_HALTED;
 967         mutex_unlock(&phydev->lock);
 968
 969         phy_trigger_machine(phydev);
 970 }
 971
 972 /**
 973  * phy_disable_interrupts - Disable the PHY interrupts from the PHY side
 974  * @phydev: target phy_device struct
 975  */
 976 int phy_disable_interrupts(struct phy_device *phydev)
 977 {
 978         int err;
 979
 980         /* Disable PHY interrupts */
 981         err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
 982         if (err)
 983                 return err;
 984
 985         /* Clear the interrupt */
 986         return phy_clear_interrupt(phydev);
 987 }
 988
 989 /**
 990  * phy_did_interrupt - Checks if the PHY generated an interrupt
 991  * @phydev: target phy_device struct
 992  */
 993 static int phy_did_interrupt(struct phy_device *phydev)
 994 {
 995         int ret;
 996
 997         mutex_lock(&phydev->lock);
 998         ret = phydev->drv->did_interrupt(phydev);
 999         mutex_unlock(&phydev->lock);
1000
1001         return ret;
1002 }
1003
1004 /**
1005  * phy_handle_interrupt - Handle PHY interrupt
1006  * @phydev: target phy_device struct
1007  */
1008 static irqreturn_t phy_handle_interrupt(struct phy_device *phydev)
1009 {
1010         irqreturn_t ret;
1011
1012         mutex_lock(&phydev->lock);
1013         ret = phydev->drv->handle_interrupt(phydev);
1014         mutex_unlock(&phydev->lock);
1015
1016         return ret;
1017 }
1018
1019 /**
1020  * phy_interrupt - PHY interrupt handler
1021  * @irq: interrupt line
1022  * @phy_dat: phy_device pointer
1023  *
1024  * Description: Handle PHY interrupt
1025  */
1026 static irqreturn_t phy_interrupt(int irq, void *phy_dat)
1027 {
1028         struct phy_device *phydev = phy_dat;
1029         struct phy_driver *drv = phydev->drv;
1030
1031         if (drv->handle_interrupt)
1032                 return phy_handle_interrupt(phydev);
1033
1034         if (drv->did_interrupt && !phy_did_interrupt(phydev))
1035                 return IRQ_NONE;
1036
1037         /* reschedule state queue work to run as soon as possible */
1038         phy_trigger_machine(phydev);
1039
1040         /* did_interrupt() may have cleared the interrupt already */
1041         if (!drv->did_interrupt && phy_clear_interrupt(phydev)) {
1042                 phy_error(phydev);
1043                 return IRQ_NONE;
1044         }
1045
1046         return IRQ_HANDLED;
1047 }
1048
1049 /**
1050  * phy_enable_interrupts - Enable the interrupts from the PHY side
1051  * @phydev: target phy_device struct
1052  */
1053 static int phy_enable_interrupts(struct phy_device *phydev)
1054 {
1055         int err = phy_clear_interrupt(phydev);
1056
1057         if (err < 0)
1058                 return err;
1059
1060         return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED);
1061 }
1062
1063 /**
1064  * phy_request_interrupt - request and enable interrupt for a PHY device
1065  * @phydev: target phy_device struct
1066  *
1067  * Description: Request and enable the interrupt for the given PHY.
1068  *   If this fails, then we set irq to PHY_POLL.
1069  *   This should only be called with a valid IRQ number.
1070  */
1071 void phy_request_interrupt(struct phy_device *phydev)
1072 {
1073         int err;
1074
1075         err = request_threaded_irq(phydev->irq, NULL, phy_interrupt,
1076                                    IRQF_ONESHOT | IRQF_SHARED,
1077                                    phydev_name(phydev), phydev);
1078         if (err) {
1079                 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n",
1080                             err, phydev->irq);
1081                 phydev->irq = PHY_POLL;
1082         } else {
1083                 if (phy_enable_interrupts(phydev)) {
1084                         phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n");
1085                         phy_free_interrupt(phydev);
1086                         phydev->irq = PHY_POLL;
1087                 }
1088         }
1089 }
1090 EXPORT_SYMBOL(phy_request_interrupt);
1091
1092 /**
1093  * phy_free_interrupt - disable and free interrupt for a PHY device
1094  * @phydev: target phy_device struct
1095  *
1096  * Description: Disable and free the interrupt for the given PHY.
1097  *   This should only be called with a valid IRQ number.
1098  */
1099 void phy_free_interrupt(struct phy_device *phydev)
1100 {
1101         phy_disable_interrupts(phydev);
1102         free_irq(phydev->irq, phydev);
1103 }
1104 EXPORT_SYMBOL(phy_free_interrupt);
1105
1106 /**
1107  * phy_stop - Bring down the PHY link, and stop checking the status
1108  * @phydev: target phy_device struct
1109  */
1110 void phy_stop(struct phy_device *phydev)
1111 {
1112         struct net_device *dev = phydev->attached_dev;
1113
1114         if (!phy_is_started(phydev) && phydev->state != PHY_DOWN) {
1115                 WARN(1, "called from state %s\n",
1116                      phy_state_to_str(phydev->state));
1117                 return;
1118         }
1119
1120         mutex_lock(&phydev->lock);
1121
1122         if (phydev->state == PHY_CABLETEST) {
1123                 phy_abort_cable_test(phydev);
1124                 netif_testing_off(dev);
1125         }
1126
1127         if (phydev->sfp_bus)
1128                 sfp_upstream_stop(phydev->sfp_bus);
1129
1130         phydev->state = PHY_HALTED;
1131
1132         mutex_unlock(&phydev->lock);
1133
1134         phy_state_machine(&phydev->state_queue.work);
1135         phy_stop_machine(phydev);
1136
1137         /* Cannot call flush_scheduled_work() here as desired because
1138          * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler
1139          * will not reenable interrupts.
1140          */
1141 }
1142 EXPORT_SYMBOL(phy_stop);
1143
1144 /**
1145  * phy_start - start or restart a PHY device
1146  * @phydev: target phy_device struct
1147  *
1148  * Description: Indicates the attached device's readiness to
1149  *   handle PHY-related work.  Used during startup to start the
1150  *   PHY, and after a call to phy_stop() to resume operation.
1151  *   Also used to indicate the MDIO bus has cleared an error
1152  *   condition.
1153  */
1154 void phy_start(struct phy_device *phydev)
1155 {
1156         mutex_lock(&phydev->lock);
1157
1158         if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) {
1159                 WARN(1, "called from state %s\n",
1160                      phy_state_to_str(phydev->state));
1161                 goto out;
1162         }
1163
1164         if (phydev->sfp_bus)
1165                 sfp_upstream_start(phydev->sfp_bus);
1166
1167         /* if phy was suspended, bring the physical link up again */
1168         __phy_resume(phydev);
1169
1170         phydev->state = PHY_UP;
1171
1172         phy_start_machine(phydev);
1173 out:
1174         mutex_unlock(&phydev->lock);
1175 }
1176 EXPORT_SYMBOL(phy_start);
1177
1178 /**
1179  * phy_state_machine - Handle the state machine
1180  * @work: work_struct that describes the work to be done
1181  */
1182 void phy_state_machine(struct work_struct *work)
1183 {
1184         struct delayed_work *dwork = to_delayed_work(work);
1185         struct phy_device *phydev =
1186                         container_of(dwork, struct phy_device, state_queue);
1187         struct net_device *dev = phydev->attached_dev;
1188         bool needs_aneg = false, do_suspend = false;
1189         enum phy_state old_state;
1190         bool finished = false;
1191         int err = 0;
1192
1193         mutex_lock(&phydev->lock);
1194
1195         old_state = phydev->state;
1196
1197         switch (phydev->state) {
1198         case PHY_DOWN:
1199         case PHY_READY:
1200                 break;
1201         case PHY_UP:
1202                 needs_aneg = true;
1203
1204                 break;
1205         case PHY_NOLINK:
1206         case PHY_RUNNING:
1207                 err = phy_check_link_status(phydev);
1208                 break;
1209         case PHY_CABLETEST:
1210                 err = phydev->drv->cable_test_get_status(phydev, &finished);
1211                 if (err) {
1212                         phy_abort_cable_test(phydev);
1213                         netif_testing_off(dev);
1214                         needs_aneg = true;
1215                         phydev->state = PHY_UP;
1216                         break;
1217                 }
1218
1219                 if (finished) {
1220                         ethnl_cable_test_finished(phydev);
1221                         netif_testing_off(dev);
1222                         needs_aneg = true;
1223                         phydev->state = PHY_UP;
1224                 }
1225                 break;
1226         case PHY_HALTED:
1227                 if (phydev->link) {
1228                         phydev->link = 0;
1229                         phy_link_down(phydev);
1230                 }
1231                 do_suspend = true;
1232                 break;
1233         }
1234
1235         mutex_unlock(&phydev->lock);
1236
1237         if (needs_aneg)
1238                 err = phy_start_aneg(phydev);
1239         else if (do_suspend)
1240                 phy_suspend(phydev);
1241
1242         if (err < 0)
1243                 phy_error(phydev);
1244
1245         if (old_state != phydev->state) {
1246                 phydev_dbg(phydev, "PHY state change %s -> %s\n",
1247                            phy_state_to_str(old_state),
1248                            phy_state_to_str(phydev->state));
1249                 if (phydev->drv && phydev->drv->link_change_notify)
1250                         phydev->drv->link_change_notify(phydev);
1251         }
1252
1253         /* Only re-schedule a PHY state machine change if we are polling the
1254          * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving
1255          * between states from phy_mac_interrupt().
1256          *
1257          * In state PHY_HALTED the PHY gets suspended, so rescheduling the
1258          * state machine would be pointless and possibly error prone when
1259          * called from phy_disconnect() synchronously.
1260          */
1261         mutex_lock(&phydev->lock);
1262         if (phy_polling_mode(phydev) && phy_is_started(phydev))
1263                 phy_queue_state_machine(phydev, PHY_STATE_TIME);
1264         mutex_unlock(&phydev->lock);
1265 }
1266
1267 /**
1268  * phy_mac_interrupt - MAC says the link has changed
1269  * @phydev: phy_device struct with changed link
1270  *
1271  * The MAC layer is able to indicate there has been a change in the PHY link
1272  * status. Trigger the state machine and work a work queue.
1273  */
1274 void phy_mac_interrupt(struct phy_device *phydev)
1275 {
1276         /* Trigger a state machine change */
1277         phy_trigger_machine(phydev);
1278 }
1279 EXPORT_SYMBOL(phy_mac_interrupt);
1280
1281 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv)
1282 {
1283         linkmode_zero(advertising);
1284
1285         if (eee_adv & MDIO_EEE_100TX)
1286                 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
1287                                  advertising);
1288         if (eee_adv & MDIO_EEE_1000T)
1289                 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1290                                  advertising);
1291         if (eee_adv & MDIO_EEE_10GT)
1292                 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1293                                  advertising);
1294         if (eee_adv & MDIO_EEE_1000KX)
1295                 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
1296                                  advertising);
1297         if (eee_adv & MDIO_EEE_10GKX4)
1298                 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
1299                                  advertising);
1300         if (eee_adv & MDIO_EEE_10GKR)
1301                 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
1302                                  advertising);
1303 }
1304
1305 /**
1306  * phy_init_eee - init and check the EEE feature
1307  * @phydev: target phy_device struct
1308  * @clk_stop_enable: PHY may stop the clock during LPI
1309  *
1310  * Description: it checks if the Energy-Efficient Ethernet (EEE)
1311  * is supported by looking at the MMD registers 3.20 and 7.60/61
1312  * and it programs the MMD register 3.0 setting the "Clock stop enable"
1313  * bit if required.
1314  */
1315 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)
1316 {
1317         if (!phydev->drv)
1318                 return -EIO;
1319
1320         /* According to 802.3az,the EEE is supported only in full duplex-mode.
1321          */
1322         if (phydev->duplex == DUPLEX_FULL) {
1323                 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
1324                 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp);
1325                 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
1326                 int eee_lp, eee_cap, eee_adv;
1327                 int status;
1328                 u32 cap;
1329
1330                 /* Read phy status to properly get the right settings */
1331                 status = phy_read_status(phydev);
1332                 if (status)
1333                         return status;
1334
1335                 /* First check if the EEE ability is supported */
1336                 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1337                 if (eee_cap <= 0)
1338                         goto eee_exit_err;
1339
1340                 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
1341                 if (!cap)
1342                         goto eee_exit_err;
1343
1344                 /* Check which link settings negotiated and verify it in
1345                  * the EEE advertising registers.
1346                  */
1347                 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1348                 if (eee_lp <= 0)
1349                         goto eee_exit_err;
1350
1351                 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1352                 if (eee_adv <= 0)
1353                         goto eee_exit_err;
1354
1355                 mmd_eee_adv_to_linkmode(adv, eee_adv);
1356                 mmd_eee_adv_to_linkmode(lp, eee_lp);
1357                 linkmode_and(common, adv, lp);
1358
1359                 if (!phy_check_valid(phydev->speed, phydev->duplex, common))
1360                         goto eee_exit_err;
1361
1362                 if (clk_stop_enable)
1363                         /* Configure the PHY to stop receiving xMII
1364                          * clock while it is signaling LPI.
1365                          */
1366                         phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1,
1367                                          MDIO_PCS_CTRL1_CLKSTOP_EN);
1368
1369                 return 0; /* EEE supported */
1370         }
1371 eee_exit_err:
1372         return -EPROTONOSUPPORT;
1373 }
1374 EXPORT_SYMBOL(phy_init_eee);
1375
1376 /**
1377  * phy_get_eee_err - report the EEE wake error count
1378  * @phydev: target phy_device struct
1379  *
1380  * Description: it is to report the number of time where the PHY
1381  * failed to complete its normal wake sequence.
1382  */
1383 int phy_get_eee_err(struct phy_device *phydev)
1384 {
1385         if (!phydev->drv)
1386                 return -EIO;
1387
1388         return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR);
1389 }
1390 EXPORT_SYMBOL(phy_get_eee_err);
1391
1392 /**
1393  * phy_ethtool_get_eee - get EEE supported and status
1394  * @phydev: target phy_device struct
1395  * @data: ethtool_eee data
1396  *
1397  * Description: it reportes the Supported/Advertisement/LP Advertisement
1398  * capabilities.
1399  */
1400 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
1401 {
1402         int val;
1403
1404         if (!phydev->drv)
1405                 return -EIO;
1406
1407         /* Get Supported EEE */
1408         val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1409         if (val < 0)
1410                 return val;
1411         data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
1412
1413         /* Get advertisement EEE */
1414         val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1415         if (val < 0)
1416                 return val;
1417         data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1418         data->eee_enabled = !!data->advertised;
1419
1420         /* Get LP advertisement EEE */
1421         val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
1422         if (val < 0)
1423                 return val;
1424         data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
1425
1426         data->eee_active = !!(data->advertised & data->lp_advertised);
1427
1428         return 0;
1429 }
1430 EXPORT_SYMBOL(phy_ethtool_get_eee);
1431
1432 /**
1433  * phy_ethtool_set_eee - set EEE supported and status
1434  * @phydev: target phy_device struct
1435  * @data: ethtool_eee data
1436  *
1437  * Description: it is to program the Advertisement EEE register.
1438  */
1439 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
1440 {
1441         int cap, old_adv, adv = 0, ret;
1442
1443         if (!phydev->drv)
1444                 return -EIO;
1445
1446         /* Get Supported EEE */
1447         cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
1448         if (cap < 0)
1449                 return cap;
1450
1451         old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
1452         if (old_adv < 0)
1453                 return old_adv;
1454
1455         if (data->eee_enabled) {
1456                 adv = !data->advertised ? cap :
1457                       ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap;
1458                 /* Mask prohibited EEE modes */
1459                 adv &= ~phydev->eee_broken_modes;
1460         }
1461
1462         if (old_adv != adv) {
1463                 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv);
1464                 if (ret < 0)
1465                         return ret;
1466
1467                 /* Restart autonegotiation so the new modes get sent to the
1468                  * link partner.
1469                  */
1470                 if (phydev->autoneg == AUTONEG_ENABLE) {
1471                         ret = phy_restart_aneg(phydev);
1472                         if (ret < 0)
1473                                 return ret;
1474                 }
1475         }
1476
1477         return 0;
1478 }
1479 EXPORT_SYMBOL(phy_ethtool_set_eee);
1480
1481 /**
1482  * phy_ethtool_set_wol - Configure Wake On LAN
1483  *
1484  * @phydev: target phy_device struct
1485  * @wol: Configuration requested
1486  */
1487 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1488 {
1489         if (phydev->drv && phydev->drv->set_wol)
1490                 return phydev->drv->set_wol(phydev, wol);
1491
1492         return -EOPNOTSUPP;
1493 }
1494 EXPORT_SYMBOL(phy_ethtool_set_wol);
1495
1496 /**
1497  * phy_ethtool_get_wol - Get the current Wake On LAN configuration
1498  *
1499  * @phydev: target phy_device struct
1500  * @wol: Store the current configuration here
1501  */
1502 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
1503 {
1504         if (phydev->drv && phydev->drv->get_wol)
1505                 phydev->drv->get_wol(phydev, wol);
1506 }
1507 EXPORT_SYMBOL(phy_ethtool_get_wol);
1508
1509 int phy_ethtool_get_link_ksettings(struct net_device *ndev,
1510                                    struct ethtool_link_ksettings *cmd)
1511 {
1512         struct phy_device *phydev = ndev->phydev;
1513
1514         if (!phydev)
1515                 return -ENODEV;
1516
1517         phy_ethtool_ksettings_get(phydev, cmd);
1518
1519         return 0;
1520 }
1521 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings);
1522
1523 int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1524                                    const struct ethtool_link_ksettings *cmd)
1525 {
1526         struct phy_device *phydev = ndev->phydev;
1527
1528         if (!phydev)
1529                 return -ENODEV;
1530
1531         return phy_ethtool_ksettings_set(phydev, cmd);
1532 }
1533 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings);
1534
1535 /**
1536  * phy_ethtool_nway_reset - Restart auto negotiation
1537  * @ndev: Network device to restart autoneg for
1538  */
1539 int phy_ethtool_nway_reset(struct net_device *ndev)
1540 {
1541         struct phy_device *phydev = ndev->phydev;
1542
1543         if (!phydev)
1544                 return -ENODEV;
1545
1546         if (!phydev->drv)
1547                 return -EIO;
1548
1549         return phy_restart_aneg(phydev);
1550 }
1551 EXPORT_SYMBOL(phy_ethtool_nway_reset);