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