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 #include "phylib-internal.h" 40 #include "phy-caps.h" 41 42 #define PHY_STATE_TIME HZ 43 44 #define PHY_STATE_STR(_state) \ 45 case PHY_##_state: \ 46 return __stringify(_state); \ 47 48 static const char *phy_state_to_str(enum phy_state st) 49 { 50 switch (st) { 51 PHY_STATE_STR(DOWN) 52 PHY_STATE_STR(READY) 53 PHY_STATE_STR(UP) 54 PHY_STATE_STR(RUNNING) 55 PHY_STATE_STR(NOLINK) 56 PHY_STATE_STR(CABLETEST) 57 PHY_STATE_STR(HALTED) 58 PHY_STATE_STR(ERROR) 59 } 60 61 return NULL; 62 } 63 64 static void phy_process_state_change(struct phy_device *phydev, 65 enum phy_state old_state) 66 { 67 if (old_state != phydev->state) { 68 phydev_dbg(phydev, "PHY state change %s -> %s\n", 69 phy_state_to_str(old_state), 70 phy_state_to_str(phydev->state)); 71 if (phydev->drv && phydev->drv->link_change_notify) 72 phydev->drv->link_change_notify(phydev); 73 } 74 } 75 76 static void phy_link_up(struct phy_device *phydev) 77 { 78 phydev->phy_link_change(phydev, true); 79 phy_led_trigger_change_speed(phydev); 80 } 81 82 static void phy_link_down(struct phy_device *phydev) 83 { 84 phydev->phy_link_change(phydev, false); 85 phy_led_trigger_change_speed(phydev); 86 WRITE_ONCE(phydev->link_down_events, phydev->link_down_events + 1); 87 } 88 89 static const char *phy_pause_str(struct phy_device *phydev) 90 { 91 bool local_pause, local_asym_pause; 92 93 if (phydev->autoneg == AUTONEG_DISABLE) 94 goto no_pause; 95 96 local_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 97 phydev->advertising); 98 local_asym_pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 99 phydev->advertising); 100 101 if (local_pause && phydev->pause) 102 return "rx/tx"; 103 104 if (local_asym_pause && phydev->asym_pause) { 105 if (local_pause) 106 return "rx"; 107 if (phydev->pause) 108 return "tx"; 109 } 110 111 no_pause: 112 return "off"; 113 } 114 115 /** 116 * phy_print_status - Convenience function to print out the current phy status 117 * @phydev: the phy_device struct 118 */ 119 void phy_print_status(struct phy_device *phydev) 120 { 121 if (phydev->link) { 122 netdev_info(phydev->attached_dev, 123 "Link is Up - %s/%s %s- flow control %s\n", 124 phy_speed_to_str(phydev->speed), 125 phy_duplex_to_str(phydev->duplex), 126 phydev->downshifted_rate ? "(downshifted) " : "", 127 phy_pause_str(phydev)); 128 } else { 129 netdev_info(phydev->attached_dev, "Link is Down\n"); 130 } 131 } 132 EXPORT_SYMBOL(phy_print_status); 133 134 /** 135 * phy_get_rate_matching - determine if rate matching is supported 136 * @phydev: The phy device to return rate matching for 137 * @iface: The interface mode to use 138 * 139 * This determines the type of rate matching (if any) that @phy supports 140 * using @iface. @iface may be %PHY_INTERFACE_MODE_NA to determine if any 141 * interface supports rate matching. 142 * 143 * Return: The type of rate matching @phy supports for @iface, or 144 * %RATE_MATCH_NONE. 145 */ 146 int phy_get_rate_matching(struct phy_device *phydev, 147 phy_interface_t iface) 148 { 149 int ret = RATE_MATCH_NONE; 150 151 if (phydev->drv->get_rate_matching) { 152 mutex_lock(&phydev->lock); 153 ret = phydev->drv->get_rate_matching(phydev, iface); 154 mutex_unlock(&phydev->lock); 155 } 156 157 return ret; 158 } 159 EXPORT_SYMBOL_GPL(phy_get_rate_matching); 160 161 /** 162 * phy_config_interrupt - configure the PHY device for the requested interrupts 163 * @phydev: the phy_device struct 164 * @interrupts: interrupt flags to configure for this @phydev 165 * 166 * Returns 0 on success or < 0 on error. 167 */ 168 static int phy_config_interrupt(struct phy_device *phydev, bool interrupts) 169 { 170 phydev->interrupts = interrupts ? 1 : 0; 171 if (phydev->drv->config_intr) 172 return phydev->drv->config_intr(phydev); 173 174 return 0; 175 } 176 177 /** 178 * phy_restart_aneg - restart auto-negotiation 179 * @phydev: target phy_device struct 180 * 181 * Restart the autonegotiation on @phydev. Returns >= 0 on success or 182 * negative errno on error. 183 */ 184 int phy_restart_aneg(struct phy_device *phydev) 185 { 186 int ret; 187 188 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0))) 189 ret = genphy_c45_restart_aneg(phydev); 190 else 191 ret = genphy_restart_aneg(phydev); 192 193 return ret; 194 } 195 EXPORT_SYMBOL_GPL(phy_restart_aneg); 196 197 /** 198 * phy_aneg_done - return auto-negotiation status 199 * @phydev: target phy_device struct 200 * 201 * Description: Return the auto-negotiation status from this @phydev 202 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation 203 * is still pending. 204 */ 205 int phy_aneg_done(struct phy_device *phydev) 206 { 207 if (phydev->drv && phydev->drv->aneg_done) 208 return phydev->drv->aneg_done(phydev); 209 else if (phydev->is_c45) 210 return genphy_c45_aneg_done(phydev); 211 else 212 return genphy_aneg_done(phydev); 213 } 214 EXPORT_SYMBOL(phy_aneg_done); 215 216 /** 217 * phy_supported_speeds - return all speeds currently supported by a phy device 218 * @phy: The phy device to return supported speeds of. 219 * @speeds: buffer to store supported speeds in. 220 * @size: size of speeds buffer. 221 * 222 * Description: Returns the number of supported speeds, and fills the speeds 223 * buffer with the supported speeds. If speeds buffer is too small to contain 224 * all currently supported speeds, will return as many speeds as can fit. 225 */ 226 unsigned int phy_supported_speeds(struct phy_device *phy, 227 unsigned int *speeds, 228 unsigned int size) 229 { 230 return phy_caps_speeds(speeds, size, phy->supported); 231 } 232 233 /** 234 * phy_check_valid - check if there is a valid PHY setting which matches 235 * speed, duplex, and feature mask 236 * @speed: speed to match 237 * @duplex: duplex to match 238 * @features: A mask of the valid settings 239 * 240 * Description: Returns true if there is a valid setting, false otherwise. 241 */ 242 bool phy_check_valid(int speed, int duplex, unsigned long *features) 243 { 244 return phy_caps_valid(speed, duplex, features); 245 } 246 EXPORT_SYMBOL(phy_check_valid); 247 248 /** 249 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex 250 * @phydev: the target phy_device struct 251 * 252 * Description: Make sure the PHY is set to supported speeds and 253 * duplexes. Drop down by one in this order: 1000/FULL, 254 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 255 */ 256 static void phy_sanitize_settings(struct phy_device *phydev) 257 { 258 const struct link_capabilities *c; 259 260 c = phy_caps_lookup(phydev->speed, phydev->duplex, phydev->supported, 261 false); 262 263 if (c) { 264 phydev->speed = c->speed; 265 phydev->duplex = c->duplex; 266 } else { 267 /* We failed to find anything (no supported speeds?) */ 268 phydev->speed = SPEED_UNKNOWN; 269 phydev->duplex = DUPLEX_UNKNOWN; 270 } 271 } 272 273 void phy_ethtool_ksettings_get(struct phy_device *phydev, 274 struct ethtool_link_ksettings *cmd) 275 { 276 mutex_lock(&phydev->lock); 277 linkmode_copy(cmd->link_modes.supported, phydev->supported); 278 linkmode_copy(cmd->link_modes.advertising, phydev->advertising); 279 linkmode_copy(cmd->link_modes.lp_advertising, phydev->lp_advertising); 280 281 cmd->base.speed = phydev->speed; 282 cmd->base.duplex = phydev->duplex; 283 cmd->base.master_slave_cfg = phydev->master_slave_get; 284 cmd->base.master_slave_state = phydev->master_slave_state; 285 cmd->base.rate_matching = phydev->rate_matching; 286 if (phydev->interface == PHY_INTERFACE_MODE_MOCA) 287 cmd->base.port = PORT_BNC; 288 else 289 cmd->base.port = phydev->port; 290 cmd->base.transceiver = phydev->is_internal ? 291 XCVR_INTERNAL : XCVR_EXTERNAL; 292 cmd->base.phy_address = phydev->mdio.addr; 293 cmd->base.autoneg = phydev->autoneg; 294 cmd->base.eth_tp_mdix_ctrl = phydev->mdix_ctrl; 295 cmd->base.eth_tp_mdix = phydev->mdix; 296 mutex_unlock(&phydev->lock); 297 } 298 EXPORT_SYMBOL(phy_ethtool_ksettings_get); 299 300 /** 301 * phy_mii_ioctl - generic PHY MII ioctl interface 302 * @phydev: the phy_device struct 303 * @ifr: &struct ifreq for socket ioctl's 304 * @cmd: ioctl cmd to execute 305 * 306 * Note that this function is currently incompatible with the 307 * PHYCONTROL layer. It changes registers without regard to 308 * current state. Use at own risk. 309 */ 310 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd) 311 { 312 struct mii_ioctl_data *mii_data = if_mii(ifr); 313 struct kernel_hwtstamp_config kernel_cfg; 314 struct netlink_ext_ack extack = {}; 315 u16 val = mii_data->val_in; 316 bool change_autoneg = false; 317 struct hwtstamp_config cfg; 318 int prtad, devad; 319 int ret; 320 321 switch (cmd) { 322 case SIOCGMIIPHY: 323 mii_data->phy_id = phydev->mdio.addr; 324 fallthrough; 325 326 case SIOCGMIIREG: 327 if (mdio_phy_id_is_c45(mii_data->phy_id)) { 328 prtad = mdio_phy_id_prtad(mii_data->phy_id); 329 devad = mdio_phy_id_devad(mii_data->phy_id); 330 ret = mdiobus_c45_read(phydev->mdio.bus, prtad, devad, 331 mii_data->reg_num); 332 333 } else { 334 ret = mdiobus_read(phydev->mdio.bus, mii_data->phy_id, 335 mii_data->reg_num); 336 } 337 338 if (ret < 0) 339 return ret; 340 341 mii_data->val_out = ret; 342 343 return 0; 344 345 case SIOCSMIIREG: 346 if (mdio_phy_id_is_c45(mii_data->phy_id)) { 347 prtad = mdio_phy_id_prtad(mii_data->phy_id); 348 devad = mdio_phy_id_devad(mii_data->phy_id); 349 } else { 350 prtad = mii_data->phy_id; 351 devad = mii_data->reg_num; 352 } 353 if (prtad == phydev->mdio.addr) { 354 switch (devad) { 355 case MII_BMCR: 356 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) { 357 if (phydev->autoneg == AUTONEG_ENABLE) 358 change_autoneg = true; 359 phydev->autoneg = AUTONEG_DISABLE; 360 if (val & BMCR_FULLDPLX) 361 phydev->duplex = DUPLEX_FULL; 362 else 363 phydev->duplex = DUPLEX_HALF; 364 if (val & BMCR_SPEED1000) 365 phydev->speed = SPEED_1000; 366 else if (val & BMCR_SPEED100) 367 phydev->speed = SPEED_100; 368 else phydev->speed = SPEED_10; 369 } else { 370 if (phydev->autoneg == AUTONEG_DISABLE) 371 change_autoneg = true; 372 phydev->autoneg = AUTONEG_ENABLE; 373 } 374 break; 375 case MII_ADVERTISE: 376 mii_adv_mod_linkmode_adv_t(phydev->advertising, 377 val); 378 change_autoneg = true; 379 break; 380 case MII_CTRL1000: 381 mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising, 382 val); 383 change_autoneg = true; 384 break; 385 default: 386 /* do nothing */ 387 break; 388 } 389 } 390 391 if (mdio_phy_id_is_c45(mii_data->phy_id)) 392 mdiobus_c45_write(phydev->mdio.bus, prtad, devad, 393 mii_data->reg_num, val); 394 else 395 mdiobus_write(phydev->mdio.bus, prtad, devad, val); 396 397 if (prtad == phydev->mdio.addr && 398 devad == MII_BMCR && 399 val & BMCR_RESET) 400 return phy_init_hw(phydev); 401 402 if (change_autoneg) 403 return phy_start_aneg(phydev); 404 405 return 0; 406 407 case SIOCSHWTSTAMP: 408 if (phydev->mii_ts && phydev->mii_ts->hwtstamp_set) { 409 if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg))) 410 return -EFAULT; 411 412 hwtstamp_config_to_kernel(&kernel_cfg, &cfg); 413 ret = phydev->mii_ts->hwtstamp_set(phydev->mii_ts, 414 &kernel_cfg, 415 &extack); 416 if (ret) 417 return ret; 418 419 hwtstamp_config_from_kernel(&cfg, &kernel_cfg); 420 if (copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg))) 421 return -EFAULT; 422 423 return 0; 424 } 425 fallthrough; 426 427 default: 428 return -EOPNOTSUPP; 429 } 430 } 431 EXPORT_SYMBOL(phy_mii_ioctl); 432 433 /** 434 * phy_do_ioctl - generic ndo_eth_ioctl implementation 435 * @dev: the net_device struct 436 * @ifr: &struct ifreq for socket ioctl's 437 * @cmd: ioctl cmd to execute 438 */ 439 int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 440 { 441 if (!dev->phydev) 442 return -ENODEV; 443 444 return phy_mii_ioctl(dev->phydev, ifr, cmd); 445 } 446 EXPORT_SYMBOL(phy_do_ioctl); 447 448 /** 449 * phy_do_ioctl_running - generic ndo_eth_ioctl implementation but test first 450 * 451 * @dev: the net_device struct 452 * @ifr: &struct ifreq for socket ioctl's 453 * @cmd: ioctl cmd to execute 454 * 455 * Same as phy_do_ioctl, but ensures that net_device is running before 456 * handling the ioctl. 457 */ 458 int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd) 459 { 460 if (!netif_running(dev)) 461 return -ENODEV; 462 463 return phy_do_ioctl(dev, ifr, cmd); 464 } 465 EXPORT_SYMBOL(phy_do_ioctl_running); 466 467 /** 468 * __phy_hwtstamp_get - Get hardware timestamping configuration from PHY 469 * 470 * @phydev: the PHY device structure 471 * @config: structure holding the timestamping configuration 472 * 473 * Query the PHY device for its current hardware timestamping configuration. 474 */ 475 int __phy_hwtstamp_get(struct phy_device *phydev, 476 struct kernel_hwtstamp_config *config) 477 { 478 if (!phydev) 479 return -ENODEV; 480 481 if (phydev->mii_ts && phydev->mii_ts->hwtstamp_get) 482 return phydev->mii_ts->hwtstamp_get(phydev->mii_ts, config); 483 484 return -EOPNOTSUPP; 485 } 486 487 /** 488 * __phy_hwtstamp_set - Modify PHY hardware timestamping configuration 489 * 490 * @phydev: the PHY device structure 491 * @config: structure holding the timestamping configuration 492 * @extack: netlink extended ack structure, for error reporting 493 */ 494 int __phy_hwtstamp_set(struct phy_device *phydev, 495 struct kernel_hwtstamp_config *config, 496 struct netlink_ext_ack *extack) 497 { 498 if (!phydev) 499 return -ENODEV; 500 501 if (phydev->mii_ts && phydev->mii_ts->hwtstamp_set) 502 return phydev->mii_ts->hwtstamp_set(phydev->mii_ts, config, 503 extack); 504 505 return -EOPNOTSUPP; 506 } 507 508 /** 509 * phy_queue_state_machine - Trigger the state machine to run soon 510 * 511 * @phydev: the phy_device struct 512 * @jiffies: Run the state machine after these jiffies 513 */ 514 static void phy_queue_state_machine(struct phy_device *phydev, 515 unsigned long jiffies) 516 { 517 mod_delayed_work(system_power_efficient_wq, &phydev->state_queue, 518 jiffies); 519 } 520 521 /** 522 * phy_trigger_machine - Trigger the state machine to run now 523 * 524 * @phydev: the phy_device struct 525 */ 526 void phy_trigger_machine(struct phy_device *phydev) 527 { 528 phy_queue_state_machine(phydev, 0); 529 } 530 EXPORT_SYMBOL(phy_trigger_machine); 531 532 static void phy_abort_cable_test(struct phy_device *phydev) 533 { 534 int err; 535 536 ethnl_cable_test_finished(phydev); 537 538 err = phy_init_hw(phydev); 539 if (err) 540 phydev_err(phydev, "Error while aborting cable test"); 541 } 542 543 /** 544 * phy_ethtool_get_strings - Get the statistic counter names 545 * 546 * @phydev: the phy_device struct 547 * @data: Where to put the strings 548 */ 549 int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data) 550 { 551 if (!phydev->drv) 552 return -EIO; 553 554 mutex_lock(&phydev->lock); 555 phydev->drv->get_strings(phydev, data); 556 mutex_unlock(&phydev->lock); 557 558 return 0; 559 } 560 EXPORT_SYMBOL(phy_ethtool_get_strings); 561 562 /** 563 * phy_ethtool_get_sset_count - Get the number of statistic counters 564 * 565 * @phydev: the phy_device struct 566 */ 567 int phy_ethtool_get_sset_count(struct phy_device *phydev) 568 { 569 int ret; 570 571 if (!phydev->drv) 572 return -EIO; 573 574 if (phydev->drv->get_sset_count && 575 phydev->drv->get_strings && 576 phydev->drv->get_stats) { 577 mutex_lock(&phydev->lock); 578 ret = phydev->drv->get_sset_count(phydev); 579 mutex_unlock(&phydev->lock); 580 581 return ret; 582 } 583 584 return -EOPNOTSUPP; 585 } 586 EXPORT_SYMBOL(phy_ethtool_get_sset_count); 587 588 /** 589 * phy_ethtool_get_stats - Get the statistic counters 590 * 591 * @phydev: the phy_device struct 592 * @stats: What counters to get 593 * @data: Where to store the counters 594 */ 595 int phy_ethtool_get_stats(struct phy_device *phydev, 596 struct ethtool_stats *stats, u64 *data) 597 { 598 if (!phydev->drv) 599 return -EIO; 600 601 mutex_lock(&phydev->lock); 602 phydev->drv->get_stats(phydev, stats, data); 603 mutex_unlock(&phydev->lock); 604 605 return 0; 606 } 607 EXPORT_SYMBOL(phy_ethtool_get_stats); 608 609 /** 610 * __phy_ethtool_get_phy_stats - Retrieve standardized PHY statistics 611 * @phydev: Pointer to the PHY device 612 * @phy_stats: Pointer to ethtool_eth_phy_stats structure 613 * @phydev_stats: Pointer to ethtool_phy_stats structure 614 * 615 * Fetches PHY statistics using a kernel-defined interface for consistent 616 * diagnostics. Unlike phy_ethtool_get_stats(), which allows custom stats, 617 * this function enforces a standardized format for better interoperability. 618 */ 619 void __phy_ethtool_get_phy_stats(struct phy_device *phydev, 620 struct ethtool_eth_phy_stats *phy_stats, 621 struct ethtool_phy_stats *phydev_stats) 622 { 623 if (!phydev->drv || !phydev->drv->get_phy_stats) 624 return; 625 626 mutex_lock(&phydev->lock); 627 phydev->drv->get_phy_stats(phydev, phy_stats, phydev_stats); 628 mutex_unlock(&phydev->lock); 629 } 630 631 /** 632 * __phy_ethtool_get_link_ext_stats - Retrieve extended link statistics for a PHY 633 * @phydev: Pointer to the PHY device 634 * @link_stats: Pointer to the structure to store extended link statistics 635 * 636 * Populates the ethtool_link_ext_stats structure with link down event counts 637 * and additional driver-specific link statistics, if available. 638 */ 639 void __phy_ethtool_get_link_ext_stats(struct phy_device *phydev, 640 struct ethtool_link_ext_stats *link_stats) 641 { 642 link_stats->link_down_events = READ_ONCE(phydev->link_down_events); 643 644 if (!phydev->drv || !phydev->drv->get_link_stats) 645 return; 646 647 mutex_lock(&phydev->lock); 648 phydev->drv->get_link_stats(phydev, link_stats); 649 mutex_unlock(&phydev->lock); 650 } 651 652 /** 653 * phy_ethtool_get_plca_cfg - Get PLCA RS configuration 654 * @phydev: the phy_device struct 655 * @plca_cfg: where to store the retrieved configuration 656 * 657 * Retrieve the PLCA configuration from the PHY. Return 0 on success or a 658 * negative value if an error occurred. 659 */ 660 int phy_ethtool_get_plca_cfg(struct phy_device *phydev, 661 struct phy_plca_cfg *plca_cfg) 662 { 663 int ret; 664 665 if (!phydev->drv) { 666 ret = -EIO; 667 goto out; 668 } 669 670 if (!phydev->drv->get_plca_cfg) { 671 ret = -EOPNOTSUPP; 672 goto out; 673 } 674 675 mutex_lock(&phydev->lock); 676 ret = phydev->drv->get_plca_cfg(phydev, plca_cfg); 677 678 mutex_unlock(&phydev->lock); 679 out: 680 return ret; 681 } 682 683 /** 684 * plca_check_valid - Check PLCA configuration before enabling 685 * @phydev: the phy_device struct 686 * @plca_cfg: current PLCA configuration 687 * @extack: extack for reporting useful error messages 688 * 689 * Checks whether the PLCA and PHY configuration are consistent and it is safe 690 * to enable PLCA. Returns 0 on success or a negative value if the PLCA or PHY 691 * configuration is not consistent. 692 */ 693 static int plca_check_valid(struct phy_device *phydev, 694 const struct phy_plca_cfg *plca_cfg, 695 struct netlink_ext_ack *extack) 696 { 697 int ret = 0; 698 699 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT, 700 phydev->advertising)) { 701 ret = -EOPNOTSUPP; 702 NL_SET_ERR_MSG(extack, 703 "Point to Multi-Point mode is not enabled"); 704 } else if (plca_cfg->node_id >= 255) { 705 NL_SET_ERR_MSG(extack, "PLCA node ID is not set"); 706 ret = -EINVAL; 707 } 708 709 return ret; 710 } 711 712 /** 713 * phy_ethtool_set_plca_cfg - Set PLCA RS configuration 714 * @phydev: the phy_device struct 715 * @plca_cfg: new PLCA configuration to apply 716 * @extack: extack for reporting useful error messages 717 * 718 * Sets the PLCA configuration in the PHY. Return 0 on success or a 719 * negative value if an error occurred. 720 */ 721 int phy_ethtool_set_plca_cfg(struct phy_device *phydev, 722 const struct phy_plca_cfg *plca_cfg, 723 struct netlink_ext_ack *extack) 724 { 725 struct phy_plca_cfg *curr_plca_cfg; 726 int ret; 727 728 if (!phydev->drv) { 729 ret = -EIO; 730 goto out; 731 } 732 733 if (!phydev->drv->set_plca_cfg || 734 !phydev->drv->get_plca_cfg) { 735 ret = -EOPNOTSUPP; 736 goto out; 737 } 738 739 curr_plca_cfg = kmalloc(sizeof(*curr_plca_cfg), GFP_KERNEL); 740 if (!curr_plca_cfg) { 741 ret = -ENOMEM; 742 goto out; 743 } 744 745 mutex_lock(&phydev->lock); 746 747 ret = phydev->drv->get_plca_cfg(phydev, curr_plca_cfg); 748 if (ret) 749 goto out_drv; 750 751 if (curr_plca_cfg->enabled < 0 && plca_cfg->enabled >= 0) { 752 NL_SET_ERR_MSG(extack, 753 "PHY does not support changing the PLCA 'enable' attribute"); 754 ret = -EINVAL; 755 goto out_drv; 756 } 757 758 if (curr_plca_cfg->node_id < 0 && plca_cfg->node_id >= 0) { 759 NL_SET_ERR_MSG(extack, 760 "PHY does not support changing the PLCA 'local node ID' attribute"); 761 ret = -EINVAL; 762 goto out_drv; 763 } 764 765 if (curr_plca_cfg->node_cnt < 0 && plca_cfg->node_cnt >= 0) { 766 NL_SET_ERR_MSG(extack, 767 "PHY does not support changing the PLCA 'node count' attribute"); 768 ret = -EINVAL; 769 goto out_drv; 770 } 771 772 if (curr_plca_cfg->to_tmr < 0 && plca_cfg->to_tmr >= 0) { 773 NL_SET_ERR_MSG(extack, 774 "PHY does not support changing the PLCA 'TO timer' attribute"); 775 ret = -EINVAL; 776 goto out_drv; 777 } 778 779 if (curr_plca_cfg->burst_cnt < 0 && plca_cfg->burst_cnt >= 0) { 780 NL_SET_ERR_MSG(extack, 781 "PHY does not support changing the PLCA 'burst count' attribute"); 782 ret = -EINVAL; 783 goto out_drv; 784 } 785 786 if (curr_plca_cfg->burst_tmr < 0 && plca_cfg->burst_tmr >= 0) { 787 NL_SET_ERR_MSG(extack, 788 "PHY does not support changing the PLCA 'burst timer' attribute"); 789 ret = -EINVAL; 790 goto out_drv; 791 } 792 793 // if enabling PLCA, perform a few sanity checks 794 if (plca_cfg->enabled > 0) { 795 // allow setting node_id concurrently with enabled 796 if (plca_cfg->node_id >= 0) 797 curr_plca_cfg->node_id = plca_cfg->node_id; 798 799 ret = plca_check_valid(phydev, curr_plca_cfg, extack); 800 if (ret) 801 goto out_drv; 802 } 803 804 ret = phydev->drv->set_plca_cfg(phydev, plca_cfg); 805 806 out_drv: 807 kfree(curr_plca_cfg); 808 mutex_unlock(&phydev->lock); 809 out: 810 return ret; 811 } 812 813 /** 814 * phy_ethtool_get_plca_status - Get PLCA RS status information 815 * @phydev: the phy_device struct 816 * @plca_st: where to store the retrieved status information 817 * 818 * Retrieve the PLCA status information from the PHY. Return 0 on success or a 819 * negative value if an error occurred. 820 */ 821 int phy_ethtool_get_plca_status(struct phy_device *phydev, 822 struct phy_plca_status *plca_st) 823 { 824 int ret; 825 826 if (!phydev->drv) { 827 ret = -EIO; 828 goto out; 829 } 830 831 if (!phydev->drv->get_plca_status) { 832 ret = -EOPNOTSUPP; 833 goto out; 834 } 835 836 mutex_lock(&phydev->lock); 837 ret = phydev->drv->get_plca_status(phydev, plca_st); 838 839 mutex_unlock(&phydev->lock); 840 out: 841 return ret; 842 } 843 844 /** 845 * phy_start_cable_test - Start a cable test 846 * 847 * @phydev: the phy_device struct 848 * @extack: extack for reporting useful error messages 849 */ 850 int phy_start_cable_test(struct phy_device *phydev, 851 struct netlink_ext_ack *extack) 852 { 853 struct net_device *dev = phydev->attached_dev; 854 int err = -ENOMEM; 855 856 if (!(phydev->drv && 857 phydev->drv->cable_test_start && 858 phydev->drv->cable_test_get_status)) { 859 NL_SET_ERR_MSG(extack, 860 "PHY driver does not support cable testing"); 861 return -EOPNOTSUPP; 862 } 863 864 mutex_lock(&phydev->lock); 865 if (phydev->state == PHY_CABLETEST) { 866 NL_SET_ERR_MSG(extack, 867 "PHY already performing a test"); 868 err = -EBUSY; 869 goto out; 870 } 871 872 if (phydev->state < PHY_UP || 873 phydev->state > PHY_CABLETEST) { 874 NL_SET_ERR_MSG(extack, 875 "PHY not configured. Try setting interface up"); 876 err = -EBUSY; 877 goto out; 878 } 879 880 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_NTF); 881 if (err) 882 goto out; 883 884 /* Mark the carrier down until the test is complete */ 885 phy_link_down(phydev); 886 887 netif_testing_on(dev); 888 err = phydev->drv->cable_test_start(phydev); 889 if (err) { 890 netif_testing_off(dev); 891 phy_link_up(phydev); 892 goto out_free; 893 } 894 895 phydev->state = PHY_CABLETEST; 896 897 if (phy_polling_mode(phydev)) 898 phy_trigger_machine(phydev); 899 900 mutex_unlock(&phydev->lock); 901 902 return 0; 903 904 out_free: 905 ethnl_cable_test_free(phydev); 906 out: 907 mutex_unlock(&phydev->lock); 908 909 return err; 910 } 911 EXPORT_SYMBOL(phy_start_cable_test); 912 913 /** 914 * phy_start_cable_test_tdr - Start a raw TDR cable test 915 * 916 * @phydev: the phy_device struct 917 * @extack: extack for reporting useful error messages 918 * @config: Configuration of the test to run 919 */ 920 int phy_start_cable_test_tdr(struct phy_device *phydev, 921 struct netlink_ext_ack *extack, 922 const struct phy_tdr_config *config) 923 { 924 struct net_device *dev = phydev->attached_dev; 925 int err = -ENOMEM; 926 927 if (!(phydev->drv && 928 phydev->drv->cable_test_tdr_start && 929 phydev->drv->cable_test_get_status)) { 930 NL_SET_ERR_MSG(extack, 931 "PHY driver does not support cable test TDR"); 932 return -EOPNOTSUPP; 933 } 934 935 mutex_lock(&phydev->lock); 936 if (phydev->state == PHY_CABLETEST) { 937 NL_SET_ERR_MSG(extack, 938 "PHY already performing a test"); 939 err = -EBUSY; 940 goto out; 941 } 942 943 if (phydev->state < PHY_UP || 944 phydev->state > PHY_CABLETEST) { 945 NL_SET_ERR_MSG(extack, 946 "PHY not configured. Try setting interface up"); 947 err = -EBUSY; 948 goto out; 949 } 950 951 err = ethnl_cable_test_alloc(phydev, ETHTOOL_MSG_CABLE_TEST_TDR_NTF); 952 if (err) 953 goto out; 954 955 /* Mark the carrier down until the test is complete */ 956 phy_link_down(phydev); 957 958 netif_testing_on(dev); 959 err = phydev->drv->cable_test_tdr_start(phydev, config); 960 if (err) { 961 netif_testing_off(dev); 962 phy_link_up(phydev); 963 goto out_free; 964 } 965 966 phydev->state = PHY_CABLETEST; 967 968 if (phy_polling_mode(phydev)) 969 phy_trigger_machine(phydev); 970 971 mutex_unlock(&phydev->lock); 972 973 return 0; 974 975 out_free: 976 ethnl_cable_test_free(phydev); 977 out: 978 mutex_unlock(&phydev->lock); 979 980 return err; 981 } 982 EXPORT_SYMBOL(phy_start_cable_test_tdr); 983 984 int phy_config_aneg(struct phy_device *phydev) 985 { 986 if (phydev->drv->config_aneg) 987 return phydev->drv->config_aneg(phydev); 988 989 /* Clause 45 PHYs that don't implement Clause 22 registers are not 990 * allowed to call genphy_config_aneg() 991 */ 992 if (phydev->is_c45 && !(phydev->c45_ids.devices_in_package & BIT(0))) 993 return genphy_c45_config_aneg(phydev); 994 995 return genphy_config_aneg(phydev); 996 } 997 EXPORT_SYMBOL(phy_config_aneg); 998 999 /** 1000 * phy_check_link_status - check link status and set state accordingly 1001 * @phydev: the phy_device struct 1002 * 1003 * Description: Check for link and whether autoneg was triggered / is running 1004 * and set state accordingly 1005 */ 1006 static int phy_check_link_status(struct phy_device *phydev) 1007 { 1008 int err; 1009 1010 lockdep_assert_held(&phydev->lock); 1011 1012 /* Keep previous state if loopback is enabled because some PHYs 1013 * report that Link is Down when loopback is enabled. 1014 */ 1015 if (phydev->loopback_enabled) 1016 return 0; 1017 1018 err = phy_read_status(phydev); 1019 if (err) 1020 return err; 1021 1022 if (phydev->link && phydev->state != PHY_RUNNING) { 1023 phy_check_downshift(phydev); 1024 phydev->state = PHY_RUNNING; 1025 err = genphy_c45_eee_is_active(phydev, NULL); 1026 phydev->eee_active = err > 0; 1027 phydev->enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled && 1028 phydev->eee_active; 1029 1030 phy_link_up(phydev); 1031 } else if (!phydev->link && phydev->state != PHY_NOLINK) { 1032 phydev->state = PHY_NOLINK; 1033 phydev->eee_active = false; 1034 phydev->enable_tx_lpi = false; 1035 phy_link_down(phydev); 1036 } 1037 1038 return 0; 1039 } 1040 1041 /** 1042 * phy_inband_caps - query which in-band signalling modes are supported 1043 * @phydev: a pointer to a &struct phy_device 1044 * @interface: the interface mode for the PHY 1045 * 1046 * Returns zero if it is unknown what in-band signalling is supported by the 1047 * PHY (e.g. because the PHY driver doesn't implement the method.) Otherwise, 1048 * returns a bit mask of the LINK_INBAND_* values from 1049 * &enum link_inband_signalling to describe which inband modes are supported 1050 * by the PHY for this interface mode. 1051 */ 1052 unsigned int phy_inband_caps(struct phy_device *phydev, 1053 phy_interface_t interface) 1054 { 1055 if (phydev->drv && phydev->drv->inband_caps) 1056 return phydev->drv->inband_caps(phydev, interface); 1057 1058 return 0; 1059 } 1060 EXPORT_SYMBOL_GPL(phy_inband_caps); 1061 1062 /** 1063 * phy_config_inband - configure the desired PHY in-band mode 1064 * @phydev: the phy_device struct 1065 * @modes: in-band modes to configure 1066 * 1067 * Description: disables, enables or enables-with-bypass in-band signalling 1068 * between the PHY and host system. 1069 * 1070 * Returns: zero on success, or negative errno value. 1071 */ 1072 int phy_config_inband(struct phy_device *phydev, unsigned int modes) 1073 { 1074 lockdep_assert_held(&phydev->lock); 1075 1076 if (!!(modes & LINK_INBAND_DISABLE) + 1077 !!(modes & LINK_INBAND_ENABLE) + 1078 !!(modes & LINK_INBAND_BYPASS) != 1) 1079 return -EINVAL; 1080 1081 if (!phydev->drv) 1082 return -EIO; 1083 else if (!phydev->drv->config_inband) 1084 return -EOPNOTSUPP; 1085 1086 return phydev->drv->config_inband(phydev, modes); 1087 } 1088 EXPORT_SYMBOL(phy_config_inband); 1089 1090 /** 1091 * _phy_start_aneg - start auto-negotiation for this PHY device 1092 * @phydev: the phy_device struct 1093 * 1094 * Description: Sanitizes the settings (if we're not autonegotiating 1095 * them), and then calls the driver's config_aneg function. 1096 * If the PHYCONTROL Layer is operating, we change the state to 1097 * reflect the beginning of Auto-negotiation or forcing. 1098 */ 1099 int _phy_start_aneg(struct phy_device *phydev) 1100 { 1101 int err; 1102 1103 lockdep_assert_held(&phydev->lock); 1104 1105 if (!phydev->drv) 1106 return -EIO; 1107 1108 if (AUTONEG_DISABLE == phydev->autoneg) 1109 phy_sanitize_settings(phydev); 1110 1111 err = phy_config_aneg(phydev); 1112 if (err < 0) 1113 return err; 1114 1115 if (phy_is_started(phydev)) 1116 err = phy_check_link_status(phydev); 1117 1118 return err; 1119 } 1120 EXPORT_SYMBOL(_phy_start_aneg); 1121 1122 /** 1123 * phy_start_aneg - start auto-negotiation for this PHY device 1124 * @phydev: the phy_device struct 1125 * 1126 * Description: Sanitizes the settings (if we're not autonegotiating 1127 * them), and then calls the driver's config_aneg function. 1128 * If the PHYCONTROL Layer is operating, we change the state to 1129 * reflect the beginning of Auto-negotiation or forcing. 1130 */ 1131 int phy_start_aneg(struct phy_device *phydev) 1132 { 1133 int err; 1134 1135 mutex_lock(&phydev->lock); 1136 err = _phy_start_aneg(phydev); 1137 mutex_unlock(&phydev->lock); 1138 1139 return err; 1140 } 1141 EXPORT_SYMBOL(phy_start_aneg); 1142 1143 static int phy_poll_aneg_done(struct phy_device *phydev) 1144 { 1145 unsigned int retries = 100; 1146 int ret; 1147 1148 do { 1149 msleep(100); 1150 ret = phy_aneg_done(phydev); 1151 } while (!ret && --retries); 1152 1153 if (!ret) 1154 return -ETIMEDOUT; 1155 1156 return ret < 0 ? ret : 0; 1157 } 1158 1159 int phy_ethtool_ksettings_set(struct phy_device *phydev, 1160 const struct ethtool_link_ksettings *cmd) 1161 { 1162 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising); 1163 u8 autoneg = cmd->base.autoneg; 1164 u8 duplex = cmd->base.duplex; 1165 u32 speed = cmd->base.speed; 1166 1167 if (cmd->base.phy_address != phydev->mdio.addr) 1168 return -EINVAL; 1169 1170 linkmode_copy(advertising, cmd->link_modes.advertising); 1171 1172 /* We make sure that we don't pass unsupported values in to the PHY */ 1173 linkmode_and(advertising, advertising, phydev->supported); 1174 1175 /* Verify the settings we care about. */ 1176 if (autoneg != AUTONEG_ENABLE && autoneg != AUTONEG_DISABLE) 1177 return -EINVAL; 1178 1179 if (autoneg == AUTONEG_ENABLE && 1180 (linkmode_empty(advertising) || 1181 !linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 1182 phydev->supported))) 1183 return -EINVAL; 1184 1185 if (autoneg == AUTONEG_DISABLE && 1186 ((speed != SPEED_1000 && 1187 speed != SPEED_100 && 1188 speed != SPEED_10) || 1189 (duplex != DUPLEX_HALF && 1190 duplex != DUPLEX_FULL))) 1191 return -EINVAL; 1192 1193 mutex_lock(&phydev->lock); 1194 phydev->autoneg = autoneg; 1195 1196 if (autoneg == AUTONEG_DISABLE) { 1197 phydev->speed = speed; 1198 phydev->duplex = duplex; 1199 } 1200 1201 linkmode_copy(phydev->advertising, advertising); 1202 1203 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 1204 phydev->advertising, autoneg == AUTONEG_ENABLE); 1205 1206 phydev->master_slave_set = cmd->base.master_slave_cfg; 1207 phydev->mdix_ctrl = cmd->base.eth_tp_mdix_ctrl; 1208 1209 /* Restart the PHY */ 1210 if (phy_is_started(phydev)) { 1211 phydev->state = PHY_UP; 1212 phy_trigger_machine(phydev); 1213 } else { 1214 _phy_start_aneg(phydev); 1215 } 1216 1217 mutex_unlock(&phydev->lock); 1218 return 0; 1219 } 1220 EXPORT_SYMBOL(phy_ethtool_ksettings_set); 1221 1222 /** 1223 * phy_speed_down - set speed to lowest speed supported by both link partners 1224 * @phydev: the phy_device struct 1225 * @sync: perform action synchronously 1226 * 1227 * Description: Typically used to save energy when waiting for a WoL packet 1228 * 1229 * WARNING: Setting sync to false may cause the system being unable to suspend 1230 * in case the PHY generates an interrupt when finishing the autonegotiation. 1231 * This interrupt may wake up the system immediately after suspend. 1232 * Therefore use sync = false only if you're sure it's safe with the respective 1233 * network chip. 1234 */ 1235 int phy_speed_down(struct phy_device *phydev, bool sync) 1236 { 1237 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp); 1238 int ret = 0; 1239 1240 mutex_lock(&phydev->lock); 1241 1242 if (phydev->autoneg != AUTONEG_ENABLE) 1243 goto out; 1244 1245 linkmode_copy(adv_tmp, phydev->advertising); 1246 1247 ret = phy_speed_down_core(phydev); 1248 if (ret) 1249 goto out; 1250 1251 linkmode_copy(phydev->adv_old, adv_tmp); 1252 1253 if (linkmode_equal(phydev->advertising, adv_tmp)) { 1254 ret = 0; 1255 goto out; 1256 } 1257 1258 ret = phy_config_aneg(phydev); 1259 if (ret) 1260 goto out; 1261 1262 ret = sync ? phy_poll_aneg_done(phydev) : 0; 1263 out: 1264 mutex_unlock(&phydev->lock); 1265 1266 return ret; 1267 } 1268 EXPORT_SYMBOL_GPL(phy_speed_down); 1269 1270 /** 1271 * phy_speed_up - (re)set advertised speeds to all supported speeds 1272 * @phydev: the phy_device struct 1273 * 1274 * Description: Used to revert the effect of phy_speed_down 1275 */ 1276 int phy_speed_up(struct phy_device *phydev) 1277 { 1278 __ETHTOOL_DECLARE_LINK_MODE_MASK(adv_tmp); 1279 int ret = 0; 1280 1281 mutex_lock(&phydev->lock); 1282 1283 if (phydev->autoneg != AUTONEG_ENABLE) 1284 goto out; 1285 1286 if (linkmode_empty(phydev->adv_old)) 1287 goto out; 1288 1289 linkmode_copy(adv_tmp, phydev->advertising); 1290 linkmode_copy(phydev->advertising, phydev->adv_old); 1291 linkmode_zero(phydev->adv_old); 1292 1293 if (linkmode_equal(phydev->advertising, adv_tmp)) 1294 goto out; 1295 1296 ret = phy_config_aneg(phydev); 1297 out: 1298 mutex_unlock(&phydev->lock); 1299 1300 return ret; 1301 } 1302 EXPORT_SYMBOL_GPL(phy_speed_up); 1303 1304 /** 1305 * phy_start_machine - start PHY state machine tracking 1306 * @phydev: the phy_device struct 1307 * 1308 * Description: The PHY infrastructure can run a state machine 1309 * which tracks whether the PHY is starting up, negotiating, 1310 * etc. This function starts the delayed workqueue which tracks 1311 * the state of the PHY. If you want to maintain your own state machine, 1312 * do not call this function. 1313 */ 1314 void phy_start_machine(struct phy_device *phydev) 1315 { 1316 phy_trigger_machine(phydev); 1317 } 1318 EXPORT_SYMBOL_GPL(phy_start_machine); 1319 1320 /** 1321 * phy_stop_machine - stop the PHY state machine tracking 1322 * @phydev: target phy_device struct 1323 * 1324 * Description: Stops the state machine delayed workqueue, sets the 1325 * state to UP (unless it wasn't up yet). This function must be 1326 * called BEFORE phy_detach. 1327 */ 1328 void phy_stop_machine(struct phy_device *phydev) 1329 { 1330 cancel_delayed_work_sync(&phydev->state_queue); 1331 1332 mutex_lock(&phydev->lock); 1333 if (phy_is_started(phydev)) 1334 phydev->state = PHY_UP; 1335 mutex_unlock(&phydev->lock); 1336 } 1337 1338 static void phy_process_error(struct phy_device *phydev) 1339 { 1340 /* phydev->lock must be held for the state change to be safe */ 1341 if (!mutex_is_locked(&phydev->lock)) 1342 phydev_err(phydev, "PHY-device data unsafe context\n"); 1343 1344 phydev->state = PHY_ERROR; 1345 1346 phy_trigger_machine(phydev); 1347 } 1348 1349 static void phy_error_precise(struct phy_device *phydev, 1350 const void *func, int err) 1351 { 1352 WARN(1, "%pS: returned: %d\n", func, err); 1353 phy_process_error(phydev); 1354 } 1355 1356 /** 1357 * phy_error - enter ERROR state for this PHY device 1358 * @phydev: target phy_device struct 1359 * 1360 * Moves the PHY to the ERROR state in response to a read 1361 * or write error, and tells the controller the link is down. 1362 * Must be called with phydev->lock held. 1363 */ 1364 void phy_error(struct phy_device *phydev) 1365 { 1366 WARN_ON(1); 1367 phy_process_error(phydev); 1368 } 1369 EXPORT_SYMBOL(phy_error); 1370 1371 /** 1372 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side 1373 * @phydev: target phy_device struct 1374 */ 1375 int phy_disable_interrupts(struct phy_device *phydev) 1376 { 1377 /* Disable PHY interrupts */ 1378 return phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 1379 } 1380 1381 /** 1382 * phy_interrupt - PHY interrupt handler 1383 * @irq: interrupt line 1384 * @phy_dat: phy_device pointer 1385 * 1386 * Description: Handle PHY interrupt 1387 */ 1388 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 1389 { 1390 struct phy_device *phydev = phy_dat; 1391 irqreturn_t ret; 1392 1393 /* Wakeup interrupts may occur during a system sleep transition. 1394 * Postpone handling until the PHY has resumed. 1395 */ 1396 if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) { 1397 struct net_device *netdev = phydev->attached_dev; 1398 1399 if (netdev) { 1400 struct device *parent = netdev->dev.parent; 1401 1402 if (netdev->ethtool->wol_enabled) 1403 pm_system_wakeup(); 1404 else if (device_may_wakeup(&netdev->dev)) 1405 pm_wakeup_dev_event(&netdev->dev, 0, true); 1406 else if (parent && device_may_wakeup(parent)) 1407 pm_wakeup_dev_event(parent, 0, true); 1408 } 1409 1410 phydev->irq_rerun = 1; 1411 disable_irq_nosync(irq); 1412 return IRQ_HANDLED; 1413 } 1414 1415 mutex_lock(&phydev->lock); 1416 ret = phydev->drv->handle_interrupt(phydev); 1417 mutex_unlock(&phydev->lock); 1418 1419 return ret; 1420 } 1421 1422 /** 1423 * phy_enable_interrupts - Enable the interrupts from the PHY side 1424 * @phydev: target phy_device struct 1425 */ 1426 static int phy_enable_interrupts(struct phy_device *phydev) 1427 { 1428 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 1429 } 1430 1431 /** 1432 * phy_update_stats - Update PHY device statistics if supported. 1433 * @phydev: Pointer to the PHY device structure. 1434 * 1435 * If the PHY driver provides an update_stats callback, this function 1436 * invokes it to update the PHY statistics. If not, it returns 0. 1437 * 1438 * Return: 0 on success, or a negative error code if the callback fails. 1439 */ 1440 static int phy_update_stats(struct phy_device *phydev) 1441 { 1442 if (!phydev->drv->update_stats) 1443 return 0; 1444 1445 return phydev->drv->update_stats(phydev); 1446 } 1447 1448 /** 1449 * phy_request_interrupt - request and enable interrupt for a PHY device 1450 * @phydev: target phy_device struct 1451 * 1452 * Description: Request and enable the interrupt for the given PHY. 1453 * If this fails, then we set irq to PHY_POLL. 1454 * This should only be called with a valid IRQ number. 1455 */ 1456 void phy_request_interrupt(struct phy_device *phydev) 1457 { 1458 int err; 1459 1460 err = request_threaded_irq(phydev->irq, NULL, phy_interrupt, 1461 IRQF_ONESHOT | IRQF_SHARED, 1462 phydev_name(phydev), phydev); 1463 if (err) { 1464 phydev_warn(phydev, "Error %d requesting IRQ %d, falling back to polling\n", 1465 err, phydev->irq); 1466 phydev->irq = PHY_POLL; 1467 } else { 1468 if (phy_enable_interrupts(phydev)) { 1469 phydev_warn(phydev, "Can't enable interrupt, falling back to polling\n"); 1470 phy_free_interrupt(phydev); 1471 phydev->irq = PHY_POLL; 1472 } 1473 } 1474 } 1475 EXPORT_SYMBOL(phy_request_interrupt); 1476 1477 /** 1478 * phy_free_interrupt - disable and free interrupt for a PHY device 1479 * @phydev: target phy_device struct 1480 * 1481 * Description: Disable and free the interrupt for the given PHY. 1482 * This should only be called with a valid IRQ number. 1483 */ 1484 void phy_free_interrupt(struct phy_device *phydev) 1485 { 1486 phy_disable_interrupts(phydev); 1487 free_irq(phydev->irq, phydev); 1488 } 1489 EXPORT_SYMBOL(phy_free_interrupt); 1490 1491 /** 1492 * phy_get_next_update_time - Determine the next PHY update time 1493 * @phydev: Pointer to the phy_device structure 1494 * 1495 * This function queries the PHY driver to get the time for the next polling 1496 * event. If the driver does not implement the callback, a default value is 1497 * used. 1498 * 1499 * Return: The time for the next polling event in jiffies 1500 */ 1501 static unsigned int phy_get_next_update_time(struct phy_device *phydev) 1502 { 1503 if (phydev->drv && phydev->drv->get_next_update_time) 1504 return phydev->drv->get_next_update_time(phydev); 1505 1506 return PHY_STATE_TIME; 1507 } 1508 1509 enum phy_state_work { 1510 PHY_STATE_WORK_NONE, 1511 PHY_STATE_WORK_ANEG, 1512 PHY_STATE_WORK_SUSPEND, 1513 }; 1514 1515 static enum phy_state_work _phy_state_machine(struct phy_device *phydev) 1516 { 1517 enum phy_state_work state_work = PHY_STATE_WORK_NONE; 1518 struct net_device *dev = phydev->attached_dev; 1519 enum phy_state old_state = phydev->state; 1520 const void *func = NULL; 1521 bool finished = false; 1522 int err = 0; 1523 1524 switch (phydev->state) { 1525 case PHY_DOWN: 1526 case PHY_READY: 1527 break; 1528 case PHY_UP: 1529 state_work = PHY_STATE_WORK_ANEG; 1530 break; 1531 case PHY_NOLINK: 1532 case PHY_RUNNING: 1533 err = phy_check_link_status(phydev); 1534 func = &phy_check_link_status; 1535 1536 if (!err) 1537 err = phy_update_stats(phydev); 1538 break; 1539 case PHY_CABLETEST: 1540 err = phydev->drv->cable_test_get_status(phydev, &finished); 1541 if (err) { 1542 phy_abort_cable_test(phydev); 1543 netif_testing_off(dev); 1544 state_work = PHY_STATE_WORK_ANEG; 1545 phydev->state = PHY_UP; 1546 break; 1547 } 1548 1549 if (finished) { 1550 ethnl_cable_test_finished(phydev); 1551 netif_testing_off(dev); 1552 state_work = PHY_STATE_WORK_ANEG; 1553 phydev->state = PHY_UP; 1554 } 1555 break; 1556 case PHY_HALTED: 1557 if (phydev->link) { 1558 if (phydev->autoneg == AUTONEG_ENABLE) { 1559 phydev->speed = SPEED_UNKNOWN; 1560 phydev->duplex = DUPLEX_UNKNOWN; 1561 } 1562 if (phydev->master_slave_state != 1563 MASTER_SLAVE_STATE_UNSUPPORTED) 1564 phydev->master_slave_state = 1565 MASTER_SLAVE_STATE_UNKNOWN; 1566 phydev->mdix = ETH_TP_MDI_INVALID; 1567 linkmode_zero(phydev->lp_advertising); 1568 } 1569 fallthrough; 1570 case PHY_ERROR: 1571 if (phydev->link) { 1572 phydev->link = 0; 1573 phydev->eee_active = false; 1574 phydev->enable_tx_lpi = false; 1575 phy_link_down(phydev); 1576 } 1577 state_work = PHY_STATE_WORK_SUSPEND; 1578 break; 1579 } 1580 1581 if (state_work == PHY_STATE_WORK_ANEG) { 1582 err = _phy_start_aneg(phydev); 1583 func = &_phy_start_aneg; 1584 } 1585 1586 if (err == -ENODEV) 1587 return state_work; 1588 1589 if (err < 0) 1590 phy_error_precise(phydev, func, err); 1591 1592 phy_process_state_change(phydev, old_state); 1593 1594 /* Only re-schedule a PHY state machine change if we are polling the 1595 * PHY, if PHY_MAC_INTERRUPT is set, then we will be moving 1596 * between states from phy_mac_interrupt(). 1597 * 1598 * In state PHY_HALTED the PHY gets suspended, so rescheduling the 1599 * state machine would be pointless and possibly error prone when 1600 * called from phy_disconnect() synchronously. 1601 */ 1602 if (phy_polling_mode(phydev) && phy_is_started(phydev)) 1603 phy_queue_state_machine(phydev, 1604 phy_get_next_update_time(phydev)); 1605 1606 return state_work; 1607 } 1608 1609 /* unlocked part of the PHY state machine */ 1610 static void _phy_state_machine_post_work(struct phy_device *phydev, 1611 enum phy_state_work state_work) 1612 { 1613 if (state_work == PHY_STATE_WORK_SUSPEND) 1614 phy_suspend(phydev); 1615 } 1616 1617 /** 1618 * phy_state_machine - Handle the state machine 1619 * @work: work_struct that describes the work to be done 1620 */ 1621 void phy_state_machine(struct work_struct *work) 1622 { 1623 struct delayed_work *dwork = to_delayed_work(work); 1624 struct phy_device *phydev = 1625 container_of(dwork, struct phy_device, state_queue); 1626 enum phy_state_work state_work; 1627 1628 mutex_lock(&phydev->lock); 1629 state_work = _phy_state_machine(phydev); 1630 mutex_unlock(&phydev->lock); 1631 1632 _phy_state_machine_post_work(phydev, state_work); 1633 } 1634 1635 /** 1636 * phy_stop - Bring down the PHY link, and stop checking the status 1637 * @phydev: target phy_device struct 1638 */ 1639 void phy_stop(struct phy_device *phydev) 1640 { 1641 struct net_device *dev = phydev->attached_dev; 1642 enum phy_state_work state_work; 1643 enum phy_state old_state; 1644 1645 if (!phy_is_started(phydev) && phydev->state != PHY_DOWN && 1646 phydev->state != PHY_ERROR) { 1647 WARN(1, "called from state %s\n", 1648 phy_state_to_str(phydev->state)); 1649 return; 1650 } 1651 1652 mutex_lock(&phydev->lock); 1653 old_state = phydev->state; 1654 1655 if (phydev->state == PHY_CABLETEST) { 1656 phy_abort_cable_test(phydev); 1657 netif_testing_off(dev); 1658 } 1659 1660 if (phydev->sfp_bus) 1661 sfp_upstream_stop(phydev->sfp_bus); 1662 1663 phydev->state = PHY_HALTED; 1664 phy_process_state_change(phydev, old_state); 1665 1666 state_work = _phy_state_machine(phydev); 1667 mutex_unlock(&phydev->lock); 1668 1669 _phy_state_machine_post_work(phydev, state_work); 1670 phy_stop_machine(phydev); 1671 1672 /* Cannot call flush_scheduled_work() here as desired because 1673 * of rtnl_lock(), but PHY_HALTED shall guarantee irq handler 1674 * will not reenable interrupts. 1675 */ 1676 } 1677 EXPORT_SYMBOL(phy_stop); 1678 1679 /** 1680 * phy_start - start or restart a PHY device 1681 * @phydev: target phy_device struct 1682 * 1683 * Description: Indicates the attached device's readiness to 1684 * handle PHY-related work. Used during startup to start the 1685 * PHY, and after a call to phy_stop() to resume operation. 1686 * Also used to indicate the MDIO bus has cleared an error 1687 * condition. 1688 */ 1689 void phy_start(struct phy_device *phydev) 1690 { 1691 mutex_lock(&phydev->lock); 1692 1693 if (phydev->state != PHY_READY && phydev->state != PHY_HALTED) { 1694 WARN(1, "called from state %s\n", 1695 phy_state_to_str(phydev->state)); 1696 goto out; 1697 } 1698 1699 if (phydev->sfp_bus) 1700 sfp_upstream_start(phydev->sfp_bus); 1701 1702 /* if phy was suspended, bring the physical link up again */ 1703 __phy_resume(phydev); 1704 1705 phydev->state = PHY_UP; 1706 1707 phy_start_machine(phydev); 1708 out: 1709 mutex_unlock(&phydev->lock); 1710 } 1711 EXPORT_SYMBOL(phy_start); 1712 1713 /** 1714 * phy_mac_interrupt - MAC says the link has changed 1715 * @phydev: phy_device struct with changed link 1716 * 1717 * The MAC layer is able to indicate there has been a change in the PHY link 1718 * status. Trigger the state machine and work a work queue. 1719 */ 1720 void phy_mac_interrupt(struct phy_device *phydev) 1721 { 1722 /* Trigger a state machine change */ 1723 phy_trigger_machine(phydev); 1724 } 1725 EXPORT_SYMBOL(phy_mac_interrupt); 1726 1727 /** 1728 * phy_loopback - Configure loopback mode of PHY 1729 * @phydev: target phy_device struct 1730 * @enable: enable or disable loopback mode 1731 * @speed: enable loopback mode with speed 1732 * 1733 * Configure loopback mode of PHY and signal link down and link up if speed is 1734 * changing. 1735 * 1736 * Return: 0 on success, negative error code on failure. 1737 */ 1738 int phy_loopback(struct phy_device *phydev, bool enable, int speed) 1739 { 1740 bool link_up = false; 1741 int ret = 0; 1742 1743 if (!phydev->drv) 1744 return -EIO; 1745 1746 mutex_lock(&phydev->lock); 1747 1748 if (enable && phydev->loopback_enabled) { 1749 ret = -EBUSY; 1750 goto out; 1751 } 1752 1753 if (!enable && !phydev->loopback_enabled) { 1754 ret = -EINVAL; 1755 goto out; 1756 } 1757 1758 if (enable) { 1759 /* 1760 * Link up is signaled with a defined speed. If speed changes, 1761 * then first link down and after that link up needs to be 1762 * signaled. 1763 */ 1764 if (phydev->link && phydev->state == PHY_RUNNING) { 1765 /* link is up and signaled */ 1766 if (speed && phydev->speed != speed) { 1767 /* signal link down and up for new speed */ 1768 phydev->link = false; 1769 phydev->state = PHY_NOLINK; 1770 phy_link_down(phydev); 1771 1772 link_up = true; 1773 } 1774 } else { 1775 /* link is not signaled */ 1776 if (speed) { 1777 /* signal link up for new speed */ 1778 link_up = true; 1779 } 1780 } 1781 } 1782 1783 if (phydev->drv->set_loopback) 1784 ret = phydev->drv->set_loopback(phydev, enable, speed); 1785 else 1786 ret = genphy_loopback(phydev, enable, speed); 1787 1788 if (ret) { 1789 if (enable) { 1790 /* try to restore link if enabling loopback fails */ 1791 if (phydev->drv->set_loopback) 1792 phydev->drv->set_loopback(phydev, false, 0); 1793 else 1794 genphy_loopback(phydev, false, 0); 1795 } 1796 1797 goto out; 1798 } 1799 1800 if (link_up) { 1801 phydev->link = true; 1802 phydev->state = PHY_RUNNING; 1803 phy_link_up(phydev); 1804 } 1805 1806 phydev->loopback_enabled = enable; 1807 1808 out: 1809 mutex_unlock(&phydev->lock); 1810 return ret; 1811 } 1812 EXPORT_SYMBOL(phy_loopback); 1813 1814 /** 1815 * phy_eee_tx_clock_stop_capable() - indicate whether the MAC can stop tx clock 1816 * @phydev: target phy_device struct 1817 * 1818 * Indicate whether the MAC can disable the transmit xMII clock while in LPI 1819 * state. Returns 1 if the MAC may stop the transmit clock, 0 if the MAC must 1820 * not stop the transmit clock, or negative error. 1821 */ 1822 int phy_eee_tx_clock_stop_capable(struct phy_device *phydev) 1823 { 1824 int stat1; 1825 1826 stat1 = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_STAT1); 1827 if (stat1 < 0) 1828 return stat1; 1829 1830 return !!(stat1 & MDIO_PCS_STAT1_CLKSTOP_CAP); 1831 } 1832 EXPORT_SYMBOL_GPL(phy_eee_tx_clock_stop_capable); 1833 1834 /** 1835 * phy_eee_rx_clock_stop() - configure PHY receive clock in LPI 1836 * @phydev: target phy_device struct 1837 * @clk_stop_enable: flag to indicate whether the clock can be stopped 1838 * 1839 * Configure whether the PHY can disable its receive clock during LPI mode, 1840 * See IEEE 802.3 sections 22.2.2.2, 35.2.2.10, and 45.2.3.1.4. 1841 * 1842 * Returns: 0 or negative error. 1843 */ 1844 int phy_eee_rx_clock_stop(struct phy_device *phydev, bool clk_stop_enable) 1845 { 1846 /* Configure the PHY to stop receiving xMII 1847 * clock while it is signaling LPI. 1848 */ 1849 return phy_modify_mmd(phydev, MDIO_MMD_PCS, MDIO_CTRL1, 1850 MDIO_PCS_CTRL1_CLKSTOP_EN, 1851 clk_stop_enable ? MDIO_PCS_CTRL1_CLKSTOP_EN : 0); 1852 } 1853 EXPORT_SYMBOL_GPL(phy_eee_rx_clock_stop); 1854 1855 /** 1856 * phy_init_eee - init and check the EEE feature 1857 * @phydev: target phy_device struct 1858 * @clk_stop_enable: PHY may stop the clock during LPI 1859 * 1860 * Description: it checks if the Energy-Efficient Ethernet (EEE) 1861 * is supported by looking at the MMD registers 3.20 and 7.60/61 1862 * and it programs the MMD register 3.0 setting the "Clock stop enable" 1863 * bit if required. 1864 */ 1865 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 1866 { 1867 int ret; 1868 1869 if (!phydev->drv) 1870 return -EIO; 1871 1872 ret = genphy_c45_eee_is_active(phydev, NULL); 1873 if (ret < 0) 1874 return ret; 1875 if (!ret) 1876 return -EPROTONOSUPPORT; 1877 1878 if (clk_stop_enable) 1879 ret = phy_eee_rx_clock_stop(phydev, true); 1880 1881 return ret < 0 ? ret : 0; 1882 } 1883 EXPORT_SYMBOL(phy_init_eee); 1884 1885 /** 1886 * phy_get_eee_err - report the EEE wake error count 1887 * @phydev: target phy_device struct 1888 * 1889 * Description: it is to report the number of time where the PHY 1890 * failed to complete its normal wake sequence. 1891 */ 1892 int phy_get_eee_err(struct phy_device *phydev) 1893 { 1894 int ret; 1895 1896 if (!phydev->drv) 1897 return -EIO; 1898 1899 mutex_lock(&phydev->lock); 1900 ret = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_WK_ERR); 1901 mutex_unlock(&phydev->lock); 1902 1903 return ret; 1904 } 1905 EXPORT_SYMBOL(phy_get_eee_err); 1906 1907 /** 1908 * phy_ethtool_get_eee - get EEE supported and status 1909 * @phydev: target phy_device struct 1910 * @data: ethtool_keee data 1911 * 1912 * Description: get the current EEE settings, filling in all members of 1913 * @data. 1914 */ 1915 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data) 1916 { 1917 int ret; 1918 1919 if (!phydev->drv) 1920 return -EIO; 1921 1922 mutex_lock(&phydev->lock); 1923 ret = genphy_c45_ethtool_get_eee(phydev, data); 1924 eeecfg_to_eee(data, &phydev->eee_cfg); 1925 mutex_unlock(&phydev->lock); 1926 1927 return ret; 1928 } 1929 EXPORT_SYMBOL(phy_ethtool_get_eee); 1930 1931 /** 1932 * phy_ethtool_set_eee_noneg - Adjusts MAC LPI configuration without PHY 1933 * renegotiation 1934 * @phydev: pointer to the target PHY device structure 1935 * @old_cfg: pointer to the eee_config structure containing the old EEE settings 1936 * 1937 * This function updates the Energy Efficient Ethernet (EEE) configuration 1938 * for cases where only the MAC's Low Power Idle (LPI) configuration changes, 1939 * without triggering PHY renegotiation. It ensures that the MAC is properly 1940 * informed of the new LPI settings by cycling the link down and up, which 1941 * is necessary for the MAC to adopt the new configuration. This adjustment 1942 * is done only if there is a change in the tx_lpi_enabled or tx_lpi_timer 1943 * configuration. 1944 */ 1945 static void phy_ethtool_set_eee_noneg(struct phy_device *phydev, 1946 const struct eee_config *old_cfg) 1947 { 1948 bool enable_tx_lpi; 1949 1950 if (!phydev->link) 1951 return; 1952 1953 enable_tx_lpi = phydev->eee_cfg.tx_lpi_enabled && phydev->eee_active; 1954 1955 if (phydev->enable_tx_lpi != enable_tx_lpi || 1956 phydev->eee_cfg.tx_lpi_timer != old_cfg->tx_lpi_timer) { 1957 phydev->enable_tx_lpi = false; 1958 phydev->link = false; 1959 phy_link_down(phydev); 1960 phydev->enable_tx_lpi = enable_tx_lpi; 1961 phydev->link = true; 1962 phy_link_up(phydev); 1963 } 1964 } 1965 1966 /** 1967 * phy_ethtool_set_eee - set EEE supported and status 1968 * @phydev: target phy_device struct 1969 * @data: ethtool_keee data 1970 * 1971 * Description: it is to program the Advertisement EEE register. 1972 */ 1973 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data) 1974 { 1975 struct eee_config old_cfg; 1976 int ret; 1977 1978 if (!phydev->drv) 1979 return -EIO; 1980 1981 mutex_lock(&phydev->lock); 1982 1983 old_cfg = phydev->eee_cfg; 1984 eee_to_eeecfg(&phydev->eee_cfg, data); 1985 1986 ret = genphy_c45_ethtool_set_eee(phydev, data); 1987 if (ret == 0) 1988 phy_ethtool_set_eee_noneg(phydev, &old_cfg); 1989 else if (ret < 0) 1990 phydev->eee_cfg = old_cfg; 1991 1992 mutex_unlock(&phydev->lock); 1993 1994 return ret < 0 ? ret : 0; 1995 } 1996 EXPORT_SYMBOL(phy_ethtool_set_eee); 1997 1998 /** 1999 * phy_ethtool_set_wol - Configure Wake On LAN 2000 * 2001 * @phydev: target phy_device struct 2002 * @wol: Configuration requested 2003 */ 2004 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 2005 { 2006 int ret; 2007 2008 if (phydev->drv && phydev->drv->set_wol) { 2009 mutex_lock(&phydev->lock); 2010 ret = phydev->drv->set_wol(phydev, wol); 2011 mutex_unlock(&phydev->lock); 2012 2013 return ret; 2014 } 2015 2016 return -EOPNOTSUPP; 2017 } 2018 EXPORT_SYMBOL(phy_ethtool_set_wol); 2019 2020 /** 2021 * phy_ethtool_get_wol - Get the current Wake On LAN configuration 2022 * 2023 * @phydev: target phy_device struct 2024 * @wol: Store the current configuration here 2025 */ 2026 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 2027 { 2028 if (phydev->drv && phydev->drv->get_wol) { 2029 mutex_lock(&phydev->lock); 2030 phydev->drv->get_wol(phydev, wol); 2031 mutex_unlock(&phydev->lock); 2032 } 2033 } 2034 EXPORT_SYMBOL(phy_ethtool_get_wol); 2035 2036 int phy_ethtool_get_link_ksettings(struct net_device *ndev, 2037 struct ethtool_link_ksettings *cmd) 2038 { 2039 struct phy_device *phydev = ndev->phydev; 2040 2041 if (!phydev) 2042 return -ENODEV; 2043 2044 phy_ethtool_ksettings_get(phydev, cmd); 2045 2046 return 0; 2047 } 2048 EXPORT_SYMBOL(phy_ethtool_get_link_ksettings); 2049 2050 int phy_ethtool_set_link_ksettings(struct net_device *ndev, 2051 const struct ethtool_link_ksettings *cmd) 2052 { 2053 struct phy_device *phydev = ndev->phydev; 2054 2055 if (!phydev) 2056 return -ENODEV; 2057 2058 return phy_ethtool_ksettings_set(phydev, cmd); 2059 } 2060 EXPORT_SYMBOL(phy_ethtool_set_link_ksettings); 2061 2062 /** 2063 * phy_ethtool_nway_reset - Restart auto negotiation 2064 * @ndev: Network device to restart autoneg for 2065 */ 2066 int phy_ethtool_nway_reset(struct net_device *ndev) 2067 { 2068 struct phy_device *phydev = ndev->phydev; 2069 int ret; 2070 2071 if (!phydev) 2072 return -ENODEV; 2073 2074 if (!phydev->drv) 2075 return -EIO; 2076 2077 mutex_lock(&phydev->lock); 2078 ret = phy_restart_aneg(phydev); 2079 mutex_unlock(&phydev->lock); 2080 2081 return ret; 2082 } 2083 EXPORT_SYMBOL(phy_ethtool_nway_reset); 2084