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/etherdevice.h> 19 #include <linux/skbuff.h> 20 #include <linux/mm.h> 21 #include <linux/module.h> 22 #include <linux/mii.h> 23 #include <linux/ethtool.h> 24 #include <linux/phy.h> 25 #include <linux/phy_led_triggers.h> 26 #include <linux/workqueue.h> 27 #include <linux/mdio.h> 28 #include <linux/io.h> 29 #include <linux/uaccess.h> 30 #include <linux/atomic.h> 31 32 #define PHY_STATE_STR(_state) \ 33 case PHY_##_state: \ 34 return __stringify(_state); \ 35 36 static const char *phy_state_to_str(enum phy_state st) 37 { 38 switch (st) { 39 PHY_STATE_STR(DOWN) 40 PHY_STATE_STR(READY) 41 PHY_STATE_STR(UP) 42 PHY_STATE_STR(RUNNING) 43 PHY_STATE_STR(NOLINK) 44 PHY_STATE_STR(FORCING) 45 PHY_STATE_STR(HALTED) 46 PHY_STATE_STR(RESUMING) 47 } 48 49 return NULL; 50 } 51 52 static void phy_link_up(struct phy_device *phydev) 53 { 54 phydev->phy_link_change(phydev, true, true); 55 phy_led_trigger_change_speed(phydev); 56 } 57 58 static void phy_link_down(struct phy_device *phydev, bool do_carrier) 59 { 60 phydev->phy_link_change(phydev, false, do_carrier); 61 phy_led_trigger_change_speed(phydev); 62 } 63 64 /** 65 * phy_print_status - Convenience function to print out the current phy status 66 * @phydev: the phy_device struct 67 */ 68 void phy_print_status(struct phy_device *phydev) 69 { 70 if (phydev->link) { 71 netdev_info(phydev->attached_dev, 72 "Link is Up - %s/%s - flow control %s\n", 73 phy_speed_to_str(phydev->speed), 74 phy_duplex_to_str(phydev->duplex), 75 phydev->pause ? "rx/tx" : "off"); 76 } else { 77 netdev_info(phydev->attached_dev, "Link is Down\n"); 78 } 79 } 80 EXPORT_SYMBOL(phy_print_status); 81 82 /** 83 * phy_clear_interrupt - Ack the phy device's interrupt 84 * @phydev: the phy_device struct 85 * 86 * If the @phydev driver has an ack_interrupt function, call it to 87 * ack and clear the phy device's interrupt. 88 * 89 * Returns 0 on success or < 0 on error. 90 */ 91 static int phy_clear_interrupt(struct phy_device *phydev) 92 { 93 if (phydev->drv->ack_interrupt) 94 return phydev->drv->ack_interrupt(phydev); 95 96 return 0; 97 } 98 99 /** 100 * phy_config_interrupt - configure the PHY device for the requested interrupts 101 * @phydev: the phy_device struct 102 * @interrupts: interrupt flags to configure for this @phydev 103 * 104 * Returns 0 on success or < 0 on error. 105 */ 106 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts) 107 { 108 phydev->interrupts = interrupts ? 1 : 0; 109 if (phydev->drv->config_intr) 110 return phydev->drv->config_intr(phydev); 111 112 return 0; 113 } 114 115 /** 116 * phy_restart_aneg - restart auto-negotiation 117 * @phydev: target phy_device struct 118 * 119 * Restart the autonegotiation on @phydev. Returns >= 0 on success or 120 * negative errno on error. 121 */ 122 int phy_restart_aneg(struct phy_device *phydev) 123 { 124 int ret; 125 126 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0))) 127 ret = genphy_c45_restart_aneg(phydev); 128 else 129 ret = genphy_restart_aneg(phydev); 130 131 return ret; 132 } 133 EXPORT_SYMBOL_GPL(phy_restart_aneg); 134 135 /** 136 * phy_aneg_done - return auto-negotiation status 137 * @phydev: target phy_device struct 138 * 139 * Description: Return the auto-negotiation status from this @phydev 140 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation 141 * is still pending. 142 */ 143 int phy_aneg_done(struct phy_device *phydev) 144 { 145 if (phydev->drv && phydev->drv->aneg_done) 146 return phydev->drv->aneg_done(phydev); 147 else if (phydev->is_c45) 148 return genphy_c45_aneg_done(phydev); 149 else 150 return genphy_aneg_done(phydev); 151 } 152 EXPORT_SYMBOL(phy_aneg_done); 153 154 /** 155 * phy_find_valid - find a PHY setting that matches the requested parameters 156 * @speed: desired speed 157 * @duplex: desired duplex 158 * @supported: mask of supported link modes 159 * 160 * Locate a supported phy setting that is, in priority order: 161 * - an exact match for the specified speed and duplex mode 162 * - a match for the specified speed, or slower speed 163 * - the slowest supported speed 164 * Returns the matched phy_setting entry, or %NULL if no supported phy 165 * settings were found. 166 */ 167 static const struct phy_setting * 168 phy_find_valid(int speed, int duplex, unsigned long *supported) 169 { 170 return phy_lookup_setting(speed, duplex, supported, false); 171 } 172 173 /** 174 * phy_supported_speeds - return all speeds currently supported by a phy device 175 * @phy: The phy device to return supported speeds of. 176 * @speeds: buffer to store supported speeds in. 177 * @size: size of speeds buffer. 178 * 179 * Description: Returns the number of supported speeds, and fills the speeds 180 * buffer with the supported speeds. If speeds buffer is too small to contain 181 * all currently supported speeds, will return as many speeds as can fit. 182 */ 183 unsigned int phy_supported_speeds(struct phy_device *phy, 184 unsigned int *speeds, 185 unsigned int size) 186 { 187 return phy_speeds(speeds, size, phy->supported); 188 } 189 190 /** 191 * phy_check_valid - check if there is a valid PHY setting which matches 192 * speed, duplex, and feature mask 193 * @speed: speed to match 194 * @duplex: duplex to match 195 * @features: A mask of the valid settings 196 * 197 * Description: Returns true if there is a valid setting, false otherwise. 198 */ 199 static inline bool phy_check_valid(int speed, int duplex, 200 unsigned long *features) 201 { 202 return !!phy_lookup_setting(speed, duplex, features, true); 203 } 204 205 /** 206 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex 207 * @phydev: the target phy_device struct 208 * 209 * Description: Make sure the PHY is set to supported speeds and 210 * duplexes. Drop down by one in this order: 1000/FULL, 211 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 212 */ 213 static void phy_sanitize_settings(struct phy_device *phydev) 214 { 215 const struct phy_setting *setting; 216 217 /* Sanitize settings based on PHY capabilities */ 218 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported)) 219 phydev->autoneg = AUTONEG_DISABLE; 220 221 setting = phy_find_valid(phydev->speed, phydev->duplex, 222 phydev->supported); 223 if (setting) { 224 phydev->speed = setting->speed; 225 phydev->duplex = setting->duplex; 226 } else { 227 /* We failed to find anything (no supported speeds?) */ 228 phydev->speed = SPEED_UNKNOWN; 229 phydev->duplex = DUPLEX_UNKNOWN; 230 } 231 } 232 233 /** 234 * phy_ethtool_sset - generic ethtool sset function, handles all the details 235 * @phydev: target phy_device struct 236 * @cmd: ethtool_cmd 237 * 238 * A few notes about parameter checking: 239 * 240 * - We don't set port or transceiver, so we don't care what they 241 * were set to. 242 * - phy_start_aneg() will make sure forced settings are sane, and 243 * choose the next best ones from the ones selected, so we don't 244 * care if ethtool tries to give us bad values. 245 */ 246 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd) 247 { 248 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising); 249 u32 speed = ethtool_cmd_speed(cmd); 250 251 if (cmd->phy_address != phydev->mdio.addr) 252 return -EINVAL; 253 254 /* We make sure that we don't pass unsupported values in to the PHY */ 255 ethtool_convert_legacy_u32_to_link_mode(advertising, cmd->advertising); 256 linkmode_and(advertising, advertising, phydev->supported); 257 258 /* Verify the settings we care about. */ 259 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) 260 return -EINVAL; 261 262 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) 263 return -EINVAL; 264 265 if (cmd->autoneg == AUTONEG_DISABLE && 266 ((speed != SPEED_1000 && 267 speed != SPEED_100 && 268 speed != SPEED_10) || 269 (cmd->duplex != DUPLEX_HALF && 270 cmd->duplex != DUPLEX_FULL))) 271 return -EINVAL; 272 273 phydev->autoneg = cmd->autoneg; 274 275 phydev->speed = speed; 276 277 linkmode_copy(phydev->advertising, advertising); 278 279 if (AUTONEG_ENABLE == cmd->autoneg) 280 linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 281 phydev->advertising); 282 else 283 linkmode_clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 284 phydev->advertising); 285 286 phydev->duplex = cmd->duplex; 287 288 phydev->mdix_ctrl = cmd->eth_tp_mdix_ctrl; 289 290 /* Restart the PHY */ 291 phy_start_aneg(phydev); 292 293 return 0; 294 } 295 EXPORT_SYMBOL(phy_ethtool_sset); 296 297 int phy_ethtool_ksettings_set(struct phy_device *phydev, 298 const struct ethtool_link_ksettings *cmd) 299 { 300 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising); 301 u8 autoneg = cmd->base.autoneg; 302 u8 duplex = cmd->base.duplex; 303 u32 speed = cmd->base.speed; 304 305 if (cmd->base.phy_address != phydev->mdio.addr) 306 return -EINVAL; 307 308 linkmode_copy(advertising, cmd->link_modes.advertising); 309 310 /* We make sure that we don't pass unsupported values in to the PHY */ 311 linkmode_and(advertising, advertising, phydev->supported); 312 313 /* Verify the settings we care about. */ 314 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE) 315 return -EINVAL; 316 317 if (autoneg == AUTONEG_ENABLE && linkmode_empty(advertising)) 318 return -EINVAL; 319 320 if (autoneg == AUTONEG_DISABLE && 321 ((speed != SPEED_1000 && 322 speed != SPEED_100 && 323 speed != SPEED_10) || 324 (duplex != DUPLEX_HALF && 325 duplex != DUPLEX_FULL))) 326 return -EINVAL; 327 328 phydev->autoneg = autoneg; 329 330 phydev->speed = speed; 331 332 linkmode_copy(phydev->advertising, advertising); 333 334 if (autoneg == AUTONEG_ENABLE) 335 linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 336 phydev->advertising); 337 else 338 linkmode_clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 339 phydev->advertising); 340 341 phydev->duplex = duplex; 342 343 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl; 344 345 /* Restart the PHY */ 346 phy_start_aneg(phydev); 347 348 return 0; 349 } 350 EXPORT_SYMBOL(phy_ethtool_ksettings_set); 351 352 void phy_ethtool_ksettings_get(struct phy_device *phydev, 353 struct ethtool_link_ksettings *cmd) 354 { 355 linkmode_copy(cmd->link_modes.supported, phydev->supported); 356 linkmode_copy(cmd->link_modes.advertising, phydev->advertising); 357 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising); 358 359 cmd->base.speed = phydev->speed; 360 cmd->base.duplex = phydev->duplex; 361 if (phydev->interface == PHY_INTERFACE_MODE_MOCA) 362 cmd->base.port = PORT_BNC; 363 else 364 cmd->base.port = PORT_MII; 365 cmd->base.transceiver = phy_is_internal(phydev) ? 366 XCVR_INTERNAL : XCVR_EXTERNAL; 367 cmd->base.phy_address = phydev->mdio.addr; 368 cmd->base.autoneg = phydev->autoneg; 369 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl; 370 cmd->base.eth_tp_mdix = phydev->mdix; 371 } 372 EXPORT_SYMBOL(phy_ethtool_ksettings_get); 373 374 /** 375 * phy_mii_ioctl - generic PHY MII ioctl interface 376 * @phydev: the phy_device struct 377 * @ifr: &struct ifreq for socket ioctl's 378 * @cmd: ioctl cmd to execute 379 * 380 * Note that this function is currently incompatible with the 381 * PHYCONTROL layer. It changes registers without regard to 382 * current state. Use at own risk. 383 */ 384 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd) 385 { 386 struct mii_ioctl_data *mii_data = if_mii(ifr); 387 u16 val = mii_data->val_in; 388 bool change_autoneg = false; 389 390 switch (cmd) { 391 case SIOCGMIIPHY: 392 mii_data->phy_id = phydev->mdio.addr; 393 /* fall through */ 394 395 case SIOCGMIIREG: 396 mii_data->val_out = mdiobus_read(phydev->mdio.bus, 397 mii_data->phy_id, 398 mii_data->reg_num); 399 return 0; 400 401 case SIOCSMIIREG: 402 if (mii_data->phy_id == phydev->mdio.addr) { 403 switch (mii_data->reg_num) { 404 case MII_BMCR: 405 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) { 406 if (phydev->autoneg == AUTONEG_ENABLE) 407 change_autoneg = true; 408 phydev->autoneg = AUTONEG_DISABLE; 409 if (val & BMCR_FULLDPLX) 410 phydev->duplex = DUPLEX_FULL; 411 else 412 phydev->duplex = DUPLEX_HALF; 413 if (val & BMCR_SPEED1000) 414 phydev->speed = SPEED_1000; 415 else if (val & BMCR_SPEED100) 416 phydev->speed = SPEED_100; 417 else phydev->speed = SPEED_10; 418 } 419 else { 420 if (phydev->autoneg == AUTONEG_DISABLE) 421 change_autoneg = true; 422 phydev->autoneg = AUTONEG_ENABLE; 423 } 424 break; 425 case MII_ADVERTISE: 426 mii_adv_mod_linkmode_adv_t(phydev->advertising, 427 val); 428 change_autoneg = true; 429 break; 430 default: 431 /* do nothing */ 432 break; 433 } 434 } 435 436 mdiobus_write(phydev->mdio.bus, mii_data->phy_id, 437 mii_data->reg_num, val); 438 439 if (mii_data->phy_id == phydev->mdio.addr && 440 mii_data->reg_num == MII_BMCR && 441 val & BMCR_RESET) 442 return phy_init_hw(phydev); 443 444 if (change_autoneg) 445 return phy_start_aneg(phydev); 446 447 return 0; 448 449 case SIOCSHWTSTAMP: 450 if (phydev->drv && phydev->drv->hwtstamp) 451 return phydev->drv->hwtstamp(phydev, ifr); 452 /* fall through */ 453 454 default: 455 return -EOPNOTSUPP; 456 } 457 } 458 EXPORT_SYMBOL(phy_mii_ioctl); 459 460 static void phy_queue_state_machine(struct phy_device *phydev, 461 unsigned int secs) 462 { 463 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue, 464 secs * HZ); 465 } 466 467 static void phy_trigger_machine(struct phy_device *phydev) 468 { 469 phy_queue_state_machine(phydev, 0); 470 } 471 472 static int phy_config_aneg(struct phy_device *phydev) 473 { 474 if (phydev->drv->config_aneg) 475 return phydev->drv->config_aneg(phydev); 476 477 /* Clause 45 PHYs that don't implement Clause 22 registers are not 478 * allowed to call genphy_config_aneg() 479 */ 480 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0))) 481 return -EOPNOTSUPP; 482 483 return genphy_config_aneg(phydev); 484 } 485 486 /** 487 * phy_check_link_status - check link status and set state accordingly 488 * @phydev: the phy_device struct 489 * 490 * Description: Check for link and whether autoneg was triggered / is running 491 * and set state accordingly 492 */ 493 static int phy_check_link_status(struct phy_device *phydev) 494 { 495 int err; 496 497 WARN_ON(!mutex_is_locked(&phydev->lock)); 498 499 err = phy_read_status(phydev); 500 if (err) 501 return err; 502 503 if (phydev->link && phydev->state != PHY_RUNNING) { 504 phydev->state = PHY_RUNNING; 505 phy_link_up(phydev); 506 } else if (!phydev->link && phydev->state != PHY_NOLINK) { 507 phydev->state = PHY_NOLINK; 508 phy_link_down(phydev, true); 509 } 510 511 return 0; 512 } 513 514 /** 515 * phy_start_aneg - start auto-negotiation for this PHY device 516 * @phydev: the phy_device struct 517 * 518 * Description: Sanitizes the settings (if we're not autonegotiating 519 * them), and then calls the driver's config_aneg function. 520 * If the PHYCONTROL Layer is operating, we change the state to 521 * reflect the beginning of Auto-negotiation or forcing. 522 */ 523 int phy_start_aneg(struct phy_device *phydev) 524 { 525 int err; 526 527 if (!phydev->drv) 528 return -EIO; 529 530 mutex_lock(&phydev->lock); 531 532 if (AUTONEG_DISABLE == phydev->autoneg) 533 phy_sanitize_settings(phydev); 534 535 /* Invalidate LP advertising flags */ 536 linkmode_zero(phydev->lp_advertising); 537 538 err = phy_config_aneg(phydev); 539 if (err < 0) 540 goto out_unlock; 541 542 if (phy_is_started(phydev)) { 543 if (phydev->autoneg == AUTONEG_ENABLE) { 544 err = phy_check_link_status(phydev); 545 } else { 546 phydev->state = PHY_FORCING; 547 phydev->link_timeout = PHY_FORCE_TIMEOUT; 548 } 549 } 550 551 out_unlock: 552 mutex_unlock(&phydev->lock); 553 554 return err; 555 } 556 EXPORT_SYMBOL(phy_start_aneg); 557 558 static int phy_poll_aneg_done(struct phy_device *phydev) 559 { 560 unsigned int retries = 100; 561 int ret; 562 563 do { 564 msleep(100); 565 ret = phy_aneg_done(phydev); 566 } while (!ret && --retries); 567 568 if (!ret) 569 return -ETIMEDOUT; 570 571 return ret < 0 ? ret : 0; 572 } 573 574 /** 575 * phy_speed_down - set speed to lowest speed supported by both link partners 576 * @phydev: the phy_device struct 577 * @sync: perform action synchronously 578 * 579 * Description: Typically used to save energy when waiting for a WoL packet 580 * 581 * WARNING: Setting sync to false may cause the system being unable to suspend 582 * in case the PHY generates an interrupt when finishing the autonegotiation. 583 * This interrupt may wake up the system immediately after suspend. 584 * Therefore use sync = false only if you're sure it's safe with the respective 585 * network chip. 586 */ 587 int phy_speed_down(struct phy_device *phydev, bool sync) 588 { 589 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_old); 590 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv); 591 int ret; 592 593 if (phydev->autoneg != AUTONEG_ENABLE) 594 return 0; 595 596 linkmode_copy(adv_old, phydev->advertising); 597 linkmode_copy(adv, phydev->lp_advertising); 598 linkmode_and(adv, adv, phydev->supported); 599 600 if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, adv) || 601 linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, adv)) { 602 linkmode_clear_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, 603 phydev->advertising); 604 linkmode_clear_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 605 phydev->advertising); 606 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 607 phydev->advertising); 608 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 609 phydev->advertising); 610 } else if (linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, 611 adv) || 612 linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 613 adv)) { 614 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 615 phydev->advertising); 616 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 617 phydev->advertising); 618 } 619 620 if (linkmode_equal(phydev->advertising, adv_old)) 621 return 0; 622 623 ret = phy_config_aneg(phydev); 624 if (ret) 625 return ret; 626 627 return sync ? phy_poll_aneg_done(phydev) : 0; 628 } 629 EXPORT_SYMBOL_GPL(phy_speed_down); 630 631 /** 632 * phy_speed_up - (re)set advertised speeds to all supported speeds 633 * @phydev: the phy_device struct 634 * 635 * Description: Used to revert the effect of phy_speed_down 636 */ 637 int phy_speed_up(struct phy_device *phydev) 638 { 639 __ETHTOOL_DECLARE_LINK_MODE_MASK(all_speeds) = { 0, }; 640 __ETHTOOL_DECLARE_LINK_MODE_MASK(not_speeds); 641 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 642 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_old); 643 __ETHTOOL_DECLARE_LINK_MODE_MASK(speeds); 644 645 linkmode_copy(adv_old, phydev->advertising); 646 647 if (phydev->autoneg != AUTONEG_ENABLE) 648 return 0; 649 650 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, all_speeds); 651 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, all_speeds); 652 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, all_speeds); 653 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, all_speeds); 654 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, all_speeds); 655 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, all_speeds); 656 657 linkmode_andnot(not_speeds, adv_old, all_speeds); 658 linkmode_copy(supported, phydev->supported); 659 linkmode_and(speeds, supported, all_speeds); 660 linkmode_or(phydev->advertising, not_speeds, speeds); 661 662 if (linkmode_equal(phydev->advertising, adv_old)) 663 return 0; 664 665 return phy_config_aneg(phydev); 666 } 667 EXPORT_SYMBOL_GPL(phy_speed_up); 668 669 /** 670 * phy_start_machine - start PHY state machine tracking 671 * @phydev: the phy_device struct 672 * 673 * Description: The PHY infrastructure can run a state machine 674 * which tracks whether the PHY is starting up, negotiating, 675 * etc. This function starts the delayed workqueue which tracks 676 * the state of the PHY. If you want to maintain your own state machine, 677 * do not call this function. 678 */ 679 void phy_start_machine(struct phy_device *phydev) 680 { 681 phy_trigger_machine(phydev); 682 } 683 EXPORT_SYMBOL_GPL(phy_start_machine); 684 685 /** 686 * phy_stop_machine - stop the PHY state machine tracking 687 * @phydev: target phy_device struct 688 * 689 * Description: Stops the state machine delayed workqueue, sets the 690 * state to UP (unless it wasn't up yet). This function must be 691 * called BEFORE phy_detach. 692 */ 693 void phy_stop_machine(struct phy_device *phydev) 694 { 695 cancel_delayed_work_sync(&phydev->state_queue); 696 697 mutex_lock(&phydev->lock); 698 if (phy_is_started(phydev)) 699 phydev->state = PHY_UP; 700 mutex_unlock(&phydev->lock); 701 } 702 703 /** 704 * phy_error - enter HALTED state for this PHY device 705 * @phydev: target phy_device struct 706 * 707 * Moves the PHY to the HALTED state in response to a read 708 * or write error, and tells the controller the link is down. 709 * Must not be called from interrupt context, or while the 710 * phydev->lock is held. 711 */ 712 static void phy_error(struct phy_device *phydev) 713 { 714 WARN_ON(1); 715 716 mutex_lock(&phydev->lock); 717 phydev->state = PHY_HALTED; 718 mutex_unlock(&phydev->lock); 719 720 phy_trigger_machine(phydev); 721 } 722 723 /** 724 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side 725 * @phydev: target phy_device struct 726 */ 727 static int phy_disable_interrupts(struct phy_device *phydev) 728 { 729 int err; 730 731 /* Disable PHY interrupts */ 732 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 733 if (err) 734 return err; 735 736 /* Clear the interrupt */ 737 return phy_clear_interrupt(phydev); 738 } 739 740 /** 741 * phy_interrupt - PHY interrupt handler 742 * @irq: interrupt line 743 * @phy_dat: phy_device pointer 744 * 745 * Description: Handle PHY interrupt 746 */ 747 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 748 { 749 struct phy_device *phydev = phy_dat; 750 751 if (phydev->drv->did_interrupt && !phydev->drv->did_interrupt(phydev)) 752 return IRQ_NONE; 753 754 /* reschedule state queue work to run as soon as possible */ 755 phy_trigger_machine(phydev); 756 757 if (phy_clear_interrupt(phydev)) 758 goto phy_err; 759 return IRQ_HANDLED; 760 761 phy_err: 762 phy_error(phydev); 763 return IRQ_NONE; 764 } 765 766 /** 767 * phy_enable_interrupts - Enable the interrupts from the PHY side 768 * @phydev: target phy_device struct 769 */ 770 static int phy_enable_interrupts(struct phy_device *phydev) 771 { 772 int err = phy_clear_interrupt(phydev); 773 774 if (err < 0) 775 return err; 776 777 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 778 } 779 780 /** 781 * phy_request_interrupt - request interrupt for a PHY device 782 * @phydev: target phy_device struct 783 * 784 * Description: Request the interrupt for the given PHY. 785 * If this fails, then we set irq to PHY_POLL. 786 * This should only be called with a valid IRQ number. 787 */ 788 void phy_request_interrupt(struct phy_device *phydev) 789 { 790 int err; 791 792 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt, 793 IRQF_ONESHOT | IRQF_SHARED, 794 phydev_name(phydev), phydev); 795 if (err) { 796 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n", 797 err, phydev->irq); 798 phydev->irq = PHY_POLL; 799 } 800 } 801 EXPORT_SYMBOL(phy_request_interrupt); 802 803 /** 804 * phy_stop - Bring down the PHY link, and stop checking the status 805 * @phydev: target phy_device struct 806 */ 807 void phy_stop(struct phy_device *phydev) 808 { 809 if (!phy_is_started(phydev)) { 810 WARN(1, "called from state %s\n", 811 phy_state_to_str(phydev->state)); 812 return; 813 } 814 815 mutex_lock(&phydev->lock); 816 817 if (phy_interrupt_is_valid(phydev)) 818 phy_disable_interrupts(phydev); 819 820 phydev->state = PHY_HALTED; 821 822 mutex_unlock(&phydev->lock); 823 824 phy_state_machine(&phydev->state_queue.work); 825 phy_stop_machine(phydev); 826 827 /* Cannot call flush_scheduled_work() here as desired because 828 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler 829 * will not reenable interrupts. 830 */ 831 } 832 EXPORT_SYMBOL(phy_stop); 833 834 /** 835 * phy_start - start or restart a PHY device 836 * @phydev: target phy_device struct 837 * 838 * Description: Indicates the attached device's readiness to 839 * handle PHY-related work. Used during startup to start the 840 * PHY, and after a call to phy_stop() to resume operation. 841 * Also used to indicate the MDIO bus has cleared an error 842 * condition. 843 */ 844 void phy_start(struct phy_device *phydev) 845 { 846 int err; 847 848 mutex_lock(&phydev->lock); 849 850 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) { 851 WARN(1, "called from state %s\n", 852 phy_state_to_str(phydev->state)); 853 goto out; 854 } 855 856 /* if phy was suspended, bring the physical link up again */ 857 __phy_resume(phydev); 858 859 /* make sure interrupts are enabled for the PHY */ 860 if (phy_interrupt_is_valid(phydev)) { 861 err = phy_enable_interrupts(phydev); 862 if (err < 0) 863 goto out; 864 } 865 866 if (phydev->state == PHY_READY) 867 phydev->state = PHY_UP; 868 else 869 phydev->state = PHY_RESUMING; 870 871 phy_start_machine(phydev); 872 out: 873 mutex_unlock(&phydev->lock); 874 } 875 EXPORT_SYMBOL(phy_start); 876 877 /** 878 * phy_state_machine - Handle the state machine 879 * @work: work_struct that describes the work to be done 880 */ 881 void phy_state_machine(struct work_struct *work) 882 { 883 struct delayed_work *dwork = to_delayed_work(work); 884 struct phy_device *phydev = 885 container_of(dwork, struct phy_device, state_queue); 886 bool needs_aneg = false, do_suspend = false; 887 enum phy_state old_state; 888 int err = 0; 889 890 mutex_lock(&phydev->lock); 891 892 old_state = phydev->state; 893 894 if (phydev->drv && phydev->drv->link_change_notify) 895 phydev->drv->link_change_notify(phydev); 896 897 switch (phydev->state) { 898 case PHY_DOWN: 899 case PHY_READY: 900 break; 901 case PHY_UP: 902 needs_aneg = true; 903 904 break; 905 case PHY_NOLINK: 906 case PHY_RUNNING: 907 case PHY_RESUMING: 908 err = phy_check_link_status(phydev); 909 break; 910 case PHY_FORCING: 911 err = genphy_update_link(phydev); 912 if (err) 913 break; 914 915 if (phydev->link) { 916 phydev->state = PHY_RUNNING; 917 phy_link_up(phydev); 918 } else { 919 if (0 == phydev->link_timeout--) 920 needs_aneg = true; 921 phy_link_down(phydev, false); 922 } 923 break; 924 case PHY_HALTED: 925 if (phydev->link) { 926 phydev->link = 0; 927 phy_link_down(phydev, true); 928 do_suspend = true; 929 } 930 break; 931 } 932 933 mutex_unlock(&phydev->lock); 934 935 if (needs_aneg) 936 err = phy_start_aneg(phydev); 937 else if (do_suspend) 938 phy_suspend(phydev); 939 940 if (err < 0) 941 phy_error(phydev); 942 943 if (old_state != phydev->state) 944 phydev_dbg(phydev, "PHY state change %s -> %s\n", 945 phy_state_to_str(old_state), 946 phy_state_to_str(phydev->state)); 947 948 /* Only re-schedule a PHY state machine change if we are polling the 949 * PHY, if PHY_IGNORE_INTERRUPT is set, then we will be moving 950 * between states from phy_mac_interrupt(). 951 * 952 * In state PHY_HALTED the PHY gets suspended, so rescheduling the 953 * state machine would be pointless and possibly error prone when 954 * called from phy_disconnect() synchronously. 955 */ 956 mutex_lock(&phydev->lock); 957 if (phy_polling_mode(phydev) && phy_is_started(phydev)) 958 phy_queue_state_machine(phydev, PHY_STATE_TIME); 959 mutex_unlock(&phydev->lock); 960 } 961 962 /** 963 * phy_mac_interrupt - MAC says the link has changed 964 * @phydev: phy_device struct with changed link 965 * 966 * The MAC layer is able to indicate there has been a change in the PHY link 967 * status. Trigger the state machine and work a work queue. 968 */ 969 void phy_mac_interrupt(struct phy_device *phydev) 970 { 971 /* Trigger a state machine change */ 972 phy_trigger_machine(phydev); 973 } 974 EXPORT_SYMBOL(phy_mac_interrupt); 975 976 static void mmd_eee_adv_to_linkmode(unsigned long *advertising, u16 eee_adv) 977 { 978 linkmode_zero(advertising); 979 980 if (eee_adv & MDIO_EEE_100TX) 981 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 982 advertising); 983 if (eee_adv & MDIO_EEE_1000T) 984 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 985 advertising); 986 if (eee_adv & MDIO_EEE_10GT) 987 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 988 advertising); 989 if (eee_adv & MDIO_EEE_1000KX) 990 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, 991 advertising); 992 if (eee_adv & MDIO_EEE_10GKX4) 993 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, 994 advertising); 995 if (eee_adv & MDIO_EEE_10GKR) 996 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, 997 advertising); 998 } 999 1000 /** 1001 * phy_init_eee - init and check the EEE feature 1002 * @phydev: target phy_device struct 1003 * @clk_stop_enable: PHY may stop the clock during LPI 1004 * 1005 * Description: it checks if the Energy-Efficient Ethernet (EEE) 1006 * is supported by looking at the MMD registers 3.20 and 7.60/61 1007 * and it programs the MMD register 3.0 setting the "Clock stop enable" 1008 * bit if required. 1009 */ 1010 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 1011 { 1012 if (!phydev->drv) 1013 return -EIO; 1014 1015 /* According to 802.3az,the EEE is supported only in full duplex-mode. 1016 */ 1017 if (phydev->duplex == DUPLEX_FULL) { 1018 __ETHTOOL_DECLARE_LINK_MODE_MASK(common); 1019 __ETHTOOL_DECLARE_LINK_MODE_MASK(lp); 1020 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv); 1021 int eee_lp, eee_cap, eee_adv; 1022 int status; 1023 u32 cap; 1024 1025 /* Read phy status to properly get the right settings */ 1026 status = phy_read_status(phydev); 1027 if (status) 1028 return status; 1029 1030 /* First check if the EEE ability is supported */ 1031 eee_cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 1032 if (eee_cap <= 0) 1033 goto eee_exit_err; 1034 1035 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap); 1036 if (!cap) 1037 goto eee_exit_err; 1038 1039 /* Check which link settings negotiated and verify it in 1040 * the EEE advertising registers. 1041 */ 1042 eee_lp = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE); 1043 if (eee_lp <= 0) 1044 goto eee_exit_err; 1045 1046 eee_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV); 1047 if (eee_adv <= 0) 1048 goto eee_exit_err; 1049 1050 mmd_eee_adv_to_linkmode(adv, eee_adv); 1051 mmd_eee_adv_to_linkmode(lp, eee_lp); 1052 linkmode_and(common, adv, lp); 1053 1054 if (!phy_check_valid(phydev->speed, phydev->duplex, common)) 1055 goto eee_exit_err; 1056 1057 if (clk_stop_enable) 1058 /* Configure the PHY to stop receiving xMII 1059 * clock while it is signaling LPI. 1060 */ 1061 phy_set_bits_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1, 1062 MDIO_PCS_CTRL1_CLKSTOP_EN); 1063 1064 return 0; /* EEE supported */ 1065 } 1066 eee_exit_err: 1067 return -EPROTONOSUPPORT; 1068 } 1069 EXPORT_SYMBOL(phy_init_eee); 1070 1071 /** 1072 * phy_get_eee_err - report the EEE wake error count 1073 * @phydev: target phy_device struct 1074 * 1075 * Description: it is to report the number of time where the PHY 1076 * failed to complete its normal wake sequence. 1077 */ 1078 int phy_get_eee_err(struct phy_device *phydev) 1079 { 1080 if (!phydev->drv) 1081 return -EIO; 1082 1083 return phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR); 1084 } 1085 EXPORT_SYMBOL(phy_get_eee_err); 1086 1087 /** 1088 * phy_ethtool_get_eee - get EEE supported and status 1089 * @phydev: target phy_device struct 1090 * @data: ethtool_eee data 1091 * 1092 * Description: it reportes the Supported/Advertisement/LP Advertisement 1093 * capabilities. 1094 */ 1095 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data) 1096 { 1097 int val; 1098 1099 if (!phydev->drv) 1100 return -EIO; 1101 1102 /* Get Supported EEE */ 1103 val = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 1104 if (val < 0) 1105 return val; 1106 data->supported = mmd_eee_cap_to_ethtool_sup_t(val); 1107 1108 /* Get advertisement EEE */ 1109 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV); 1110 if (val < 0) 1111 return val; 1112 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1113 data->eee_enabled = !!data->advertised; 1114 1115 /* Get LP advertisement EEE */ 1116 val = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE); 1117 if (val < 0) 1118 return val; 1119 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1120 1121 data->eee_active = !!(data->advertised & data->lp_advertised); 1122 1123 return 0; 1124 } 1125 EXPORT_SYMBOL(phy_ethtool_get_eee); 1126 1127 /** 1128 * phy_ethtool_set_eee - set EEE supported and status 1129 * @phydev: target phy_device struct 1130 * @data: ethtool_eee data 1131 * 1132 * Description: it is to program the Advertisement EEE register. 1133 */ 1134 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data) 1135 { 1136 int cap, old_adv, adv = 0, ret; 1137 1138 if (!phydev->drv) 1139 return -EIO; 1140 1141 /* Get Supported EEE */ 1142 cap = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 1143 if (cap < 0) 1144 return cap; 1145 1146 old_adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV); 1147 if (old_adv < 0) 1148 return old_adv; 1149 1150 if (data->eee_enabled) { 1151 adv = !data->advertised ? cap : 1152 ethtool_adv_to_mmd_eee_adv_t(data->advertised) & cap; 1153 /* Mask prohibited EEE modes */ 1154 adv &= ~phydev->eee_broken_modes; 1155 } 1156 1157 if (old_adv != adv) { 1158 ret = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv); 1159 if (ret < 0) 1160 return ret; 1161 1162 /* Restart autonegotiation so the new modes get sent to the 1163 * link partner. 1164 */ 1165 ret = phy_restart_aneg(phydev); 1166 if (ret < 0) 1167 return ret; 1168 } 1169 1170 return 0; 1171 } 1172 EXPORT_SYMBOL(phy_ethtool_set_eee); 1173 1174 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1175 { 1176 if (phydev->drv && phydev->drv->set_wol) 1177 return phydev->drv->set_wol(phydev, wol); 1178 1179 return -EOPNOTSUPP; 1180 } 1181 EXPORT_SYMBOL(phy_ethtool_set_wol); 1182 1183 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1184 { 1185 if (phydev->drv && phydev->drv->get_wol) 1186 phydev->drv->get_wol(phydev, wol); 1187 } 1188 EXPORT_SYMBOL(phy_ethtool_get_wol); 1189 1190 int phy_ethtool_get_link_ksettings(struct net_device *ndev, 1191 struct ethtool_link_ksettings *cmd) 1192 { 1193 struct phy_device *phydev = ndev->phydev; 1194 1195 if (!phydev) 1196 return -ENODEV; 1197 1198 phy_ethtool_ksettings_get(phydev, cmd); 1199 1200 return 0; 1201 } 1202 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings); 1203 1204 int phy_ethtool_set_link_ksettings(struct net_device *ndev, 1205 const struct ethtool_link_ksettings *cmd) 1206 { 1207 struct phy_device *phydev = ndev->phydev; 1208 1209 if (!phydev) 1210 return -ENODEV; 1211 1212 return phy_ethtool_ksettings_set(phydev, cmd); 1213 } 1214 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings); 1215 1216 int phy_ethtool_nway_reset(struct net_device *ndev) 1217 { 1218 struct phy_device *phydev = ndev->phydev; 1219 1220 if (!phydev) 1221 return -ENODEV; 1222 1223 if (!phydev->drv) 1224 return -EIO; 1225 1226 return phy_restart_aneg(phydev); 1227 } 1228 EXPORT_SYMBOL(phy_ethtool_nway_reset); 1229