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