1 // SPDX-License-Identifier: GPL-2.0+ 2 /* Framework for finding and configuring PHYs. 3 * Also contains generic PHY driver 4 * 5 * Author: Andy Fleming 6 * 7 * Copyright (c) 2004 Freescale Semiconductor, Inc. 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <linux/acpi.h> 13 #include <linux/bitmap.h> 14 #include <linux/delay.h> 15 #include <linux/errno.h> 16 #include <linux/etherdevice.h> 17 #include <linux/ethtool.h> 18 #include <linux/init.h> 19 #include <linux/interrupt.h> 20 #include <linux/io.h> 21 #include <linux/kernel.h> 22 #include <linux/list.h> 23 #include <linux/mdio.h> 24 #include <linux/mii.h> 25 #include <linux/mm.h> 26 #include <linux/module.h> 27 #include <linux/of.h> 28 #include <linux/netdevice.h> 29 #include <linux/phy.h> 30 #include <linux/phylib_stubs.h> 31 #include <linux/phy_led_triggers.h> 32 #include <linux/phy_link_topology.h> 33 #include <linux/pse-pd/pse.h> 34 #include <linux/property.h> 35 #include <linux/rtnetlink.h> 36 #include <linux/sfp.h> 37 #include <linux/skbuff.h> 38 #include <linux/slab.h> 39 #include <linux/string.h> 40 #include <linux/uaccess.h> 41 #include <linux/unistd.h> 42 43 MODULE_DESCRIPTION("PHY library"); 44 MODULE_AUTHOR("Andy Fleming"); 45 MODULE_LICENSE("GPL"); 46 47 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init; 48 EXPORT_SYMBOL_GPL(phy_basic_features); 49 50 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init; 51 EXPORT_SYMBOL_GPL(phy_basic_t1_features); 52 53 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1s_p2mp_features) __ro_after_init; 54 EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features); 55 56 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init; 57 EXPORT_SYMBOL_GPL(phy_gbit_features); 58 59 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init; 60 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features); 61 62 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init; 63 EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features); 64 65 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init; 66 EXPORT_SYMBOL_GPL(phy_10gbit_features); 67 68 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init; 69 EXPORT_SYMBOL_GPL(phy_10gbit_fec_features); 70 71 const int phy_basic_ports_array[3] = { 72 ETHTOOL_LINK_MODE_Autoneg_BIT, 73 ETHTOOL_LINK_MODE_TP_BIT, 74 ETHTOOL_LINK_MODE_MII_BIT, 75 }; 76 EXPORT_SYMBOL_GPL(phy_basic_ports_array); 77 78 const int phy_fibre_port_array[1] = { 79 ETHTOOL_LINK_MODE_FIBRE_BIT, 80 }; 81 EXPORT_SYMBOL_GPL(phy_fibre_port_array); 82 83 const int phy_all_ports_features_array[7] = { 84 ETHTOOL_LINK_MODE_Autoneg_BIT, 85 ETHTOOL_LINK_MODE_TP_BIT, 86 ETHTOOL_LINK_MODE_MII_BIT, 87 ETHTOOL_LINK_MODE_FIBRE_BIT, 88 ETHTOOL_LINK_MODE_AUI_BIT, 89 ETHTOOL_LINK_MODE_BNC_BIT, 90 ETHTOOL_LINK_MODE_Backplane_BIT, 91 }; 92 EXPORT_SYMBOL_GPL(phy_all_ports_features_array); 93 94 const int phy_10_100_features_array[4] = { 95 ETHTOOL_LINK_MODE_10baseT_Half_BIT, 96 ETHTOOL_LINK_MODE_10baseT_Full_BIT, 97 ETHTOOL_LINK_MODE_100baseT_Half_BIT, 98 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 99 }; 100 EXPORT_SYMBOL_GPL(phy_10_100_features_array); 101 102 const int phy_basic_t1_features_array[3] = { 103 ETHTOOL_LINK_MODE_TP_BIT, 104 ETHTOOL_LINK_MODE_10baseT1L_Full_BIT, 105 ETHTOOL_LINK_MODE_100baseT1_Full_BIT, 106 }; 107 EXPORT_SYMBOL_GPL(phy_basic_t1_features_array); 108 109 const int phy_basic_t1s_p2mp_features_array[2] = { 110 ETHTOOL_LINK_MODE_TP_BIT, 111 ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT, 112 }; 113 EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features_array); 114 115 const int phy_gbit_features_array[2] = { 116 ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 117 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 118 }; 119 EXPORT_SYMBOL_GPL(phy_gbit_features_array); 120 121 const int phy_10gbit_features_array[1] = { 122 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 123 }; 124 EXPORT_SYMBOL_GPL(phy_10gbit_features_array); 125 126 static const int phy_10gbit_fec_features_array[1] = { 127 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT, 128 }; 129 130 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init; 131 EXPORT_SYMBOL_GPL(phy_10gbit_full_features); 132 133 static const int phy_10gbit_full_features_array[] = { 134 ETHTOOL_LINK_MODE_10baseT_Full_BIT, 135 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 136 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 137 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 138 }; 139 140 static const int phy_eee_cap1_features_array[] = { 141 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 142 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 143 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 144 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, 145 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, 146 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, 147 }; 148 149 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap1_features) __ro_after_init; 150 EXPORT_SYMBOL_GPL(phy_eee_cap1_features); 151 152 static const int phy_eee_cap2_features_array[] = { 153 ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 154 ETHTOOL_LINK_MODE_5000baseT_Full_BIT, 155 }; 156 157 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap2_features) __ro_after_init; 158 EXPORT_SYMBOL_GPL(phy_eee_cap2_features); 159 160 static void features_init(void) 161 { 162 /* 10/100 half/full*/ 163 linkmode_set_bit_array(phy_basic_ports_array, 164 ARRAY_SIZE(phy_basic_ports_array), 165 phy_basic_features); 166 linkmode_set_bit_array(phy_10_100_features_array, 167 ARRAY_SIZE(phy_10_100_features_array), 168 phy_basic_features); 169 170 /* 100 full, TP */ 171 linkmode_set_bit_array(phy_basic_t1_features_array, 172 ARRAY_SIZE(phy_basic_t1_features_array), 173 phy_basic_t1_features); 174 175 /* 10 half, P2MP, TP */ 176 linkmode_set_bit_array(phy_basic_t1s_p2mp_features_array, 177 ARRAY_SIZE(phy_basic_t1s_p2mp_features_array), 178 phy_basic_t1s_p2mp_features); 179 180 /* 10/100 half/full + 1000 half/full */ 181 linkmode_set_bit_array(phy_basic_ports_array, 182 ARRAY_SIZE(phy_basic_ports_array), 183 phy_gbit_features); 184 linkmode_set_bit_array(phy_10_100_features_array, 185 ARRAY_SIZE(phy_10_100_features_array), 186 phy_gbit_features); 187 linkmode_set_bit_array(phy_gbit_features_array, 188 ARRAY_SIZE(phy_gbit_features_array), 189 phy_gbit_features); 190 191 /* 10/100 half/full + 1000 half/full + fibre*/ 192 linkmode_set_bit_array(phy_basic_ports_array, 193 ARRAY_SIZE(phy_basic_ports_array), 194 phy_gbit_fibre_features); 195 linkmode_set_bit_array(phy_10_100_features_array, 196 ARRAY_SIZE(phy_10_100_features_array), 197 phy_gbit_fibre_features); 198 linkmode_set_bit_array(phy_gbit_features_array, 199 ARRAY_SIZE(phy_gbit_features_array), 200 phy_gbit_fibre_features); 201 linkmode_set_bit_array(phy_fibre_port_array, 202 ARRAY_SIZE(phy_fibre_port_array), 203 phy_gbit_fibre_features); 204 205 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/ 206 linkmode_set_bit_array(phy_all_ports_features_array, 207 ARRAY_SIZE(phy_all_ports_features_array), 208 phy_gbit_all_ports_features); 209 linkmode_set_bit_array(phy_10_100_features_array, 210 ARRAY_SIZE(phy_10_100_features_array), 211 phy_gbit_all_ports_features); 212 linkmode_set_bit_array(phy_gbit_features_array, 213 ARRAY_SIZE(phy_gbit_features_array), 214 phy_gbit_all_ports_features); 215 216 /* 10/100 half/full + 1000 half/full + 10G full*/ 217 linkmode_set_bit_array(phy_all_ports_features_array, 218 ARRAY_SIZE(phy_all_ports_features_array), 219 phy_10gbit_features); 220 linkmode_set_bit_array(phy_10_100_features_array, 221 ARRAY_SIZE(phy_10_100_features_array), 222 phy_10gbit_features); 223 linkmode_set_bit_array(phy_gbit_features_array, 224 ARRAY_SIZE(phy_gbit_features_array), 225 phy_10gbit_features); 226 linkmode_set_bit_array(phy_10gbit_features_array, 227 ARRAY_SIZE(phy_10gbit_features_array), 228 phy_10gbit_features); 229 230 /* 10/100/1000/10G full */ 231 linkmode_set_bit_array(phy_all_ports_features_array, 232 ARRAY_SIZE(phy_all_ports_features_array), 233 phy_10gbit_full_features); 234 linkmode_set_bit_array(phy_10gbit_full_features_array, 235 ARRAY_SIZE(phy_10gbit_full_features_array), 236 phy_10gbit_full_features); 237 /* 10G FEC only */ 238 linkmode_set_bit_array(phy_10gbit_fec_features_array, 239 ARRAY_SIZE(phy_10gbit_fec_features_array), 240 phy_10gbit_fec_features); 241 linkmode_set_bit_array(phy_eee_cap1_features_array, 242 ARRAY_SIZE(phy_eee_cap1_features_array), 243 phy_eee_cap1_features); 244 linkmode_set_bit_array(phy_eee_cap2_features_array, 245 ARRAY_SIZE(phy_eee_cap2_features_array), 246 phy_eee_cap2_features); 247 248 } 249 250 void phy_device_free(struct phy_device *phydev) 251 { 252 put_device(&phydev->mdio.dev); 253 } 254 EXPORT_SYMBOL(phy_device_free); 255 256 static void phy_mdio_device_free(struct mdio_device *mdiodev) 257 { 258 struct phy_device *phydev; 259 260 phydev = container_of(mdiodev, struct phy_device, mdio); 261 phy_device_free(phydev); 262 } 263 264 static void phy_device_release(struct device *dev) 265 { 266 fwnode_handle_put(dev->fwnode); 267 kfree(to_phy_device(dev)); 268 } 269 270 static void phy_mdio_device_remove(struct mdio_device *mdiodev) 271 { 272 struct phy_device *phydev; 273 274 phydev = container_of(mdiodev, struct phy_device, mdio); 275 phy_device_remove(phydev); 276 } 277 278 static struct phy_driver genphy_driver; 279 280 static LIST_HEAD(phy_fixup_list); 281 static DEFINE_MUTEX(phy_fixup_lock); 282 283 static bool phy_drv_wol_enabled(struct phy_device *phydev) 284 { 285 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL }; 286 287 phy_ethtool_get_wol(phydev, &wol); 288 289 return wol.wolopts != 0; 290 } 291 292 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev) 293 { 294 struct device_driver *drv = phydev->mdio.dev.driver; 295 struct phy_driver *phydrv = to_phy_driver(drv); 296 struct net_device *netdev = phydev->attached_dev; 297 298 if (!drv || !phydrv->suspend) 299 return false; 300 301 /* If the PHY on the mido bus is not attached but has WOL enabled 302 * we cannot suspend the PHY. 303 */ 304 if (!netdev && phy_drv_wol_enabled(phydev)) 305 return false; 306 307 /* PHY not attached? May suspend if the PHY has not already been 308 * suspended as part of a prior call to phy_disconnect() -> 309 * phy_detach() -> phy_suspend() because the parent netdev might be the 310 * MDIO bus driver and clock gated at this point. 311 */ 312 if (!netdev) 313 goto out; 314 315 if (netdev->ethtool->wol_enabled) 316 return false; 317 318 /* As long as not all affected network drivers support the 319 * wol_enabled flag, let's check for hints that WoL is enabled. 320 * Don't suspend PHY if the attached netdev parent may wake up. 321 * The parent may point to a PCI device, as in tg3 driver. 322 */ 323 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent)) 324 return false; 325 326 /* Also don't suspend PHY if the netdev itself may wakeup. This 327 * is the case for devices w/o underlaying pwr. mgmt. aware bus, 328 * e.g. SoC devices. 329 */ 330 if (device_may_wakeup(&netdev->dev)) 331 return false; 332 333 out: 334 return !phydev->suspended; 335 } 336 337 static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) 338 { 339 struct phy_device *phydev = to_phy_device(dev); 340 341 if (phydev->mac_managed_pm) 342 return 0; 343 344 /* Wakeup interrupts may occur during the system sleep transition when 345 * the PHY is inaccessible. Set flag to postpone handling until the PHY 346 * has resumed. Wait for concurrent interrupt handler to complete. 347 */ 348 if (phy_interrupt_is_valid(phydev)) { 349 phydev->irq_suspended = 1; 350 synchronize_irq(phydev->irq); 351 } 352 353 /* We must stop the state machine manually, otherwise it stops out of 354 * control, possibly with the phydev->lock held. Upon resume, netdev 355 * may call phy routines that try to grab the same lock, and that may 356 * lead to a deadlock. 357 */ 358 if (phydev->attached_dev && phydev->adjust_link) 359 phy_stop_machine(phydev); 360 361 if (!mdio_bus_phy_may_suspend(phydev)) 362 return 0; 363 364 phydev->suspended_by_mdio_bus = 1; 365 366 return phy_suspend(phydev); 367 } 368 369 static __maybe_unused int mdio_bus_phy_resume(struct device *dev) 370 { 371 struct phy_device *phydev = to_phy_device(dev); 372 int ret; 373 374 if (phydev->mac_managed_pm) 375 return 0; 376 377 if (!phydev->suspended_by_mdio_bus) 378 goto no_resume; 379 380 phydev->suspended_by_mdio_bus = 0; 381 382 /* If we managed to get here with the PHY state machine in a state 383 * neither PHY_HALTED, PHY_READY nor PHY_UP, this is an indication 384 * that something went wrong and we should most likely be using 385 * MAC managed PM, but we are not. 386 */ 387 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY && 388 phydev->state != PHY_UP); 389 390 ret = phy_init_hw(phydev); 391 if (ret < 0) 392 return ret; 393 394 ret = phy_resume(phydev); 395 if (ret < 0) 396 return ret; 397 no_resume: 398 if (phy_interrupt_is_valid(phydev)) { 399 phydev->irq_suspended = 0; 400 synchronize_irq(phydev->irq); 401 402 /* Rerun interrupts which were postponed by phy_interrupt() 403 * because they occurred during the system sleep transition. 404 */ 405 if (phydev->irq_rerun) { 406 phydev->irq_rerun = 0; 407 enable_irq(phydev->irq); 408 irq_wake_thread(phydev->irq, phydev); 409 } 410 } 411 412 if (phydev->attached_dev && phydev->adjust_link) 413 phy_start_machine(phydev); 414 415 return 0; 416 } 417 418 static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend, 419 mdio_bus_phy_resume); 420 421 /** 422 * phy_register_fixup - creates a new phy_fixup and adds it to the list 423 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID) 424 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY) 425 * It can also be PHY_ANY_UID 426 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before 427 * comparison 428 * @run: The actual code to be run when a matching PHY is found 429 */ 430 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, 431 int (*run)(struct phy_device *)) 432 { 433 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL); 434 435 if (!fixup) 436 return -ENOMEM; 437 438 strscpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id)); 439 fixup->phy_uid = phy_uid; 440 fixup->phy_uid_mask = phy_uid_mask; 441 fixup->run = run; 442 443 mutex_lock(&phy_fixup_lock); 444 list_add_tail(&fixup->list, &phy_fixup_list); 445 mutex_unlock(&phy_fixup_lock); 446 447 return 0; 448 } 449 EXPORT_SYMBOL(phy_register_fixup); 450 451 /* Registers a fixup to be run on any PHY with the UID in phy_uid */ 452 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask, 453 int (*run)(struct phy_device *)) 454 { 455 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run); 456 } 457 EXPORT_SYMBOL(phy_register_fixup_for_uid); 458 459 /* Registers a fixup to be run on the PHY with id string bus_id */ 460 int phy_register_fixup_for_id(const char *bus_id, 461 int (*run)(struct phy_device *)) 462 { 463 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run); 464 } 465 EXPORT_SYMBOL(phy_register_fixup_for_id); 466 467 /** 468 * phy_unregister_fixup - remove a phy_fixup from the list 469 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list 470 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list 471 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison 472 */ 473 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask) 474 { 475 struct list_head *pos, *n; 476 struct phy_fixup *fixup; 477 int ret; 478 479 ret = -ENODEV; 480 481 mutex_lock(&phy_fixup_lock); 482 list_for_each_safe(pos, n, &phy_fixup_list) { 483 fixup = list_entry(pos, struct phy_fixup, list); 484 485 if ((!strcmp(fixup->bus_id, bus_id)) && 486 phy_id_compare(fixup->phy_uid, phy_uid, phy_uid_mask)) { 487 list_del(&fixup->list); 488 kfree(fixup); 489 ret = 0; 490 break; 491 } 492 } 493 mutex_unlock(&phy_fixup_lock); 494 495 return ret; 496 } 497 EXPORT_SYMBOL(phy_unregister_fixup); 498 499 /* Unregisters a fixup of any PHY with the UID in phy_uid */ 500 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask) 501 { 502 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask); 503 } 504 EXPORT_SYMBOL(phy_unregister_fixup_for_uid); 505 506 /* Unregisters a fixup of the PHY with id string bus_id */ 507 int phy_unregister_fixup_for_id(const char *bus_id) 508 { 509 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff); 510 } 511 EXPORT_SYMBOL(phy_unregister_fixup_for_id); 512 513 /* Returns 1 if fixup matches phydev in bus_id and phy_uid. 514 * Fixups can be set to match any in one or more fields. 515 */ 516 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup) 517 { 518 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0) 519 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0) 520 return 0; 521 522 if (!phy_id_compare(phydev->phy_id, fixup->phy_uid, 523 fixup->phy_uid_mask)) 524 if (fixup->phy_uid != PHY_ANY_UID) 525 return 0; 526 527 return 1; 528 } 529 530 /* Runs any matching fixups for this phydev */ 531 static int phy_scan_fixups(struct phy_device *phydev) 532 { 533 struct phy_fixup *fixup; 534 535 mutex_lock(&phy_fixup_lock); 536 list_for_each_entry(fixup, &phy_fixup_list, list) { 537 if (phy_needs_fixup(phydev, fixup)) { 538 int err = fixup->run(phydev); 539 540 if (err < 0) { 541 mutex_unlock(&phy_fixup_lock); 542 return err; 543 } 544 phydev->has_fixups = true; 545 } 546 } 547 mutex_unlock(&phy_fixup_lock); 548 549 return 0; 550 } 551 552 static int phy_bus_match(struct device *dev, const struct device_driver *drv) 553 { 554 struct phy_device *phydev = to_phy_device(dev); 555 const struct phy_driver *phydrv = to_phy_driver(drv); 556 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids); 557 int i; 558 559 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)) 560 return 0; 561 562 if (phydrv->match_phy_device) 563 return phydrv->match_phy_device(phydev); 564 565 if (phydev->is_c45) { 566 for (i = 1; i < num_ids; i++) { 567 if (phydev->c45_ids.device_ids[i] == 0xffffffff) 568 continue; 569 570 if (phy_id_compare(phydev->c45_ids.device_ids[i], 571 phydrv->phy_id, phydrv->phy_id_mask)) 572 return 1; 573 } 574 return 0; 575 } else { 576 return phy_id_compare(phydev->phy_id, phydrv->phy_id, 577 phydrv->phy_id_mask); 578 } 579 } 580 581 static ssize_t 582 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf) 583 { 584 struct phy_device *phydev = to_phy_device(dev); 585 586 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id); 587 } 588 static DEVICE_ATTR_RO(phy_id); 589 590 static ssize_t 591 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf) 592 { 593 struct phy_device *phydev = to_phy_device(dev); 594 const char *mode = NULL; 595 596 if (phy_is_internal(phydev)) 597 mode = "internal"; 598 else 599 mode = phy_modes(phydev->interface); 600 601 return sysfs_emit(buf, "%s\n", mode); 602 } 603 static DEVICE_ATTR_RO(phy_interface); 604 605 static ssize_t 606 phy_has_fixups_show(struct device *dev, struct device_attribute *attr, 607 char *buf) 608 { 609 struct phy_device *phydev = to_phy_device(dev); 610 611 return sysfs_emit(buf, "%d\n", phydev->has_fixups); 612 } 613 static DEVICE_ATTR_RO(phy_has_fixups); 614 615 static ssize_t phy_dev_flags_show(struct device *dev, 616 struct device_attribute *attr, 617 char *buf) 618 { 619 struct phy_device *phydev = to_phy_device(dev); 620 621 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags); 622 } 623 static DEVICE_ATTR_RO(phy_dev_flags); 624 625 static struct attribute *phy_dev_attrs[] = { 626 &dev_attr_phy_id.attr, 627 &dev_attr_phy_interface.attr, 628 &dev_attr_phy_has_fixups.attr, 629 &dev_attr_phy_dev_flags.attr, 630 NULL, 631 }; 632 ATTRIBUTE_GROUPS(phy_dev); 633 634 static const struct device_type mdio_bus_phy_type = { 635 .name = "PHY", 636 .groups = phy_dev_groups, 637 .release = phy_device_release, 638 .pm = pm_ptr(&mdio_bus_phy_pm_ops), 639 }; 640 641 static int phy_request_driver_module(struct phy_device *dev, u32 phy_id) 642 { 643 int ret; 644 645 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, 646 MDIO_ID_ARGS(phy_id)); 647 /* We only check for failures in executing the usermode binary, 648 * not whether a PHY driver module exists for the PHY ID. 649 * Accept -ENOENT because this may occur in case no initramfs exists, 650 * then modprobe isn't available. 651 */ 652 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) { 653 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n", 654 ret, (unsigned long)phy_id); 655 return ret; 656 } 657 658 return 0; 659 } 660 661 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id, 662 bool is_c45, 663 struct phy_c45_device_ids *c45_ids) 664 { 665 struct phy_device *dev; 666 struct mdio_device *mdiodev; 667 int ret = 0; 668 669 /* We allocate the device, and initialize the default values */ 670 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 671 if (!dev) 672 return ERR_PTR(-ENOMEM); 673 674 mdiodev = &dev->mdio; 675 mdiodev->dev.parent = &bus->dev; 676 mdiodev->dev.bus = &mdio_bus_type; 677 mdiodev->dev.type = &mdio_bus_phy_type; 678 mdiodev->bus = bus; 679 mdiodev->bus_match = phy_bus_match; 680 mdiodev->addr = addr; 681 mdiodev->flags = MDIO_DEVICE_FLAG_PHY; 682 mdiodev->device_free = phy_mdio_device_free; 683 mdiodev->device_remove = phy_mdio_device_remove; 684 mdiodev->reset_state = -1; 685 686 dev->speed = SPEED_UNKNOWN; 687 dev->duplex = DUPLEX_UNKNOWN; 688 dev->pause = 0; 689 dev->asym_pause = 0; 690 dev->link = 0; 691 dev->port = PORT_TP; 692 dev->interface = PHY_INTERFACE_MODE_GMII; 693 694 dev->autoneg = AUTONEG_ENABLE; 695 696 dev->pma_extable = -ENODATA; 697 dev->is_c45 = is_c45; 698 dev->phy_id = phy_id; 699 if (c45_ids) 700 dev->c45_ids = *c45_ids; 701 dev->irq = bus->irq[addr]; 702 703 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr); 704 device_initialize(&mdiodev->dev); 705 706 dev->state = PHY_DOWN; 707 INIT_LIST_HEAD(&dev->leds); 708 709 mutex_init(&dev->lock); 710 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); 711 712 /* Request the appropriate module unconditionally; don't 713 * bother trying to do so only if it isn't already loaded, 714 * because that gets complicated. A hotplug event would have 715 * done an unconditional modprobe anyway. 716 * We don't do normal hotplug because it won't work for MDIO 717 * -- because it relies on the device staying around for long 718 * enough for the driver to get loaded. With MDIO, the NIC 719 * driver will get bored and give up as soon as it finds that 720 * there's no driver _already_ loaded. 721 */ 722 if (is_c45 && c45_ids) { 723 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 724 int i; 725 726 for (i = 1; i < num_ids; i++) { 727 if (c45_ids->device_ids[i] == 0xffffffff) 728 continue; 729 730 ret = phy_request_driver_module(dev, 731 c45_ids->device_ids[i]); 732 if (ret) 733 break; 734 } 735 } else { 736 ret = phy_request_driver_module(dev, phy_id); 737 } 738 739 if (ret) { 740 put_device(&mdiodev->dev); 741 dev = ERR_PTR(ret); 742 } 743 744 return dev; 745 } 746 EXPORT_SYMBOL(phy_device_create); 747 748 /* phy_c45_probe_present - checks to see if a MMD is present in the package 749 * @bus: the target MII bus 750 * @prtad: PHY package address on the MII bus 751 * @devad: PHY device (MMD) address 752 * 753 * Read the MDIO_STAT2 register, and check whether a device is responding 754 * at this address. 755 * 756 * Returns: negative error number on bus access error, zero if no device 757 * is responding, or positive if a device is present. 758 */ 759 static int phy_c45_probe_present(struct mii_bus *bus, int prtad, int devad) 760 { 761 int stat2; 762 763 stat2 = mdiobus_c45_read(bus, prtad, devad, MDIO_STAT2); 764 if (stat2 < 0) 765 return stat2; 766 767 return (stat2 & MDIO_STAT2_DEVPRST) == MDIO_STAT2_DEVPRST_VAL; 768 } 769 770 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers. 771 * @bus: the target MII bus 772 * @addr: PHY address on the MII bus 773 * @dev_addr: MMD address in the PHY. 774 * @devices_in_package: where to store the devices in package information. 775 * 776 * Description: reads devices in package registers of a MMD at @dev_addr 777 * from PHY at @addr on @bus. 778 * 779 * Returns: 0 on success, -EIO on failure. 780 */ 781 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr, 782 u32 *devices_in_package) 783 { 784 int phy_reg; 785 786 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2); 787 if (phy_reg < 0) 788 return -EIO; 789 *devices_in_package = phy_reg << 16; 790 791 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1); 792 if (phy_reg < 0) 793 return -EIO; 794 *devices_in_package |= phy_reg; 795 796 return 0; 797 } 798 799 /** 800 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs. 801 * @bus: the target MII bus 802 * @addr: PHY address on the MII bus 803 * @c45_ids: where to store the c45 ID information. 804 * 805 * Read the PHY "devices in package". If this appears to be valid, read 806 * the PHY identifiers for each device. Return the "devices in package" 807 * and identifiers in @c45_ids. 808 * 809 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if 810 * the "devices in package" is invalid or no device responds. 811 */ 812 static int get_phy_c45_ids(struct mii_bus *bus, int addr, 813 struct phy_c45_device_ids *c45_ids) 814 { 815 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 816 u32 devs_in_pkg = 0; 817 int i, ret, phy_reg; 818 819 /* Find first non-zero Devices In package. Device zero is reserved 820 * for 802.3 c45 complied PHYs, so don't probe it at first. 821 */ 822 for (i = 1; i < MDIO_MMD_NUM && (devs_in_pkg == 0 || 823 (devs_in_pkg & 0x1fffffff) == 0x1fffffff); i++) { 824 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) { 825 /* Check that there is a device present at this 826 * address before reading the devices-in-package 827 * register to avoid reading garbage from the PHY. 828 * Some PHYs (88x3310) vendor space is not IEEE802.3 829 * compliant. 830 */ 831 ret = phy_c45_probe_present(bus, addr, i); 832 if (ret < 0) 833 /* returning -ENODEV doesn't stop bus 834 * scanning 835 */ 836 return (phy_reg == -EIO || 837 phy_reg == -ENODEV) ? -ENODEV : -EIO; 838 839 if (!ret) 840 continue; 841 } 842 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, &devs_in_pkg); 843 if (phy_reg < 0) 844 return -EIO; 845 } 846 847 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) { 848 /* If mostly Fs, there is no device there, then let's probe 849 * MMD 0, as some 10G PHYs have zero Devices In package, 850 * e.g. Cortina CS4315/CS4340 PHY. 851 */ 852 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, &devs_in_pkg); 853 if (phy_reg < 0) 854 return -EIO; 855 856 /* no device there, let's get out of here */ 857 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) 858 return -ENODEV; 859 } 860 861 /* Now probe Device Identifiers for each device present. */ 862 for (i = 1; i < num_ids; i++) { 863 if (!(devs_in_pkg & (1 << i))) 864 continue; 865 866 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) { 867 /* Probe the "Device Present" bits for the vendor MMDs 868 * to ignore these if they do not contain IEEE 802.3 869 * registers. 870 */ 871 ret = phy_c45_probe_present(bus, addr, i); 872 if (ret < 0) 873 return ret; 874 875 if (!ret) 876 continue; 877 } 878 879 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1); 880 if (phy_reg < 0) 881 return -EIO; 882 c45_ids->device_ids[i] = phy_reg << 16; 883 884 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2); 885 if (phy_reg < 0) 886 return -EIO; 887 c45_ids->device_ids[i] |= phy_reg; 888 } 889 890 c45_ids->devices_in_package = devs_in_pkg; 891 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */ 892 c45_ids->mmds_present = devs_in_pkg & ~BIT(0); 893 894 return 0; 895 } 896 897 /** 898 * get_phy_c22_id - reads the specified addr for its clause 22 ID. 899 * @bus: the target MII bus 900 * @addr: PHY address on the MII bus 901 * @phy_id: where to store the ID retrieved. 902 * 903 * Read the 802.3 clause 22 PHY ID from the PHY at @addr on the @bus, 904 * placing it in @phy_id. Return zero on successful read and the ID is 905 * valid, %-EIO on bus access error, or %-ENODEV if no device responds 906 * or invalid ID. 907 */ 908 static int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id) 909 { 910 int phy_reg; 911 912 /* Grab the bits from PHYIR1, and put them in the upper half */ 913 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1); 914 if (phy_reg < 0) { 915 /* returning -ENODEV doesn't stop bus scanning */ 916 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO; 917 } 918 919 *phy_id = phy_reg << 16; 920 921 /* Grab the bits from PHYIR2, and put them in the lower half */ 922 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2); 923 if (phy_reg < 0) { 924 /* returning -ENODEV doesn't stop bus scanning */ 925 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO; 926 } 927 928 *phy_id |= phy_reg; 929 930 /* If the phy_id is mostly Fs, there is no device there */ 931 if ((*phy_id & 0x1fffffff) == 0x1fffffff) 932 return -ENODEV; 933 934 return 0; 935 } 936 937 /* Extract the phy ID from the compatible string of the form 938 * ethernet-phy-idAAAA.BBBB. 939 */ 940 int fwnode_get_phy_id(struct fwnode_handle *fwnode, u32 *phy_id) 941 { 942 unsigned int upper, lower; 943 const char *cp; 944 int ret; 945 946 ret = fwnode_property_read_string(fwnode, "compatible", &cp); 947 if (ret) 948 return ret; 949 950 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) != 2) 951 return -EINVAL; 952 953 *phy_id = ((upper & GENMASK(15, 0)) << 16) | (lower & GENMASK(15, 0)); 954 return 0; 955 } 956 EXPORT_SYMBOL(fwnode_get_phy_id); 957 958 /** 959 * get_phy_device - reads the specified PHY device and returns its @phy_device 960 * struct 961 * @bus: the target MII bus 962 * @addr: PHY address on the MII bus 963 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 964 * 965 * Probe for a PHY at @addr on @bus. 966 * 967 * When probing for a clause 22 PHY, then read the ID registers. If we find 968 * a valid ID, allocate and return a &struct phy_device. 969 * 970 * When probing for a clause 45 PHY, read the "devices in package" registers. 971 * If the "devices in package" appears valid, read the ID registers for each 972 * MMD, allocate and return a &struct phy_device. 973 * 974 * Returns an allocated &struct phy_device on success, %-ENODEV if there is 975 * no PHY present, or %-EIO on bus access error. 976 */ 977 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45) 978 { 979 struct phy_c45_device_ids c45_ids; 980 u32 phy_id = 0; 981 int r; 982 983 c45_ids.devices_in_package = 0; 984 c45_ids.mmds_present = 0; 985 memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids)); 986 987 if (is_c45) 988 r = get_phy_c45_ids(bus, addr, &c45_ids); 989 else 990 r = get_phy_c22_id(bus, addr, &phy_id); 991 992 if (r) 993 return ERR_PTR(r); 994 995 /* PHY device such as the Marvell Alaska 88E2110 will return a PHY ID 996 * of 0 when probed using get_phy_c22_id() with no error. Proceed to 997 * probe with C45 to see if we're able to get a valid PHY ID in the C45 998 * space, if successful, create the C45 PHY device. 999 */ 1000 if (!is_c45 && phy_id == 0 && bus->read_c45) { 1001 r = get_phy_c45_ids(bus, addr, &c45_ids); 1002 if (!r) 1003 return phy_device_create(bus, addr, phy_id, 1004 true, &c45_ids); 1005 } 1006 1007 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids); 1008 } 1009 EXPORT_SYMBOL(get_phy_device); 1010 1011 /** 1012 * phy_device_register - Register the phy device on the MDIO bus 1013 * @phydev: phy_device structure to be added to the MDIO bus 1014 */ 1015 int phy_device_register(struct phy_device *phydev) 1016 { 1017 int err; 1018 1019 err = mdiobus_register_device(&phydev->mdio); 1020 if (err) 1021 return err; 1022 1023 /* Deassert the reset signal */ 1024 phy_device_reset(phydev, 0); 1025 1026 /* Run all of the fixups for this PHY */ 1027 err = phy_scan_fixups(phydev); 1028 if (err) { 1029 phydev_err(phydev, "failed to initialize\n"); 1030 goto out; 1031 } 1032 1033 err = device_add(&phydev->mdio.dev); 1034 if (err) { 1035 phydev_err(phydev, "failed to add\n"); 1036 goto out; 1037 } 1038 1039 return 0; 1040 1041 out: 1042 /* Assert the reset signal */ 1043 phy_device_reset(phydev, 1); 1044 1045 mdiobus_unregister_device(&phydev->mdio); 1046 return err; 1047 } 1048 EXPORT_SYMBOL(phy_device_register); 1049 1050 /** 1051 * phy_device_remove - Remove a previously registered phy device from the MDIO bus 1052 * @phydev: phy_device structure to remove 1053 * 1054 * This doesn't free the phy_device itself, it merely reverses the effects 1055 * of phy_device_register(). Use phy_device_free() to free the device 1056 * after calling this function. 1057 */ 1058 void phy_device_remove(struct phy_device *phydev) 1059 { 1060 unregister_mii_timestamper(phydev->mii_ts); 1061 pse_control_put(phydev->psec); 1062 1063 device_del(&phydev->mdio.dev); 1064 1065 /* Assert the reset signal */ 1066 phy_device_reset(phydev, 1); 1067 1068 mdiobus_unregister_device(&phydev->mdio); 1069 } 1070 EXPORT_SYMBOL(phy_device_remove); 1071 1072 /** 1073 * phy_get_c45_ids - Read 802.3-c45 IDs for phy device. 1074 * @phydev: phy_device structure to read 802.3-c45 IDs 1075 * 1076 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if 1077 * the "devices in package" is invalid. 1078 */ 1079 int phy_get_c45_ids(struct phy_device *phydev) 1080 { 1081 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr, 1082 &phydev->c45_ids); 1083 } 1084 EXPORT_SYMBOL(phy_get_c45_ids); 1085 1086 /** 1087 * phy_find_first - finds the first PHY device on the bus 1088 * @bus: the target MII bus 1089 */ 1090 struct phy_device *phy_find_first(struct mii_bus *bus) 1091 { 1092 struct phy_device *phydev; 1093 int addr; 1094 1095 for (addr = 0; addr < PHY_MAX_ADDR; addr++) { 1096 phydev = mdiobus_get_phy(bus, addr); 1097 if (phydev) 1098 return phydev; 1099 } 1100 return NULL; 1101 } 1102 EXPORT_SYMBOL(phy_find_first); 1103 1104 static void phy_link_change(struct phy_device *phydev, bool up) 1105 { 1106 struct net_device *netdev = phydev->attached_dev; 1107 1108 if (up) 1109 netif_carrier_on(netdev); 1110 else 1111 netif_carrier_off(netdev); 1112 phydev->adjust_link(netdev); 1113 if (phydev->mii_ts && phydev->mii_ts->link_state) 1114 phydev->mii_ts->link_state(phydev->mii_ts, phydev); 1115 } 1116 1117 /** 1118 * phy_prepare_link - prepares the PHY layer to monitor link status 1119 * @phydev: target phy_device struct 1120 * @handler: callback function for link status change notifications 1121 * 1122 * Description: Tells the PHY infrastructure to handle the 1123 * gory details on monitoring link status (whether through 1124 * polling or an interrupt), and to call back to the 1125 * connected device driver when the link status changes. 1126 * If you want to monitor your own link state, don't call 1127 * this function. 1128 */ 1129 static void phy_prepare_link(struct phy_device *phydev, 1130 void (*handler)(struct net_device *)) 1131 { 1132 phydev->adjust_link = handler; 1133 } 1134 1135 /** 1136 * phy_connect_direct - connect an ethernet device to a specific phy_device 1137 * @dev: the network device to connect 1138 * @phydev: the pointer to the phy device 1139 * @handler: callback function for state change notifications 1140 * @interface: PHY device's interface 1141 */ 1142 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 1143 void (*handler)(struct net_device *), 1144 phy_interface_t interface) 1145 { 1146 int rc; 1147 1148 if (!dev) 1149 return -EINVAL; 1150 1151 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 1152 if (rc) 1153 return rc; 1154 1155 phy_prepare_link(phydev, handler); 1156 if (phy_interrupt_is_valid(phydev)) 1157 phy_request_interrupt(phydev); 1158 1159 return 0; 1160 } 1161 EXPORT_SYMBOL(phy_connect_direct); 1162 1163 /** 1164 * phy_connect - connect an ethernet device to a PHY device 1165 * @dev: the network device to connect 1166 * @bus_id: the id string of the PHY device to connect 1167 * @handler: callback function for state change notifications 1168 * @interface: PHY device's interface 1169 * 1170 * Description: Convenience function for connecting ethernet 1171 * devices to PHY devices. The default behavior is for 1172 * the PHY infrastructure to handle everything, and only notify 1173 * the connected driver when the link status changes. If you 1174 * don't want, or can't use the provided functionality, you may 1175 * choose to call only the subset of functions which provide 1176 * the desired functionality. 1177 */ 1178 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, 1179 void (*handler)(struct net_device *), 1180 phy_interface_t interface) 1181 { 1182 struct phy_device *phydev; 1183 struct device *d; 1184 int rc; 1185 1186 /* Search the list of PHY devices on the mdio bus for the 1187 * PHY with the requested name 1188 */ 1189 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 1190 if (!d) { 1191 pr_err("PHY %s not found\n", bus_id); 1192 return ERR_PTR(-ENODEV); 1193 } 1194 phydev = to_phy_device(d); 1195 1196 rc = phy_connect_direct(dev, phydev, handler, interface); 1197 put_device(d); 1198 if (rc) 1199 return ERR_PTR(rc); 1200 1201 return phydev; 1202 } 1203 EXPORT_SYMBOL(phy_connect); 1204 1205 /** 1206 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY 1207 * device 1208 * @phydev: target phy_device struct 1209 */ 1210 void phy_disconnect(struct phy_device *phydev) 1211 { 1212 if (phy_is_started(phydev)) 1213 phy_stop(phydev); 1214 1215 if (phy_interrupt_is_valid(phydev)) 1216 phy_free_interrupt(phydev); 1217 1218 phydev->adjust_link = NULL; 1219 1220 phy_detach(phydev); 1221 } 1222 EXPORT_SYMBOL(phy_disconnect); 1223 1224 /** 1225 * phy_poll_reset - Safely wait until a PHY reset has properly completed 1226 * @phydev: The PHY device to poll 1227 * 1228 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as 1229 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR 1230 * register must be polled until the BMCR_RESET bit clears. 1231 * 1232 * Furthermore, any attempts to write to PHY registers may have no effect 1233 * or even generate MDIO bus errors until this is complete. 1234 * 1235 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the 1236 * standard and do not fully reset after the BMCR_RESET bit is set, and may 1237 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an 1238 * effort to support such broken PHYs, this function is separate from the 1239 * standard phy_init_hw() which will zero all the other bits in the BMCR 1240 * and reapply all driver-specific and board-specific fixups. 1241 */ 1242 static int phy_poll_reset(struct phy_device *phydev) 1243 { 1244 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */ 1245 int ret, val; 1246 1247 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET), 1248 50000, 600000, true); 1249 if (ret) 1250 return ret; 1251 /* Some chips (smsc911x) may still need up to another 1ms after the 1252 * BMCR_RESET bit is cleared before they are usable. 1253 */ 1254 msleep(1); 1255 return 0; 1256 } 1257 1258 int phy_init_hw(struct phy_device *phydev) 1259 { 1260 int ret = 0; 1261 1262 /* Deassert the reset signal */ 1263 phy_device_reset(phydev, 0); 1264 1265 if (!phydev->drv) 1266 return 0; 1267 1268 if (phydev->drv->soft_reset) { 1269 ret = phydev->drv->soft_reset(phydev); 1270 if (ret < 0) 1271 return ret; 1272 1273 /* see comment in genphy_soft_reset for an explanation */ 1274 phydev->suspended = 0; 1275 } 1276 1277 ret = phy_scan_fixups(phydev); 1278 if (ret < 0) 1279 return ret; 1280 1281 phy_interface_zero(phydev->possible_interfaces); 1282 1283 if (phydev->drv->config_init) { 1284 ret = phydev->drv->config_init(phydev); 1285 if (ret < 0) 1286 return ret; 1287 } 1288 1289 if (phydev->drv->config_intr) { 1290 ret = phydev->drv->config_intr(phydev); 1291 if (ret < 0) 1292 return ret; 1293 } 1294 1295 return 0; 1296 } 1297 EXPORT_SYMBOL(phy_init_hw); 1298 1299 void phy_attached_info(struct phy_device *phydev) 1300 { 1301 phy_attached_print(phydev, NULL); 1302 } 1303 EXPORT_SYMBOL(phy_attached_info); 1304 1305 #define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)" 1306 char *phy_attached_info_irq(struct phy_device *phydev) 1307 { 1308 char *irq_str; 1309 char irq_num[8]; 1310 1311 switch(phydev->irq) { 1312 case PHY_POLL: 1313 irq_str = "POLL"; 1314 break; 1315 case PHY_MAC_INTERRUPT: 1316 irq_str = "MAC"; 1317 break; 1318 default: 1319 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq); 1320 irq_str = irq_num; 1321 break; 1322 } 1323 1324 return kasprintf(GFP_KERNEL, "%s", irq_str); 1325 } 1326 EXPORT_SYMBOL(phy_attached_info_irq); 1327 1328 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...) 1329 { 1330 const char *unbound = phydev->drv ? "" : "[unbound] "; 1331 char *irq_str = phy_attached_info_irq(phydev); 1332 1333 if (!fmt) { 1334 phydev_info(phydev, ATTACHED_FMT "\n", unbound, 1335 phydev_name(phydev), irq_str); 1336 } else { 1337 va_list ap; 1338 1339 phydev_info(phydev, ATTACHED_FMT, unbound, 1340 phydev_name(phydev), irq_str); 1341 1342 va_start(ap, fmt); 1343 vprintk(fmt, ap); 1344 va_end(ap); 1345 } 1346 kfree(irq_str); 1347 } 1348 EXPORT_SYMBOL(phy_attached_print); 1349 1350 static void phy_sysfs_create_links(struct phy_device *phydev) 1351 { 1352 struct net_device *dev = phydev->attached_dev; 1353 int err; 1354 1355 if (!dev) 1356 return; 1357 1358 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj, 1359 "attached_dev"); 1360 if (err) 1361 return; 1362 1363 err = sysfs_create_link_nowarn(&dev->dev.kobj, 1364 &phydev->mdio.dev.kobj, 1365 "phydev"); 1366 if (err) { 1367 dev_err(&dev->dev, "could not add device link to %s err %d\n", 1368 kobject_name(&phydev->mdio.dev.kobj), 1369 err); 1370 /* non-fatal - some net drivers can use one netdevice 1371 * with more then one phy 1372 */ 1373 } 1374 1375 phydev->sysfs_links = true; 1376 } 1377 1378 static ssize_t 1379 phy_standalone_show(struct device *dev, struct device_attribute *attr, 1380 char *buf) 1381 { 1382 struct phy_device *phydev = to_phy_device(dev); 1383 1384 return sysfs_emit(buf, "%d\n", !phydev->attached_dev); 1385 } 1386 static DEVICE_ATTR_RO(phy_standalone); 1387 1388 /** 1389 * phy_sfp_connect_phy - Connect the SFP module's PHY to the upstream PHY 1390 * @upstream: pointer to the upstream phy device 1391 * @phy: pointer to the SFP module's phy device 1392 * 1393 * This helper allows keeping track of PHY devices on the link. It adds the 1394 * SFP module's phy to the phy namespace of the upstream phy 1395 * 1396 * Return: 0 on success, otherwise a negative error code. 1397 */ 1398 int phy_sfp_connect_phy(void *upstream, struct phy_device *phy) 1399 { 1400 struct phy_device *phydev = upstream; 1401 struct net_device *dev = phydev->attached_dev; 1402 1403 if (dev) 1404 return phy_link_topo_add_phy(dev, phy, PHY_UPSTREAM_PHY, phydev); 1405 1406 return 0; 1407 } 1408 EXPORT_SYMBOL(phy_sfp_connect_phy); 1409 1410 /** 1411 * phy_sfp_disconnect_phy - Disconnect the SFP module's PHY from the upstream PHY 1412 * @upstream: pointer to the upstream phy device 1413 * @phy: pointer to the SFP module's phy device 1414 * 1415 * This helper allows keeping track of PHY devices on the link. It removes the 1416 * SFP module's phy to the phy namespace of the upstream phy. As the module phy 1417 * will be destroyed, re-inserting the same module will add a new phy with a 1418 * new index. 1419 */ 1420 void phy_sfp_disconnect_phy(void *upstream, struct phy_device *phy) 1421 { 1422 struct phy_device *phydev = upstream; 1423 struct net_device *dev = phydev->attached_dev; 1424 1425 if (dev) 1426 phy_link_topo_del_phy(dev, phy); 1427 } 1428 EXPORT_SYMBOL(phy_sfp_disconnect_phy); 1429 1430 /** 1431 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device 1432 * @upstream: pointer to the phy device 1433 * @bus: sfp bus representing cage being attached 1434 * 1435 * This is used to fill in the sfp_upstream_ops .attach member. 1436 */ 1437 void phy_sfp_attach(void *upstream, struct sfp_bus *bus) 1438 { 1439 struct phy_device *phydev = upstream; 1440 1441 if (phydev->attached_dev) 1442 phydev->attached_dev->sfp_bus = bus; 1443 phydev->sfp_bus_attached = true; 1444 } 1445 EXPORT_SYMBOL(phy_sfp_attach); 1446 1447 /** 1448 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device 1449 * @upstream: pointer to the phy device 1450 * @bus: sfp bus representing cage being attached 1451 * 1452 * This is used to fill in the sfp_upstream_ops .detach member. 1453 */ 1454 void phy_sfp_detach(void *upstream, struct sfp_bus *bus) 1455 { 1456 struct phy_device *phydev = upstream; 1457 1458 if (phydev->attached_dev) 1459 phydev->attached_dev->sfp_bus = NULL; 1460 phydev->sfp_bus_attached = false; 1461 } 1462 EXPORT_SYMBOL(phy_sfp_detach); 1463 1464 /** 1465 * phy_sfp_probe - probe for a SFP cage attached to this PHY device 1466 * @phydev: Pointer to phy_device 1467 * @ops: SFP's upstream operations 1468 */ 1469 int phy_sfp_probe(struct phy_device *phydev, 1470 const struct sfp_upstream_ops *ops) 1471 { 1472 struct sfp_bus *bus; 1473 int ret = 0; 1474 1475 if (phydev->mdio.dev.fwnode) { 1476 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode); 1477 if (IS_ERR(bus)) 1478 return PTR_ERR(bus); 1479 1480 phydev->sfp_bus = bus; 1481 1482 ret = sfp_bus_add_upstream(bus, phydev, ops); 1483 sfp_bus_put(bus); 1484 } 1485 return ret; 1486 } 1487 EXPORT_SYMBOL(phy_sfp_probe); 1488 1489 static bool phy_drv_supports_irq(const struct phy_driver *phydrv) 1490 { 1491 return phydrv->config_intr && phydrv->handle_interrupt; 1492 } 1493 1494 /** 1495 * phy_attach_direct - attach a network device to a given PHY device pointer 1496 * @dev: network device to attach 1497 * @phydev: Pointer to phy_device to attach 1498 * @flags: PHY device's dev_flags 1499 * @interface: PHY device's interface 1500 * 1501 * Description: Called by drivers to attach to a particular PHY 1502 * device. The phy_device is found, and properly hooked up 1503 * to the phy_driver. If no driver is attached, then a 1504 * generic driver is used. The phy_device is given a ptr to 1505 * the attaching device, and given a callback for link status 1506 * change. The phy_device is returned to the attaching driver. 1507 * This function takes a reference on the phy device. 1508 */ 1509 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 1510 u32 flags, phy_interface_t interface) 1511 { 1512 struct mii_bus *bus = phydev->mdio.bus; 1513 struct device *d = &phydev->mdio.dev; 1514 struct module *ndev_owner = NULL; 1515 bool using_genphy = false; 1516 int err; 1517 1518 /* For Ethernet device drivers that register their own MDIO bus, we 1519 * will have bus->owner match ndev_mod, so we do not want to increment 1520 * our own module->refcnt here, otherwise we would not be able to 1521 * unload later on. 1522 */ 1523 if (dev) 1524 ndev_owner = dev->dev.parent->driver->owner; 1525 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) { 1526 phydev_err(phydev, "failed to get the bus module\n"); 1527 return -EIO; 1528 } 1529 1530 get_device(d); 1531 1532 /* Assume that if there is no driver, that it doesn't 1533 * exist, and we should use the genphy driver. 1534 */ 1535 if (!d->driver) { 1536 if (phydev->is_c45) 1537 d->driver = &genphy_c45_driver.mdiodrv.driver; 1538 else 1539 d->driver = &genphy_driver.mdiodrv.driver; 1540 1541 using_genphy = true; 1542 } 1543 1544 if (!try_module_get(d->driver->owner)) { 1545 phydev_err(phydev, "failed to get the device driver module\n"); 1546 err = -EIO; 1547 goto error_put_device; 1548 } 1549 1550 if (using_genphy) { 1551 err = d->driver->probe(d); 1552 if (err >= 0) 1553 err = device_bind_driver(d); 1554 1555 if (err) 1556 goto error_module_put; 1557 } 1558 1559 if (phydev->attached_dev) { 1560 dev_err(&dev->dev, "PHY already attached\n"); 1561 err = -EBUSY; 1562 goto error; 1563 } 1564 1565 phydev->phy_link_change = phy_link_change; 1566 if (dev) { 1567 phydev->attached_dev = dev; 1568 dev->phydev = phydev; 1569 1570 if (phydev->sfp_bus_attached) 1571 dev->sfp_bus = phydev->sfp_bus; 1572 1573 err = phy_link_topo_add_phy(dev, phydev, PHY_UPSTREAM_MAC, dev); 1574 if (err) 1575 goto error; 1576 } 1577 1578 /* Some Ethernet drivers try to connect to a PHY device before 1579 * calling register_netdevice() -> netdev_register_kobject() and 1580 * does the dev->dev.kobj initialization. Here we only check for 1581 * success which indicates that the network device kobject is 1582 * ready. Once we do that we still need to keep track of whether 1583 * links were successfully set up or not for phy_detach() to 1584 * remove them accordingly. 1585 */ 1586 phydev->sysfs_links = false; 1587 1588 phy_sysfs_create_links(phydev); 1589 1590 if (!phydev->attached_dev) { 1591 err = sysfs_create_file(&phydev->mdio.dev.kobj, 1592 &dev_attr_phy_standalone.attr); 1593 if (err) 1594 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n"); 1595 } 1596 1597 phydev->dev_flags |= flags; 1598 1599 phydev->interface = interface; 1600 1601 phydev->state = PHY_READY; 1602 1603 phydev->interrupts = PHY_INTERRUPT_DISABLED; 1604 1605 /* PHYs can request to use poll mode even though they have an 1606 * associated interrupt line. This could be the case if they 1607 * detect a broken interrupt handling. 1608 */ 1609 if (phydev->dev_flags & PHY_F_NO_IRQ) 1610 phydev->irq = PHY_POLL; 1611 1612 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev)) 1613 phydev->irq = PHY_POLL; 1614 1615 /* Port is set to PORT_TP by default and the actual PHY driver will set 1616 * it to different value depending on the PHY configuration. If we have 1617 * the generic PHY driver we can't figure it out, thus set the old 1618 * legacy PORT_MII value. 1619 */ 1620 if (using_genphy) 1621 phydev->port = PORT_MII; 1622 1623 /* Initial carrier state is off as the phy is about to be 1624 * (re)initialized. 1625 */ 1626 if (dev) 1627 netif_carrier_off(phydev->attached_dev); 1628 1629 /* Do initial configuration here, now that 1630 * we have certain key parameters 1631 * (dev_flags and interface) 1632 */ 1633 err = phy_init_hw(phydev); 1634 if (err) 1635 goto error; 1636 1637 phy_resume(phydev); 1638 if (!phydev->is_on_sfp_module) 1639 phy_led_triggers_register(phydev); 1640 1641 /** 1642 * If the external phy used by current mac interface is managed by 1643 * another mac interface, so we should create a device link between 1644 * phy dev and mac dev. 1645 */ 1646 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent) 1647 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev, 1648 DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS); 1649 1650 return err; 1651 1652 error: 1653 /* phy_detach() does all of the cleanup below */ 1654 phy_detach(phydev); 1655 return err; 1656 1657 error_module_put: 1658 module_put(d->driver->owner); 1659 d->driver = NULL; 1660 error_put_device: 1661 put_device(d); 1662 if (ndev_owner != bus->owner) 1663 module_put(bus->owner); 1664 return err; 1665 } 1666 EXPORT_SYMBOL(phy_attach_direct); 1667 1668 /** 1669 * phy_attach - attach a network device to a particular PHY device 1670 * @dev: network device to attach 1671 * @bus_id: Bus ID of PHY device to attach 1672 * @interface: PHY device's interface 1673 * 1674 * Description: Same as phy_attach_direct() except that a PHY bus_id 1675 * string is passed instead of a pointer to a struct phy_device. 1676 */ 1677 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, 1678 phy_interface_t interface) 1679 { 1680 struct phy_device *phydev; 1681 struct device *d; 1682 int rc; 1683 1684 if (!dev) 1685 return ERR_PTR(-EINVAL); 1686 1687 /* Search the list of PHY devices on the mdio bus for the 1688 * PHY with the requested name 1689 */ 1690 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 1691 if (!d) { 1692 pr_err("PHY %s not found\n", bus_id); 1693 return ERR_PTR(-ENODEV); 1694 } 1695 phydev = to_phy_device(d); 1696 1697 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 1698 put_device(d); 1699 if (rc) 1700 return ERR_PTR(rc); 1701 1702 return phydev; 1703 } 1704 EXPORT_SYMBOL(phy_attach); 1705 1706 static bool phy_driver_is_genphy_kind(struct phy_device *phydev, 1707 struct device_driver *driver) 1708 { 1709 struct device *d = &phydev->mdio.dev; 1710 bool ret = false; 1711 1712 if (!phydev->drv) 1713 return ret; 1714 1715 get_device(d); 1716 ret = d->driver == driver; 1717 put_device(d); 1718 1719 return ret; 1720 } 1721 1722 bool phy_driver_is_genphy(struct phy_device *phydev) 1723 { 1724 return phy_driver_is_genphy_kind(phydev, 1725 &genphy_driver.mdiodrv.driver); 1726 } 1727 EXPORT_SYMBOL_GPL(phy_driver_is_genphy); 1728 1729 bool phy_driver_is_genphy_10g(struct phy_device *phydev) 1730 { 1731 return phy_driver_is_genphy_kind(phydev, 1732 &genphy_c45_driver.mdiodrv.driver); 1733 } 1734 EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g); 1735 1736 /** 1737 * phy_package_join - join a common PHY group 1738 * @phydev: target phy_device struct 1739 * @base_addr: cookie and base PHY address of PHY package for offset 1740 * calculation of global register access 1741 * @priv_size: if non-zero allocate this amount of bytes for private data 1742 * 1743 * This joins a PHY group and provides a shared storage for all phydevs in 1744 * this group. This is intended to be used for packages which contain 1745 * more than one PHY, for example a quad PHY transceiver. 1746 * 1747 * The base_addr parameter serves as cookie which has to have the same values 1748 * for all members of one group and as the base PHY address of the PHY package 1749 * for offset calculation to access generic registers of a PHY package. 1750 * Usually, one of the PHY addresses of the different PHYs in the package 1751 * provides access to these global registers. 1752 * The address which is given here, will be used in the phy_package_read() 1753 * and phy_package_write() convenience functions as base and added to the 1754 * passed offset in those functions. 1755 * 1756 * This will set the shared pointer of the phydev to the shared storage. 1757 * If this is the first call for a this cookie the shared storage will be 1758 * allocated. If priv_size is non-zero, the given amount of bytes are 1759 * allocated for the priv member. 1760 * 1761 * Returns < 1 on error, 0 on success. Esp. calling phy_package_join() 1762 * with the same cookie but a different priv_size is an error. 1763 */ 1764 int phy_package_join(struct phy_device *phydev, int base_addr, size_t priv_size) 1765 { 1766 struct mii_bus *bus = phydev->mdio.bus; 1767 struct phy_package_shared *shared; 1768 int ret; 1769 1770 if (base_addr < 0 || base_addr >= PHY_MAX_ADDR) 1771 return -EINVAL; 1772 1773 mutex_lock(&bus->shared_lock); 1774 shared = bus->shared[base_addr]; 1775 if (!shared) { 1776 ret = -ENOMEM; 1777 shared = kzalloc(sizeof(*shared), GFP_KERNEL); 1778 if (!shared) 1779 goto err_unlock; 1780 if (priv_size) { 1781 shared->priv = kzalloc(priv_size, GFP_KERNEL); 1782 if (!shared->priv) 1783 goto err_free; 1784 shared->priv_size = priv_size; 1785 } 1786 shared->base_addr = base_addr; 1787 shared->np = NULL; 1788 refcount_set(&shared->refcnt, 1); 1789 bus->shared[base_addr] = shared; 1790 } else { 1791 ret = -EINVAL; 1792 if (priv_size && priv_size != shared->priv_size) 1793 goto err_unlock; 1794 refcount_inc(&shared->refcnt); 1795 } 1796 mutex_unlock(&bus->shared_lock); 1797 1798 phydev->shared = shared; 1799 1800 return 0; 1801 1802 err_free: 1803 kfree(shared); 1804 err_unlock: 1805 mutex_unlock(&bus->shared_lock); 1806 return ret; 1807 } 1808 EXPORT_SYMBOL_GPL(phy_package_join); 1809 1810 /** 1811 * of_phy_package_join - join a common PHY group in PHY package 1812 * @phydev: target phy_device struct 1813 * @priv_size: if non-zero allocate this amount of bytes for private data 1814 * 1815 * This is a variant of phy_package_join for PHY package defined in DT. 1816 * 1817 * The parent node of the @phydev is checked as a valid PHY package node 1818 * structure (by matching the node name "ethernet-phy-package") and the 1819 * base_addr for the PHY package is passed to phy_package_join. 1820 * 1821 * With this configuration the shared struct will also have the np value 1822 * filled to use additional DT defined properties in PHY specific 1823 * probe_once and config_init_once PHY package OPs. 1824 * 1825 * Returns < 0 on error, 0 on success. Esp. calling phy_package_join() 1826 * with the same cookie but a different priv_size is an error. Or a parent 1827 * node is not detected or is not valid or doesn't match the expected node 1828 * name for PHY package. 1829 */ 1830 int of_phy_package_join(struct phy_device *phydev, size_t priv_size) 1831 { 1832 struct device_node *node = phydev->mdio.dev.of_node; 1833 struct device_node *package_node; 1834 u32 base_addr; 1835 int ret; 1836 1837 if (!node) 1838 return -EINVAL; 1839 1840 package_node = of_get_parent(node); 1841 if (!package_node) 1842 return -EINVAL; 1843 1844 if (!of_node_name_eq(package_node, "ethernet-phy-package")) { 1845 ret = -EINVAL; 1846 goto exit; 1847 } 1848 1849 if (of_property_read_u32(package_node, "reg", &base_addr)) { 1850 ret = -EINVAL; 1851 goto exit; 1852 } 1853 1854 ret = phy_package_join(phydev, base_addr, priv_size); 1855 if (ret) 1856 goto exit; 1857 1858 phydev->shared->np = package_node; 1859 1860 return 0; 1861 exit: 1862 of_node_put(package_node); 1863 return ret; 1864 } 1865 EXPORT_SYMBOL_GPL(of_phy_package_join); 1866 1867 /** 1868 * phy_package_leave - leave a common PHY group 1869 * @phydev: target phy_device struct 1870 * 1871 * This leaves a PHY group created by phy_package_join(). If this phydev 1872 * was the last user of the shared data between the group, this data is 1873 * freed. Resets the phydev->shared pointer to NULL. 1874 */ 1875 void phy_package_leave(struct phy_device *phydev) 1876 { 1877 struct phy_package_shared *shared = phydev->shared; 1878 struct mii_bus *bus = phydev->mdio.bus; 1879 1880 if (!shared) 1881 return; 1882 1883 /* Decrease the node refcount on leave if present */ 1884 if (shared->np) 1885 of_node_put(shared->np); 1886 1887 if (refcount_dec_and_mutex_lock(&shared->refcnt, &bus->shared_lock)) { 1888 bus->shared[shared->base_addr] = NULL; 1889 mutex_unlock(&bus->shared_lock); 1890 kfree(shared->priv); 1891 kfree(shared); 1892 } 1893 1894 phydev->shared = NULL; 1895 } 1896 EXPORT_SYMBOL_GPL(phy_package_leave); 1897 1898 static void devm_phy_package_leave(struct device *dev, void *res) 1899 { 1900 phy_package_leave(*(struct phy_device **)res); 1901 } 1902 1903 /** 1904 * devm_phy_package_join - resource managed phy_package_join() 1905 * @dev: device that is registering this PHY package 1906 * @phydev: target phy_device struct 1907 * @base_addr: cookie and base PHY address of PHY package for offset 1908 * calculation of global register access 1909 * @priv_size: if non-zero allocate this amount of bytes for private data 1910 * 1911 * Managed phy_package_join(). Shared storage fetched by this function, 1912 * phy_package_leave() is automatically called on driver detach. See 1913 * phy_package_join() for more information. 1914 */ 1915 int devm_phy_package_join(struct device *dev, struct phy_device *phydev, 1916 int base_addr, size_t priv_size) 1917 { 1918 struct phy_device **ptr; 1919 int ret; 1920 1921 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr), 1922 GFP_KERNEL); 1923 if (!ptr) 1924 return -ENOMEM; 1925 1926 ret = phy_package_join(phydev, base_addr, priv_size); 1927 1928 if (!ret) { 1929 *ptr = phydev; 1930 devres_add(dev, ptr); 1931 } else { 1932 devres_free(ptr); 1933 } 1934 1935 return ret; 1936 } 1937 EXPORT_SYMBOL_GPL(devm_phy_package_join); 1938 1939 /** 1940 * devm_of_phy_package_join - resource managed of_phy_package_join() 1941 * @dev: device that is registering this PHY package 1942 * @phydev: target phy_device struct 1943 * @priv_size: if non-zero allocate this amount of bytes for private data 1944 * 1945 * Managed of_phy_package_join(). Shared storage fetched by this function, 1946 * phy_package_leave() is automatically called on driver detach. See 1947 * of_phy_package_join() for more information. 1948 */ 1949 int devm_of_phy_package_join(struct device *dev, struct phy_device *phydev, 1950 size_t priv_size) 1951 { 1952 struct phy_device **ptr; 1953 int ret; 1954 1955 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr), 1956 GFP_KERNEL); 1957 if (!ptr) 1958 return -ENOMEM; 1959 1960 ret = of_phy_package_join(phydev, priv_size); 1961 1962 if (!ret) { 1963 *ptr = phydev; 1964 devres_add(dev, ptr); 1965 } else { 1966 devres_free(ptr); 1967 } 1968 1969 return ret; 1970 } 1971 EXPORT_SYMBOL_GPL(devm_of_phy_package_join); 1972 1973 /** 1974 * phy_detach - detach a PHY device from its network device 1975 * @phydev: target phy_device struct 1976 * 1977 * This detaches the phy device from its network device and the phy 1978 * driver, and drops the reference count taken in phy_attach_direct(). 1979 */ 1980 void phy_detach(struct phy_device *phydev) 1981 { 1982 struct net_device *dev = phydev->attached_dev; 1983 struct module *ndev_owner = NULL; 1984 struct mii_bus *bus; 1985 1986 if (phydev->devlink) 1987 device_link_del(phydev->devlink); 1988 1989 if (phydev->sysfs_links) { 1990 if (dev) 1991 sysfs_remove_link(&dev->dev.kobj, "phydev"); 1992 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev"); 1993 } 1994 1995 if (!phydev->attached_dev) 1996 sysfs_remove_file(&phydev->mdio.dev.kobj, 1997 &dev_attr_phy_standalone.attr); 1998 1999 phy_suspend(phydev); 2000 if (dev) { 2001 phydev->attached_dev->phydev = NULL; 2002 phydev->attached_dev = NULL; 2003 phy_link_topo_del_phy(dev, phydev); 2004 } 2005 phydev->phylink = NULL; 2006 2007 if (!phydev->is_on_sfp_module) 2008 phy_led_triggers_unregister(phydev); 2009 2010 if (phydev->mdio.dev.driver) 2011 module_put(phydev->mdio.dev.driver->owner); 2012 2013 /* If the device had no specific driver before (i.e. - it 2014 * was using the generic driver), we unbind the device 2015 * from the generic driver so that there's a chance a 2016 * real driver could be loaded 2017 */ 2018 if (phy_driver_is_genphy(phydev) || 2019 phy_driver_is_genphy_10g(phydev)) 2020 device_release_driver(&phydev->mdio.dev); 2021 2022 /* Assert the reset signal */ 2023 phy_device_reset(phydev, 1); 2024 2025 /* 2026 * The phydev might go away on the put_device() below, so avoid 2027 * a use-after-free bug by reading the underlying bus first. 2028 */ 2029 bus = phydev->mdio.bus; 2030 2031 put_device(&phydev->mdio.dev); 2032 if (dev) 2033 ndev_owner = dev->dev.parent->driver->owner; 2034 if (ndev_owner != bus->owner) 2035 module_put(bus->owner); 2036 } 2037 EXPORT_SYMBOL(phy_detach); 2038 2039 int phy_suspend(struct phy_device *phydev) 2040 { 2041 struct net_device *netdev = phydev->attached_dev; 2042 const struct phy_driver *phydrv = phydev->drv; 2043 int ret; 2044 2045 if (phydev->suspended || !phydrv) 2046 return 0; 2047 2048 phydev->wol_enabled = phy_drv_wol_enabled(phydev) || 2049 (netdev && netdev->ethtool->wol_enabled); 2050 /* If the device has WOL enabled, we cannot suspend the PHY */ 2051 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND)) 2052 return -EBUSY; 2053 2054 if (!phydrv->suspend) 2055 return 0; 2056 2057 ret = phydrv->suspend(phydev); 2058 if (!ret) 2059 phydev->suspended = true; 2060 2061 return ret; 2062 } 2063 EXPORT_SYMBOL(phy_suspend); 2064 2065 int __phy_resume(struct phy_device *phydev) 2066 { 2067 const struct phy_driver *phydrv = phydev->drv; 2068 int ret; 2069 2070 lockdep_assert_held(&phydev->lock); 2071 2072 if (!phydrv || !phydrv->resume) 2073 return 0; 2074 2075 ret = phydrv->resume(phydev); 2076 if (!ret) 2077 phydev->suspended = false; 2078 2079 return ret; 2080 } 2081 EXPORT_SYMBOL(__phy_resume); 2082 2083 int phy_resume(struct phy_device *phydev) 2084 { 2085 int ret; 2086 2087 mutex_lock(&phydev->lock); 2088 ret = __phy_resume(phydev); 2089 mutex_unlock(&phydev->lock); 2090 2091 return ret; 2092 } 2093 EXPORT_SYMBOL(phy_resume); 2094 2095 int phy_loopback(struct phy_device *phydev, bool enable) 2096 { 2097 int ret = 0; 2098 2099 if (!phydev->drv) 2100 return -EIO; 2101 2102 mutex_lock(&phydev->lock); 2103 2104 if (enable && phydev->loopback_enabled) { 2105 ret = -EBUSY; 2106 goto out; 2107 } 2108 2109 if (!enable && !phydev->loopback_enabled) { 2110 ret = -EINVAL; 2111 goto out; 2112 } 2113 2114 if (phydev->drv->set_loopback) 2115 ret = phydev->drv->set_loopback(phydev, enable); 2116 else 2117 ret = genphy_loopback(phydev, enable); 2118 2119 if (ret) 2120 goto out; 2121 2122 phydev->loopback_enabled = enable; 2123 2124 out: 2125 mutex_unlock(&phydev->lock); 2126 return ret; 2127 } 2128 EXPORT_SYMBOL(phy_loopback); 2129 2130 /** 2131 * phy_reset_after_clk_enable - perform a PHY reset if needed 2132 * @phydev: target phy_device struct 2133 * 2134 * Description: Some PHYs are known to need a reset after their refclk was 2135 * enabled. This function evaluates the flags and perform the reset if it's 2136 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy 2137 * was reset. 2138 */ 2139 int phy_reset_after_clk_enable(struct phy_device *phydev) 2140 { 2141 if (!phydev || !phydev->drv) 2142 return -ENODEV; 2143 2144 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) { 2145 phy_device_reset(phydev, 1); 2146 phy_device_reset(phydev, 0); 2147 return 1; 2148 } 2149 2150 return 0; 2151 } 2152 EXPORT_SYMBOL(phy_reset_after_clk_enable); 2153 2154 /* Generic PHY support and helper functions */ 2155 2156 /** 2157 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 2158 * @phydev: target phy_device struct 2159 * @advert: auto-negotiation parameters to advertise 2160 * 2161 * Description: Writes MII_ADVERTISE with the appropriate values, 2162 * after sanitizing the values to make sure we only advertise 2163 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 2164 * hasn't changed, and > 0 if it has changed. 2165 */ 2166 static int genphy_config_advert(struct phy_device *phydev, 2167 const unsigned long *advert) 2168 { 2169 int err, bmsr, changed = 0; 2170 u32 adv; 2171 2172 adv = linkmode_adv_to_mii_adv_t(advert); 2173 2174 /* Setup standard advertisement */ 2175 err = phy_modify_changed(phydev, MII_ADVERTISE, 2176 ADVERTISE_ALL | ADVERTISE_100BASE4 | 2177 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM, 2178 adv); 2179 if (err < 0) 2180 return err; 2181 if (err > 0) 2182 changed = 1; 2183 2184 bmsr = phy_read(phydev, MII_BMSR); 2185 if (bmsr < 0) 2186 return bmsr; 2187 2188 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all 2189 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a 2190 * logical 1. 2191 */ 2192 if (!(bmsr & BMSR_ESTATEN)) 2193 return changed; 2194 2195 adv = linkmode_adv_to_mii_ctrl1000_t(advert); 2196 2197 err = phy_modify_changed(phydev, MII_CTRL1000, 2198 ADVERTISE_1000FULL | ADVERTISE_1000HALF, 2199 adv); 2200 if (err < 0) 2201 return err; 2202 if (err > 0) 2203 changed = 1; 2204 2205 return changed; 2206 } 2207 2208 /** 2209 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters 2210 * @phydev: target phy_device struct 2211 * 2212 * Description: Writes MII_ADVERTISE with the appropriate values, 2213 * after sanitizing the values to make sure we only advertise 2214 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 2215 * hasn't changed, and > 0 if it has changed. This function is intended 2216 * for Clause 37 1000Base-X mode. 2217 */ 2218 static int genphy_c37_config_advert(struct phy_device *phydev) 2219 { 2220 u16 adv = 0; 2221 2222 /* Only allow advertising what this PHY supports */ 2223 linkmode_and(phydev->advertising, phydev->advertising, 2224 phydev->supported); 2225 2226 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 2227 phydev->advertising)) 2228 adv |= ADVERTISE_1000XFULL; 2229 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2230 phydev->advertising)) 2231 adv |= ADVERTISE_1000XPAUSE; 2232 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2233 phydev->advertising)) 2234 adv |= ADVERTISE_1000XPSE_ASYM; 2235 2236 return phy_modify_changed(phydev, MII_ADVERTISE, 2237 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE | 2238 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM, 2239 adv); 2240 } 2241 2242 /** 2243 * genphy_config_eee_advert - disable unwanted eee mode advertisement 2244 * @phydev: target phy_device struct 2245 * 2246 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy 2247 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't 2248 * changed, and 1 if it has changed. 2249 */ 2250 int genphy_config_eee_advert(struct phy_device *phydev) 2251 { 2252 int err; 2253 2254 /* Nothing to disable */ 2255 if (!phydev->eee_broken_modes) 2256 return 0; 2257 2258 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, 2259 phydev->eee_broken_modes, 0); 2260 /* If the call failed, we assume that EEE is not supported */ 2261 return err < 0 ? 0 : err; 2262 } 2263 EXPORT_SYMBOL(genphy_config_eee_advert); 2264 2265 /** 2266 * genphy_setup_forced - configures/forces speed/duplex from @phydev 2267 * @phydev: target phy_device struct 2268 * 2269 * Description: Configures MII_BMCR to force speed/duplex 2270 * to the values in phydev. Assumes that the values are valid. 2271 * Please see phy_sanitize_settings(). 2272 */ 2273 int genphy_setup_forced(struct phy_device *phydev) 2274 { 2275 u16 ctl; 2276 2277 phydev->pause = 0; 2278 phydev->asym_pause = 0; 2279 2280 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex); 2281 2282 return phy_modify(phydev, MII_BMCR, 2283 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl); 2284 } 2285 EXPORT_SYMBOL(genphy_setup_forced); 2286 2287 static int genphy_setup_master_slave(struct phy_device *phydev) 2288 { 2289 u16 ctl = 0; 2290 2291 if (!phydev->is_gigabit_capable) 2292 return 0; 2293 2294 switch (phydev->master_slave_set) { 2295 case MASTER_SLAVE_CFG_MASTER_PREFERRED: 2296 ctl |= CTL1000_PREFER_MASTER; 2297 break; 2298 case MASTER_SLAVE_CFG_SLAVE_PREFERRED: 2299 break; 2300 case MASTER_SLAVE_CFG_MASTER_FORCE: 2301 ctl |= CTL1000_AS_MASTER; 2302 fallthrough; 2303 case MASTER_SLAVE_CFG_SLAVE_FORCE: 2304 ctl |= CTL1000_ENABLE_MASTER; 2305 break; 2306 case MASTER_SLAVE_CFG_UNKNOWN: 2307 case MASTER_SLAVE_CFG_UNSUPPORTED: 2308 return 0; 2309 default: 2310 phydev_warn(phydev, "Unsupported Master/Slave mode\n"); 2311 return -EOPNOTSUPP; 2312 } 2313 2314 return phy_modify_changed(phydev, MII_CTRL1000, 2315 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER | 2316 CTL1000_PREFER_MASTER), ctl); 2317 } 2318 2319 int genphy_read_master_slave(struct phy_device *phydev) 2320 { 2321 int cfg, state; 2322 int val; 2323 2324 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN; 2325 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN; 2326 2327 val = phy_read(phydev, MII_CTRL1000); 2328 if (val < 0) 2329 return val; 2330 2331 if (val & CTL1000_ENABLE_MASTER) { 2332 if (val & CTL1000_AS_MASTER) 2333 cfg = MASTER_SLAVE_CFG_MASTER_FORCE; 2334 else 2335 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE; 2336 } else { 2337 if (val & CTL1000_PREFER_MASTER) 2338 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED; 2339 else 2340 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED; 2341 } 2342 2343 val = phy_read(phydev, MII_STAT1000); 2344 if (val < 0) 2345 return val; 2346 2347 if (val & LPA_1000MSFAIL) { 2348 state = MASTER_SLAVE_STATE_ERR; 2349 } else if (phydev->link) { 2350 /* this bits are valid only for active link */ 2351 if (val & LPA_1000MSRES) 2352 state = MASTER_SLAVE_STATE_MASTER; 2353 else 2354 state = MASTER_SLAVE_STATE_SLAVE; 2355 } else { 2356 state = MASTER_SLAVE_STATE_UNKNOWN; 2357 } 2358 2359 phydev->master_slave_get = cfg; 2360 phydev->master_slave_state = state; 2361 2362 return 0; 2363 } 2364 EXPORT_SYMBOL(genphy_read_master_slave); 2365 2366 /** 2367 * genphy_restart_aneg - Enable and Restart Autonegotiation 2368 * @phydev: target phy_device struct 2369 */ 2370 int genphy_restart_aneg(struct phy_device *phydev) 2371 { 2372 /* Don't isolate the PHY if we're negotiating */ 2373 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, 2374 BMCR_ANENABLE | BMCR_ANRESTART); 2375 } 2376 EXPORT_SYMBOL(genphy_restart_aneg); 2377 2378 /** 2379 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation 2380 * @phydev: target phy_device struct 2381 * @restart: whether aneg restart is requested 2382 * 2383 * Check, and restart auto-negotiation if needed. 2384 */ 2385 int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart) 2386 { 2387 int ret; 2388 2389 if (!restart) { 2390 /* Advertisement hasn't changed, but maybe aneg was never on to 2391 * begin with? Or maybe phy was isolated? 2392 */ 2393 ret = phy_read(phydev, MII_BMCR); 2394 if (ret < 0) 2395 return ret; 2396 2397 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE)) 2398 restart = true; 2399 } 2400 2401 if (restart) 2402 return genphy_restart_aneg(phydev); 2403 2404 return 0; 2405 } 2406 EXPORT_SYMBOL(genphy_check_and_restart_aneg); 2407 2408 /** 2409 * __genphy_config_aneg - restart auto-negotiation or write BMCR 2410 * @phydev: target phy_device struct 2411 * @changed: whether autoneg is requested 2412 * 2413 * Description: If auto-negotiation is enabled, we configure the 2414 * advertising, and then restart auto-negotiation. If it is not 2415 * enabled, then we write the BMCR. 2416 */ 2417 int __genphy_config_aneg(struct phy_device *phydev, bool changed) 2418 { 2419 __ETHTOOL_DECLARE_LINK_MODE_MASK(fixed_advert); 2420 const struct phy_setting *set; 2421 unsigned long *advert; 2422 int err; 2423 2424 err = genphy_c45_an_config_eee_aneg(phydev); 2425 if (err < 0) 2426 return err; 2427 else if (err) 2428 changed = true; 2429 2430 err = genphy_setup_master_slave(phydev); 2431 if (err < 0) 2432 return err; 2433 else if (err) 2434 changed = true; 2435 2436 if (phydev->autoneg == AUTONEG_ENABLE) { 2437 /* Only allow advertising what this PHY supports */ 2438 linkmode_and(phydev->advertising, phydev->advertising, 2439 phydev->supported); 2440 advert = phydev->advertising; 2441 } else if (phydev->speed < SPEED_1000) { 2442 return genphy_setup_forced(phydev); 2443 } else { 2444 linkmode_zero(fixed_advert); 2445 2446 set = phy_lookup_setting(phydev->speed, phydev->duplex, 2447 phydev->supported, true); 2448 if (set) 2449 linkmode_set_bit(set->bit, fixed_advert); 2450 2451 advert = fixed_advert; 2452 } 2453 2454 err = genphy_config_advert(phydev, advert); 2455 if (err < 0) /* error */ 2456 return err; 2457 else if (err) 2458 changed = true; 2459 2460 return genphy_check_and_restart_aneg(phydev, changed); 2461 } 2462 EXPORT_SYMBOL(__genphy_config_aneg); 2463 2464 /** 2465 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR 2466 * @phydev: target phy_device struct 2467 * 2468 * Description: If auto-negotiation is enabled, we configure the 2469 * advertising, and then restart auto-negotiation. If it is not 2470 * enabled, then we write the BMCR. This function is intended 2471 * for use with Clause 37 1000Base-X mode. 2472 */ 2473 int genphy_c37_config_aneg(struct phy_device *phydev) 2474 { 2475 int err, changed; 2476 2477 if (phydev->autoneg != AUTONEG_ENABLE) 2478 return genphy_setup_forced(phydev); 2479 2480 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100, 2481 BMCR_SPEED1000); 2482 if (err) 2483 return err; 2484 2485 changed = genphy_c37_config_advert(phydev); 2486 if (changed < 0) /* error */ 2487 return changed; 2488 2489 if (!changed) { 2490 /* Advertisement hasn't changed, but maybe aneg was never on to 2491 * begin with? Or maybe phy was isolated? 2492 */ 2493 int ctl = phy_read(phydev, MII_BMCR); 2494 2495 if (ctl < 0) 2496 return ctl; 2497 2498 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 2499 changed = 1; /* do restart aneg */ 2500 } 2501 2502 /* Only restart aneg if we are advertising something different 2503 * than we were before. 2504 */ 2505 if (changed > 0) 2506 return genphy_restart_aneg(phydev); 2507 2508 return 0; 2509 } 2510 EXPORT_SYMBOL(genphy_c37_config_aneg); 2511 2512 /** 2513 * genphy_aneg_done - return auto-negotiation status 2514 * @phydev: target phy_device struct 2515 * 2516 * Description: Reads the status register and returns 0 either if 2517 * auto-negotiation is incomplete, or if there was an error. 2518 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 2519 */ 2520 int genphy_aneg_done(struct phy_device *phydev) 2521 { 2522 int retval = phy_read(phydev, MII_BMSR); 2523 2524 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 2525 } 2526 EXPORT_SYMBOL(genphy_aneg_done); 2527 2528 /** 2529 * genphy_update_link - update link status in @phydev 2530 * @phydev: target phy_device struct 2531 * 2532 * Description: Update the value in phydev->link to reflect the 2533 * current link value. In order to do this, we need to read 2534 * the status register twice, keeping the second value. 2535 */ 2536 int genphy_update_link(struct phy_device *phydev) 2537 { 2538 int status = 0, bmcr; 2539 2540 bmcr = phy_read(phydev, MII_BMCR); 2541 if (bmcr < 0) 2542 return bmcr; 2543 2544 /* Autoneg is being started, therefore disregard BMSR value and 2545 * report link as down. 2546 */ 2547 if (bmcr & BMCR_ANRESTART) 2548 goto done; 2549 2550 /* The link state is latched low so that momentary link 2551 * drops can be detected. Do not double-read the status 2552 * in polling mode to detect such short link drops except 2553 * the link was already down. 2554 */ 2555 if (!phy_polling_mode(phydev) || !phydev->link) { 2556 status = phy_read(phydev, MII_BMSR); 2557 if (status < 0) 2558 return status; 2559 else if (status & BMSR_LSTATUS) 2560 goto done; 2561 } 2562 2563 /* Read link and autonegotiation status */ 2564 status = phy_read(phydev, MII_BMSR); 2565 if (status < 0) 2566 return status; 2567 done: 2568 phydev->link = status & BMSR_LSTATUS ? 1 : 0; 2569 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0; 2570 2571 /* Consider the case that autoneg was started and "aneg complete" 2572 * bit has been reset, but "link up" bit not yet. 2573 */ 2574 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete) 2575 phydev->link = 0; 2576 2577 return 0; 2578 } 2579 EXPORT_SYMBOL(genphy_update_link); 2580 2581 int genphy_read_lpa(struct phy_device *phydev) 2582 { 2583 int lpa, lpagb; 2584 2585 if (phydev->autoneg == AUTONEG_ENABLE) { 2586 if (!phydev->autoneg_complete) { 2587 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising, 2588 0); 2589 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0); 2590 return 0; 2591 } 2592 2593 if (phydev->is_gigabit_capable) { 2594 lpagb = phy_read(phydev, MII_STAT1000); 2595 if (lpagb < 0) 2596 return lpagb; 2597 2598 if (lpagb & LPA_1000MSFAIL) { 2599 int adv = phy_read(phydev, MII_CTRL1000); 2600 2601 if (adv < 0) 2602 return adv; 2603 2604 if (adv & CTL1000_ENABLE_MASTER) 2605 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n"); 2606 else 2607 phydev_err(phydev, "Master/Slave resolution failed\n"); 2608 return -ENOLINK; 2609 } 2610 2611 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising, 2612 lpagb); 2613 } 2614 2615 lpa = phy_read(phydev, MII_LPA); 2616 if (lpa < 0) 2617 return lpa; 2618 2619 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa); 2620 } else { 2621 linkmode_zero(phydev->lp_advertising); 2622 } 2623 2624 return 0; 2625 } 2626 EXPORT_SYMBOL(genphy_read_lpa); 2627 2628 /** 2629 * genphy_read_status_fixed - read the link parameters for !aneg mode 2630 * @phydev: target phy_device struct 2631 * 2632 * Read the current duplex and speed state for a PHY operating with 2633 * autonegotiation disabled. 2634 */ 2635 int genphy_read_status_fixed(struct phy_device *phydev) 2636 { 2637 int bmcr = phy_read(phydev, MII_BMCR); 2638 2639 if (bmcr < 0) 2640 return bmcr; 2641 2642 if (bmcr & BMCR_FULLDPLX) 2643 phydev->duplex = DUPLEX_FULL; 2644 else 2645 phydev->duplex = DUPLEX_HALF; 2646 2647 if (bmcr & BMCR_SPEED1000) 2648 phydev->speed = SPEED_1000; 2649 else if (bmcr & BMCR_SPEED100) 2650 phydev->speed = SPEED_100; 2651 else 2652 phydev->speed = SPEED_10; 2653 2654 return 0; 2655 } 2656 EXPORT_SYMBOL(genphy_read_status_fixed); 2657 2658 /** 2659 * genphy_read_status - check the link status and update current link state 2660 * @phydev: target phy_device struct 2661 * 2662 * Description: Check the link, then figure out the current state 2663 * by comparing what we advertise with what the link partner 2664 * advertises. Start by checking the gigabit possibilities, 2665 * then move on to 10/100. 2666 */ 2667 int genphy_read_status(struct phy_device *phydev) 2668 { 2669 int err, old_link = phydev->link; 2670 2671 /* Update the link, but return if there was an error */ 2672 err = genphy_update_link(phydev); 2673 if (err) 2674 return err; 2675 2676 /* why bother the PHY if nothing can have changed */ 2677 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) 2678 return 0; 2679 2680 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED; 2681 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED; 2682 phydev->speed = SPEED_UNKNOWN; 2683 phydev->duplex = DUPLEX_UNKNOWN; 2684 phydev->pause = 0; 2685 phydev->asym_pause = 0; 2686 2687 if (phydev->is_gigabit_capable) { 2688 err = genphy_read_master_slave(phydev); 2689 if (err < 0) 2690 return err; 2691 } 2692 2693 err = genphy_read_lpa(phydev); 2694 if (err < 0) 2695 return err; 2696 2697 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) { 2698 phy_resolve_aneg_linkmode(phydev); 2699 } else if (phydev->autoneg == AUTONEG_DISABLE) { 2700 err = genphy_read_status_fixed(phydev); 2701 if (err < 0) 2702 return err; 2703 } 2704 2705 return 0; 2706 } 2707 EXPORT_SYMBOL(genphy_read_status); 2708 2709 /** 2710 * genphy_c37_read_status - check the link status and update current link state 2711 * @phydev: target phy_device struct 2712 * @changed: pointer where to store if link changed 2713 * 2714 * Description: Check the link, then figure out the current state 2715 * by comparing what we advertise with what the link partner 2716 * advertises. This function is for Clause 37 1000Base-X mode. 2717 * 2718 * If link has changed, @changed is set to true, false otherwise. 2719 */ 2720 int genphy_c37_read_status(struct phy_device *phydev, bool *changed) 2721 { 2722 int lpa, err, old_link = phydev->link; 2723 2724 /* Update the link, but return if there was an error */ 2725 err = genphy_update_link(phydev); 2726 if (err) 2727 return err; 2728 2729 /* why bother the PHY if nothing can have changed */ 2730 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) { 2731 *changed = false; 2732 return 0; 2733 } 2734 2735 /* Signal link has changed */ 2736 *changed = true; 2737 phydev->duplex = DUPLEX_UNKNOWN; 2738 phydev->pause = 0; 2739 phydev->asym_pause = 0; 2740 2741 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) { 2742 lpa = phy_read(phydev, MII_LPA); 2743 if (lpa < 0) 2744 return lpa; 2745 2746 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 2747 phydev->lp_advertising, lpa & LPA_LPACK); 2748 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 2749 phydev->lp_advertising, lpa & LPA_1000XFULL); 2750 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2751 phydev->lp_advertising, lpa & LPA_1000XPAUSE); 2752 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2753 phydev->lp_advertising, 2754 lpa & LPA_1000XPAUSE_ASYM); 2755 2756 phy_resolve_aneg_linkmode(phydev); 2757 } else if (phydev->autoneg == AUTONEG_DISABLE) { 2758 int bmcr = phy_read(phydev, MII_BMCR); 2759 2760 if (bmcr < 0) 2761 return bmcr; 2762 2763 if (bmcr & BMCR_FULLDPLX) 2764 phydev->duplex = DUPLEX_FULL; 2765 else 2766 phydev->duplex = DUPLEX_HALF; 2767 } 2768 2769 return 0; 2770 } 2771 EXPORT_SYMBOL(genphy_c37_read_status); 2772 2773 /** 2774 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit 2775 * @phydev: target phy_device struct 2776 * 2777 * Description: Perform a software PHY reset using the standard 2778 * BMCR_RESET bit and poll for the reset bit to be cleared. 2779 * 2780 * Returns: 0 on success, < 0 on failure 2781 */ 2782 int genphy_soft_reset(struct phy_device *phydev) 2783 { 2784 u16 res = BMCR_RESET; 2785 int ret; 2786 2787 if (phydev->autoneg == AUTONEG_ENABLE) 2788 res |= BMCR_ANRESTART; 2789 2790 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res); 2791 if (ret < 0) 2792 return ret; 2793 2794 /* Clause 22 states that setting bit BMCR_RESET sets control registers 2795 * to their default value. Therefore the POWER DOWN bit is supposed to 2796 * be cleared after soft reset. 2797 */ 2798 phydev->suspended = 0; 2799 2800 ret = phy_poll_reset(phydev); 2801 if (ret) 2802 return ret; 2803 2804 /* BMCR may be reset to defaults */ 2805 if (phydev->autoneg == AUTONEG_DISABLE) 2806 ret = genphy_setup_forced(phydev); 2807 2808 return ret; 2809 } 2810 EXPORT_SYMBOL(genphy_soft_reset); 2811 2812 irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev) 2813 { 2814 /* It seems there are cases where the interrupts are handled by another 2815 * entity (ie an IRQ controller embedded inside the PHY) and do not 2816 * need any other interraction from phylib. In this case, just trigger 2817 * the state machine directly. 2818 */ 2819 phy_trigger_machine(phydev); 2820 2821 return 0; 2822 } 2823 EXPORT_SYMBOL(genphy_handle_interrupt_no_ack); 2824 2825 /** 2826 * genphy_read_abilities - read PHY abilities from Clause 22 registers 2827 * @phydev: target phy_device struct 2828 * 2829 * Description: Reads the PHY's abilities and populates 2830 * phydev->supported accordingly. 2831 * 2832 * Returns: 0 on success, < 0 on failure 2833 */ 2834 int genphy_read_abilities(struct phy_device *phydev) 2835 { 2836 int val; 2837 2838 linkmode_set_bit_array(phy_basic_ports_array, 2839 ARRAY_SIZE(phy_basic_ports_array), 2840 phydev->supported); 2841 2842 val = phy_read(phydev, MII_BMSR); 2843 if (val < 0) 2844 return val; 2845 2846 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported, 2847 val & BMSR_ANEGCAPABLE); 2848 2849 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported, 2850 val & BMSR_100FULL); 2851 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported, 2852 val & BMSR_100HALF); 2853 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported, 2854 val & BMSR_10FULL); 2855 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported, 2856 val & BMSR_10HALF); 2857 2858 if (val & BMSR_ESTATEN) { 2859 val = phy_read(phydev, MII_ESTATUS); 2860 if (val < 0) 2861 return val; 2862 2863 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 2864 phydev->supported, val & ESTATUS_1000_TFULL); 2865 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 2866 phydev->supported, val & ESTATUS_1000_THALF); 2867 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 2868 phydev->supported, val & ESTATUS_1000_XFULL); 2869 } 2870 2871 /* This is optional functionality. If not supported, we may get an error 2872 * which should be ignored. 2873 */ 2874 genphy_c45_read_eee_abilities(phydev); 2875 2876 return 0; 2877 } 2878 EXPORT_SYMBOL(genphy_read_abilities); 2879 2880 /* This is used for the phy device which doesn't support the MMD extended 2881 * register access, but it does have side effect when we are trying to access 2882 * the MMD register via indirect method. 2883 */ 2884 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum) 2885 { 2886 return -EOPNOTSUPP; 2887 } 2888 EXPORT_SYMBOL(genphy_read_mmd_unsupported); 2889 2890 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum, 2891 u16 regnum, u16 val) 2892 { 2893 return -EOPNOTSUPP; 2894 } 2895 EXPORT_SYMBOL(genphy_write_mmd_unsupported); 2896 2897 int genphy_suspend(struct phy_device *phydev) 2898 { 2899 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN); 2900 } 2901 EXPORT_SYMBOL(genphy_suspend); 2902 2903 int genphy_resume(struct phy_device *phydev) 2904 { 2905 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN); 2906 } 2907 EXPORT_SYMBOL(genphy_resume); 2908 2909 int genphy_loopback(struct phy_device *phydev, bool enable) 2910 { 2911 if (enable) { 2912 u16 ctl = BMCR_LOOPBACK; 2913 int ret, val; 2914 2915 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex); 2916 2917 phy_modify(phydev, MII_BMCR, ~0, ctl); 2918 2919 ret = phy_read_poll_timeout(phydev, MII_BMSR, val, 2920 val & BMSR_LSTATUS, 2921 5000, 500000, true); 2922 if (ret) 2923 return ret; 2924 } else { 2925 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0); 2926 2927 phy_config_aneg(phydev); 2928 } 2929 2930 return 0; 2931 } 2932 EXPORT_SYMBOL(genphy_loopback); 2933 2934 /** 2935 * phy_remove_link_mode - Remove a supported link mode 2936 * @phydev: phy_device structure to remove link mode from 2937 * @link_mode: Link mode to be removed 2938 * 2939 * Description: Some MACs don't support all link modes which the PHY 2940 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper 2941 * to remove a link mode. 2942 */ 2943 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode) 2944 { 2945 linkmode_clear_bit(link_mode, phydev->supported); 2946 phy_advertise_supported(phydev); 2947 } 2948 EXPORT_SYMBOL(phy_remove_link_mode); 2949 2950 static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src) 2951 { 2952 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst, 2953 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src)); 2954 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst, 2955 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src)); 2956 } 2957 2958 /** 2959 * phy_advertise_supported - Advertise all supported modes 2960 * @phydev: target phy_device struct 2961 * 2962 * Description: Called to advertise all supported modes, doesn't touch 2963 * pause mode advertising. 2964 */ 2965 void phy_advertise_supported(struct phy_device *phydev) 2966 { 2967 __ETHTOOL_DECLARE_LINK_MODE_MASK(new); 2968 2969 linkmode_copy(new, phydev->supported); 2970 phy_copy_pause_bits(new, phydev->advertising); 2971 linkmode_copy(phydev->advertising, new); 2972 } 2973 EXPORT_SYMBOL(phy_advertise_supported); 2974 2975 /** 2976 * phy_advertise_eee_all - Advertise all supported EEE modes 2977 * @phydev: target phy_device struct 2978 * 2979 * Description: Per default phylib preserves the EEE advertising at the time of 2980 * phy probing, which might be a subset of the supported EEE modes. Use this 2981 * function when all supported EEE modes should be advertised. This does not 2982 * trigger auto-negotiation, so must be called before phy_start()/ 2983 * phylink_start() which will start auto-negotiation. 2984 */ 2985 void phy_advertise_eee_all(struct phy_device *phydev) 2986 { 2987 linkmode_copy(phydev->advertising_eee, phydev->supported_eee); 2988 } 2989 EXPORT_SYMBOL_GPL(phy_advertise_eee_all); 2990 2991 /** 2992 * phy_support_eee - Set initial EEE policy configuration 2993 * @phydev: Target phy_device struct 2994 * 2995 * This function configures the initial policy for Energy Efficient Ethernet 2996 * (EEE) on the specified PHY device, influencing that EEE capabilities are 2997 * advertised before the link is established. It should be called during PHY 2998 * registration by the MAC driver and/or the PHY driver (for SmartEEE PHYs) 2999 * if MAC supports LPI or PHY is capable to compensate missing LPI functionality 3000 * of the MAC. 3001 * 3002 * The function sets default EEE policy parameters, including preparing the PHY 3003 * to advertise EEE capabilities based on hardware support. 3004 * 3005 * It also sets the expected configuration for Low Power Idle (LPI) in the MAC 3006 * driver. If the PHY framework determines that both local and remote 3007 * advertisements support EEE, and the negotiated link mode is compatible with 3008 * EEE, it will set enable_tx_lpi = true. The MAC driver is expected to act on 3009 * this setting by enabling the LPI timer if enable_tx_lpi is set. 3010 */ 3011 void phy_support_eee(struct phy_device *phydev) 3012 { 3013 linkmode_copy(phydev->advertising_eee, phydev->supported_eee); 3014 phydev->eee_cfg.tx_lpi_enabled = true; 3015 phydev->eee_cfg.eee_enabled = true; 3016 } 3017 EXPORT_SYMBOL(phy_support_eee); 3018 3019 /** 3020 * phy_support_sym_pause - Enable support of symmetrical pause 3021 * @phydev: target phy_device struct 3022 * 3023 * Description: Called by the MAC to indicate is supports symmetrical 3024 * Pause, but not asym pause. 3025 */ 3026 void phy_support_sym_pause(struct phy_device *phydev) 3027 { 3028 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported); 3029 phy_copy_pause_bits(phydev->advertising, phydev->supported); 3030 } 3031 EXPORT_SYMBOL(phy_support_sym_pause); 3032 3033 /** 3034 * phy_support_asym_pause - Enable support of asym pause 3035 * @phydev: target phy_device struct 3036 * 3037 * Description: Called by the MAC to indicate is supports Asym Pause. 3038 */ 3039 void phy_support_asym_pause(struct phy_device *phydev) 3040 { 3041 phy_copy_pause_bits(phydev->advertising, phydev->supported); 3042 } 3043 EXPORT_SYMBOL(phy_support_asym_pause); 3044 3045 /** 3046 * phy_set_sym_pause - Configure symmetric Pause 3047 * @phydev: target phy_device struct 3048 * @rx: Receiver Pause is supported 3049 * @tx: Transmit Pause is supported 3050 * @autoneg: Auto neg should be used 3051 * 3052 * Description: Configure advertised Pause support depending on if 3053 * receiver pause and pause auto neg is supported. Generally called 3054 * from the set_pauseparam .ndo. 3055 */ 3056 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx, 3057 bool autoneg) 3058 { 3059 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported); 3060 3061 if (rx && tx && autoneg) 3062 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 3063 phydev->supported); 3064 3065 linkmode_copy(phydev->advertising, phydev->supported); 3066 } 3067 EXPORT_SYMBOL(phy_set_sym_pause); 3068 3069 /** 3070 * phy_set_asym_pause - Configure Pause and Asym Pause 3071 * @phydev: target phy_device struct 3072 * @rx: Receiver Pause is supported 3073 * @tx: Transmit Pause is supported 3074 * 3075 * Description: Configure advertised Pause support depending on if 3076 * transmit and receiver pause is supported. If there has been a 3077 * change in adverting, trigger a new autoneg. Generally called from 3078 * the set_pauseparam .ndo. 3079 */ 3080 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx) 3081 { 3082 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv); 3083 3084 linkmode_copy(oldadv, phydev->advertising); 3085 linkmode_set_pause(phydev->advertising, tx, rx); 3086 3087 if (!linkmode_equal(oldadv, phydev->advertising) && 3088 phydev->autoneg) 3089 phy_start_aneg(phydev); 3090 } 3091 EXPORT_SYMBOL(phy_set_asym_pause); 3092 3093 /** 3094 * phy_validate_pause - Test if the PHY/MAC support the pause configuration 3095 * @phydev: phy_device struct 3096 * @pp: requested pause configuration 3097 * 3098 * Description: Test if the PHY/MAC combination supports the Pause 3099 * configuration the user is requesting. Returns True if it is 3100 * supported, false otherwise. 3101 */ 3102 bool phy_validate_pause(struct phy_device *phydev, 3103 struct ethtool_pauseparam *pp) 3104 { 3105 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 3106 phydev->supported) && pp->rx_pause) 3107 return false; 3108 3109 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 3110 phydev->supported) && 3111 pp->rx_pause != pp->tx_pause) 3112 return false; 3113 3114 return true; 3115 } 3116 EXPORT_SYMBOL(phy_validate_pause); 3117 3118 /** 3119 * phy_get_pause - resolve negotiated pause modes 3120 * @phydev: phy_device struct 3121 * @tx_pause: pointer to bool to indicate whether transmit pause should be 3122 * enabled. 3123 * @rx_pause: pointer to bool to indicate whether receive pause should be 3124 * enabled. 3125 * 3126 * Resolve and return the flow control modes according to the negotiation 3127 * result. This includes checking that we are operating in full duplex mode. 3128 * See linkmode_resolve_pause() for further details. 3129 */ 3130 void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause) 3131 { 3132 if (phydev->duplex != DUPLEX_FULL) { 3133 *tx_pause = false; 3134 *rx_pause = false; 3135 return; 3136 } 3137 3138 return linkmode_resolve_pause(phydev->advertising, 3139 phydev->lp_advertising, 3140 tx_pause, rx_pause); 3141 } 3142 EXPORT_SYMBOL(phy_get_pause); 3143 3144 #if IS_ENABLED(CONFIG_OF_MDIO) 3145 static int phy_get_int_delay_property(struct device *dev, const char *name) 3146 { 3147 s32 int_delay; 3148 int ret; 3149 3150 ret = device_property_read_u32(dev, name, &int_delay); 3151 if (ret) 3152 return ret; 3153 3154 return int_delay; 3155 } 3156 #else 3157 static int phy_get_int_delay_property(struct device *dev, const char *name) 3158 { 3159 return -EINVAL; 3160 } 3161 #endif 3162 3163 /** 3164 * phy_get_internal_delay - returns the index of the internal delay 3165 * @phydev: phy_device struct 3166 * @dev: pointer to the devices device struct 3167 * @delay_values: array of delays the PHY supports 3168 * @size: the size of the delay array 3169 * @is_rx: boolean to indicate to get the rx internal delay 3170 * 3171 * Returns the index within the array of internal delay passed in. 3172 * If the device property is not present then the interface type is checked 3173 * if the interface defines use of internal delay then a 1 is returned otherwise 3174 * a 0 is returned. 3175 * The array must be in ascending order. If PHY does not have an ascending order 3176 * array then size = 0 and the value of the delay property is returned. 3177 * Return -EINVAL if the delay is invalid or cannot be found. 3178 */ 3179 s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev, 3180 const int *delay_values, int size, bool is_rx) 3181 { 3182 s32 delay; 3183 int i; 3184 3185 if (is_rx) { 3186 delay = phy_get_int_delay_property(dev, "rx-internal-delay-ps"); 3187 if (delay < 0 && size == 0) { 3188 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID || 3189 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID) 3190 return 1; 3191 else 3192 return 0; 3193 } 3194 3195 } else { 3196 delay = phy_get_int_delay_property(dev, "tx-internal-delay-ps"); 3197 if (delay < 0 && size == 0) { 3198 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID || 3199 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID) 3200 return 1; 3201 else 3202 return 0; 3203 } 3204 } 3205 3206 if (delay < 0) 3207 return delay; 3208 3209 if (size == 0) 3210 return delay; 3211 3212 if (delay < delay_values[0] || delay > delay_values[size - 1]) { 3213 phydev_err(phydev, "Delay %d is out of range\n", delay); 3214 return -EINVAL; 3215 } 3216 3217 if (delay == delay_values[0]) 3218 return 0; 3219 3220 for (i = 1; i < size; i++) { 3221 if (delay == delay_values[i]) 3222 return i; 3223 3224 /* Find an approximate index by looking up the table */ 3225 if (delay > delay_values[i - 1] && 3226 delay < delay_values[i]) { 3227 if (delay - delay_values[i - 1] < 3228 delay_values[i] - delay) 3229 return i - 1; 3230 else 3231 return i; 3232 } 3233 } 3234 3235 phydev_err(phydev, "error finding internal delay index for %d\n", 3236 delay); 3237 3238 return -EINVAL; 3239 } 3240 EXPORT_SYMBOL(phy_get_internal_delay); 3241 3242 static int phy_led_set_brightness(struct led_classdev *led_cdev, 3243 enum led_brightness value) 3244 { 3245 struct phy_led *phyled = to_phy_led(led_cdev); 3246 struct phy_device *phydev = phyled->phydev; 3247 int err; 3248 3249 mutex_lock(&phydev->lock); 3250 err = phydev->drv->led_brightness_set(phydev, phyled->index, value); 3251 mutex_unlock(&phydev->lock); 3252 3253 return err; 3254 } 3255 3256 static int phy_led_blink_set(struct led_classdev *led_cdev, 3257 unsigned long *delay_on, 3258 unsigned long *delay_off) 3259 { 3260 struct phy_led *phyled = to_phy_led(led_cdev); 3261 struct phy_device *phydev = phyled->phydev; 3262 int err; 3263 3264 mutex_lock(&phydev->lock); 3265 err = phydev->drv->led_blink_set(phydev, phyled->index, 3266 delay_on, delay_off); 3267 mutex_unlock(&phydev->lock); 3268 3269 return err; 3270 } 3271 3272 static __maybe_unused struct device * 3273 phy_led_hw_control_get_device(struct led_classdev *led_cdev) 3274 { 3275 struct phy_led *phyled = to_phy_led(led_cdev); 3276 struct phy_device *phydev = phyled->phydev; 3277 3278 if (phydev->attached_dev) 3279 return &phydev->attached_dev->dev; 3280 return NULL; 3281 } 3282 3283 static int __maybe_unused 3284 phy_led_hw_control_get(struct led_classdev *led_cdev, 3285 unsigned long *rules) 3286 { 3287 struct phy_led *phyled = to_phy_led(led_cdev); 3288 struct phy_device *phydev = phyled->phydev; 3289 int err; 3290 3291 mutex_lock(&phydev->lock); 3292 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules); 3293 mutex_unlock(&phydev->lock); 3294 3295 return err; 3296 } 3297 3298 static int __maybe_unused 3299 phy_led_hw_control_set(struct led_classdev *led_cdev, 3300 unsigned long rules) 3301 { 3302 struct phy_led *phyled = to_phy_led(led_cdev); 3303 struct phy_device *phydev = phyled->phydev; 3304 int err; 3305 3306 mutex_lock(&phydev->lock); 3307 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules); 3308 mutex_unlock(&phydev->lock); 3309 3310 return err; 3311 } 3312 3313 static __maybe_unused int phy_led_hw_is_supported(struct led_classdev *led_cdev, 3314 unsigned long rules) 3315 { 3316 struct phy_led *phyled = to_phy_led(led_cdev); 3317 struct phy_device *phydev = phyled->phydev; 3318 int err; 3319 3320 mutex_lock(&phydev->lock); 3321 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules); 3322 mutex_unlock(&phydev->lock); 3323 3324 return err; 3325 } 3326 3327 static void phy_leds_unregister(struct phy_device *phydev) 3328 { 3329 struct phy_led *phyled; 3330 3331 list_for_each_entry(phyled, &phydev->leds, list) { 3332 led_classdev_unregister(&phyled->led_cdev); 3333 } 3334 } 3335 3336 static int of_phy_led(struct phy_device *phydev, 3337 struct device_node *led) 3338 { 3339 struct device *dev = &phydev->mdio.dev; 3340 struct led_init_data init_data = {}; 3341 struct led_classdev *cdev; 3342 unsigned long modes = 0; 3343 struct phy_led *phyled; 3344 u32 index; 3345 int err; 3346 3347 phyled = devm_kzalloc(dev, sizeof(*phyled), GFP_KERNEL); 3348 if (!phyled) 3349 return -ENOMEM; 3350 3351 cdev = &phyled->led_cdev; 3352 phyled->phydev = phydev; 3353 3354 err = of_property_read_u32(led, "reg", &index); 3355 if (err) 3356 return err; 3357 if (index > U8_MAX) 3358 return -EINVAL; 3359 3360 if (of_property_read_bool(led, "active-low")) 3361 set_bit(PHY_LED_ACTIVE_LOW, &modes); 3362 if (of_property_read_bool(led, "inactive-high-impedance")) 3363 set_bit(PHY_LED_INACTIVE_HIGH_IMPEDANCE, &modes); 3364 3365 if (modes) { 3366 /* Return error if asked to set polarity modes but not supported */ 3367 if (!phydev->drv->led_polarity_set) 3368 return -EINVAL; 3369 3370 err = phydev->drv->led_polarity_set(phydev, index, modes); 3371 if (err) 3372 return err; 3373 } 3374 3375 phyled->index = index; 3376 if (phydev->drv->led_brightness_set) 3377 cdev->brightness_set_blocking = phy_led_set_brightness; 3378 if (phydev->drv->led_blink_set) 3379 cdev->blink_set = phy_led_blink_set; 3380 3381 #ifdef CONFIG_LEDS_TRIGGERS 3382 if (phydev->drv->led_hw_is_supported && 3383 phydev->drv->led_hw_control_set && 3384 phydev->drv->led_hw_control_get) { 3385 cdev->hw_control_is_supported = phy_led_hw_is_supported; 3386 cdev->hw_control_set = phy_led_hw_control_set; 3387 cdev->hw_control_get = phy_led_hw_control_get; 3388 cdev->hw_control_trigger = "netdev"; 3389 } 3390 3391 cdev->hw_control_get_device = phy_led_hw_control_get_device; 3392 #endif 3393 cdev->max_brightness = 1; 3394 init_data.devicename = dev_name(&phydev->mdio.dev); 3395 init_data.fwnode = of_fwnode_handle(led); 3396 init_data.devname_mandatory = true; 3397 3398 err = led_classdev_register_ext(dev, cdev, &init_data); 3399 if (err) 3400 return err; 3401 3402 list_add(&phyled->list, &phydev->leds); 3403 3404 return 0; 3405 } 3406 3407 static int of_phy_leds(struct phy_device *phydev) 3408 { 3409 struct device_node *node = phydev->mdio.dev.of_node; 3410 struct device_node *leds; 3411 int err; 3412 3413 if (!IS_ENABLED(CONFIG_OF_MDIO)) 3414 return 0; 3415 3416 if (!node) 3417 return 0; 3418 3419 leds = of_get_child_by_name(node, "leds"); 3420 if (!leds) 3421 return 0; 3422 3423 for_each_available_child_of_node_scoped(leds, led) { 3424 err = of_phy_led(phydev, led); 3425 if (err) { 3426 of_node_put(leds); 3427 phy_leds_unregister(phydev); 3428 return err; 3429 } 3430 } 3431 3432 of_node_put(leds); 3433 return 0; 3434 } 3435 3436 /** 3437 * fwnode_mdio_find_device - Given a fwnode, find the mdio_device 3438 * @fwnode: pointer to the mdio_device's fwnode 3439 * 3440 * If successful, returns a pointer to the mdio_device with the embedded 3441 * struct device refcount incremented by one, or NULL on failure. 3442 * The caller should call put_device() on the mdio_device after its use. 3443 */ 3444 struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode) 3445 { 3446 struct device *d; 3447 3448 if (!fwnode) 3449 return NULL; 3450 3451 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode); 3452 if (!d) 3453 return NULL; 3454 3455 return to_mdio_device(d); 3456 } 3457 EXPORT_SYMBOL(fwnode_mdio_find_device); 3458 3459 /** 3460 * fwnode_phy_find_device - For provided phy_fwnode, find phy_device. 3461 * 3462 * @phy_fwnode: Pointer to the phy's fwnode. 3463 * 3464 * If successful, returns a pointer to the phy_device with the embedded 3465 * struct device refcount incremented by one, or NULL on failure. 3466 */ 3467 struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode) 3468 { 3469 struct mdio_device *mdiodev; 3470 3471 mdiodev = fwnode_mdio_find_device(phy_fwnode); 3472 if (!mdiodev) 3473 return NULL; 3474 3475 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) 3476 return to_phy_device(&mdiodev->dev); 3477 3478 put_device(&mdiodev->dev); 3479 3480 return NULL; 3481 } 3482 EXPORT_SYMBOL(fwnode_phy_find_device); 3483 3484 /** 3485 * device_phy_find_device - For the given device, get the phy_device 3486 * @dev: Pointer to the given device 3487 * 3488 * Refer return conditions of fwnode_phy_find_device(). 3489 */ 3490 struct phy_device *device_phy_find_device(struct device *dev) 3491 { 3492 return fwnode_phy_find_device(dev_fwnode(dev)); 3493 } 3494 EXPORT_SYMBOL_GPL(device_phy_find_device); 3495 3496 /** 3497 * fwnode_get_phy_node - Get the phy_node using the named reference. 3498 * @fwnode: Pointer to fwnode from which phy_node has to be obtained. 3499 * 3500 * Refer return conditions of fwnode_find_reference(). 3501 * For ACPI, only "phy-handle" is supported. Legacy DT properties "phy" 3502 * and "phy-device" are not supported in ACPI. DT supports all the three 3503 * named references to the phy node. 3504 */ 3505 struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode) 3506 { 3507 struct fwnode_handle *phy_node; 3508 3509 /* Only phy-handle is used for ACPI */ 3510 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0); 3511 if (is_acpi_node(fwnode) || !IS_ERR(phy_node)) 3512 return phy_node; 3513 phy_node = fwnode_find_reference(fwnode, "phy", 0); 3514 if (IS_ERR(phy_node)) 3515 phy_node = fwnode_find_reference(fwnode, "phy-device", 0); 3516 return phy_node; 3517 } 3518 EXPORT_SYMBOL_GPL(fwnode_get_phy_node); 3519 3520 /** 3521 * phy_probe - probe and init a PHY device 3522 * @dev: device to probe and init 3523 * 3524 * Take care of setting up the phy_device structure, set the state to READY. 3525 */ 3526 static int phy_probe(struct device *dev) 3527 { 3528 struct phy_device *phydev = to_phy_device(dev); 3529 struct device_driver *drv = phydev->mdio.dev.driver; 3530 struct phy_driver *phydrv = to_phy_driver(drv); 3531 int err = 0; 3532 3533 phydev->drv = phydrv; 3534 3535 /* Disable the interrupt if the PHY doesn't support it 3536 * but the interrupt is still a valid one 3537 */ 3538 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev)) 3539 phydev->irq = PHY_POLL; 3540 3541 if (phydrv->flags & PHY_IS_INTERNAL) 3542 phydev->is_internal = true; 3543 3544 /* Deassert the reset signal */ 3545 phy_device_reset(phydev, 0); 3546 3547 if (phydev->drv->probe) { 3548 err = phydev->drv->probe(phydev); 3549 if (err) 3550 goto out; 3551 } 3552 3553 phy_disable_interrupts(phydev); 3554 3555 /* Start out supporting everything. Eventually, 3556 * a controller will attach, and may modify one 3557 * or both of these values 3558 */ 3559 if (phydrv->features) { 3560 linkmode_copy(phydev->supported, phydrv->features); 3561 genphy_c45_read_eee_abilities(phydev); 3562 } 3563 else if (phydrv->get_features) 3564 err = phydrv->get_features(phydev); 3565 else if (phydev->is_c45) 3566 err = genphy_c45_pma_read_abilities(phydev); 3567 else 3568 err = genphy_read_abilities(phydev); 3569 3570 if (err) 3571 goto out; 3572 3573 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 3574 phydev->supported)) 3575 phydev->autoneg = 0; 3576 3577 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 3578 phydev->supported)) 3579 phydev->is_gigabit_capable = 1; 3580 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 3581 phydev->supported)) 3582 phydev->is_gigabit_capable = 1; 3583 3584 of_set_phy_supported(phydev); 3585 phy_advertise_supported(phydev); 3586 3587 /* Get PHY default EEE advertising modes and handle them as potentially 3588 * safe initial configuration. 3589 */ 3590 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee); 3591 if (err) 3592 goto out; 3593 3594 /* There is no "enabled" flag. If PHY is advertising, assume it is 3595 * kind of enabled. 3596 */ 3597 phydev->eee_enabled = !linkmode_empty(phydev->advertising_eee); 3598 3599 /* Some PHYs may advertise, by default, not support EEE modes. So, 3600 * we need to clean them. 3601 */ 3602 if (phydev->eee_enabled) 3603 linkmode_and(phydev->advertising_eee, phydev->supported_eee, 3604 phydev->advertising_eee); 3605 3606 /* Get the EEE modes we want to prohibit. We will ask 3607 * the PHY stop advertising these mode later on 3608 */ 3609 of_set_phy_eee_broken(phydev); 3610 3611 /* The Pause Frame bits indicate that the PHY can support passing 3612 * pause frames. During autonegotiation, the PHYs will determine if 3613 * they should allow pause frames to pass. The MAC driver should then 3614 * use that result to determine whether to enable flow control via 3615 * pause frames. 3616 * 3617 * Normally, PHY drivers should not set the Pause bits, and instead 3618 * allow phylib to do that. However, there may be some situations 3619 * (e.g. hardware erratum) where the driver wants to set only one 3620 * of these bits. 3621 */ 3622 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) && 3623 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) { 3624 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 3625 phydev->supported); 3626 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 3627 phydev->supported); 3628 } 3629 3630 /* Set the state to READY by default */ 3631 phydev->state = PHY_READY; 3632 3633 /* Get the LEDs from the device tree, and instantiate standard 3634 * LEDs for them. 3635 */ 3636 if (IS_ENABLED(CONFIG_PHYLIB_LEDS)) 3637 err = of_phy_leds(phydev); 3638 3639 out: 3640 /* Re-assert the reset signal on error */ 3641 if (err) 3642 phy_device_reset(phydev, 1); 3643 3644 return err; 3645 } 3646 3647 static int phy_remove(struct device *dev) 3648 { 3649 struct phy_device *phydev = to_phy_device(dev); 3650 3651 cancel_delayed_work_sync(&phydev->state_queue); 3652 3653 if (IS_ENABLED(CONFIG_PHYLIB_LEDS)) 3654 phy_leds_unregister(phydev); 3655 3656 phydev->state = PHY_DOWN; 3657 3658 sfp_bus_del_upstream(phydev->sfp_bus); 3659 phydev->sfp_bus = NULL; 3660 3661 if (phydev->drv && phydev->drv->remove) 3662 phydev->drv->remove(phydev); 3663 3664 /* Assert the reset signal */ 3665 phy_device_reset(phydev, 1); 3666 3667 phydev->drv = NULL; 3668 3669 return 0; 3670 } 3671 3672 /** 3673 * phy_driver_register - register a phy_driver with the PHY layer 3674 * @new_driver: new phy_driver to register 3675 * @owner: module owning this PHY 3676 */ 3677 int phy_driver_register(struct phy_driver *new_driver, struct module *owner) 3678 { 3679 int retval; 3680 3681 /* Either the features are hard coded, or dynamically 3682 * determined. It cannot be both. 3683 */ 3684 if (WARN_ON(new_driver->features && new_driver->get_features)) { 3685 pr_err("%s: features and get_features must not both be set\n", 3686 new_driver->name); 3687 return -EINVAL; 3688 } 3689 3690 /* PHYLIB device drivers must not match using a DT compatible table 3691 * as this bypasses our checks that the mdiodev that is being matched 3692 * is backed by a struct phy_device. If such a case happens, we will 3693 * make out-of-bounds accesses and lockup in phydev->lock. 3694 */ 3695 if (WARN(new_driver->mdiodrv.driver.of_match_table, 3696 "%s: driver must not provide a DT match table\n", 3697 new_driver->name)) 3698 return -EINVAL; 3699 3700 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY; 3701 new_driver->mdiodrv.driver.name = new_driver->name; 3702 new_driver->mdiodrv.driver.bus = &mdio_bus_type; 3703 new_driver->mdiodrv.driver.probe = phy_probe; 3704 new_driver->mdiodrv.driver.remove = phy_remove; 3705 new_driver->mdiodrv.driver.owner = owner; 3706 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS; 3707 3708 retval = driver_register(&new_driver->mdiodrv.driver); 3709 if (retval) { 3710 pr_err("%s: Error %d in registering driver\n", 3711 new_driver->name, retval); 3712 3713 return retval; 3714 } 3715 3716 pr_debug("%s: Registered new driver\n", new_driver->name); 3717 3718 return 0; 3719 } 3720 EXPORT_SYMBOL(phy_driver_register); 3721 3722 int phy_drivers_register(struct phy_driver *new_driver, int n, 3723 struct module *owner) 3724 { 3725 int i, ret = 0; 3726 3727 for (i = 0; i < n; i++) { 3728 ret = phy_driver_register(new_driver + i, owner); 3729 if (ret) { 3730 while (i-- > 0) 3731 phy_driver_unregister(new_driver + i); 3732 break; 3733 } 3734 } 3735 return ret; 3736 } 3737 EXPORT_SYMBOL(phy_drivers_register); 3738 3739 void phy_driver_unregister(struct phy_driver *drv) 3740 { 3741 driver_unregister(&drv->mdiodrv.driver); 3742 } 3743 EXPORT_SYMBOL(phy_driver_unregister); 3744 3745 void phy_drivers_unregister(struct phy_driver *drv, int n) 3746 { 3747 int i; 3748 3749 for (i = 0; i < n; i++) 3750 phy_driver_unregister(drv + i); 3751 } 3752 EXPORT_SYMBOL(phy_drivers_unregister); 3753 3754 static struct phy_driver genphy_driver = { 3755 .phy_id = 0xffffffff, 3756 .phy_id_mask = 0xffffffff, 3757 .name = "Generic PHY", 3758 .get_features = genphy_read_abilities, 3759 .suspend = genphy_suspend, 3760 .resume = genphy_resume, 3761 .set_loopback = genphy_loopback, 3762 }; 3763 3764 static const struct ethtool_phy_ops phy_ethtool_phy_ops = { 3765 .get_sset_count = phy_ethtool_get_sset_count, 3766 .get_strings = phy_ethtool_get_strings, 3767 .get_stats = phy_ethtool_get_stats, 3768 .get_plca_cfg = phy_ethtool_get_plca_cfg, 3769 .set_plca_cfg = phy_ethtool_set_plca_cfg, 3770 .get_plca_status = phy_ethtool_get_plca_status, 3771 .start_cable_test = phy_start_cable_test, 3772 .start_cable_test_tdr = phy_start_cable_test_tdr, 3773 }; 3774 3775 static const struct phylib_stubs __phylib_stubs = { 3776 .hwtstamp_get = __phy_hwtstamp_get, 3777 .hwtstamp_set = __phy_hwtstamp_set, 3778 }; 3779 3780 static void phylib_register_stubs(void) 3781 { 3782 phylib_stubs = &__phylib_stubs; 3783 } 3784 3785 static void phylib_unregister_stubs(void) 3786 { 3787 phylib_stubs = NULL; 3788 } 3789 3790 static int __init phy_init(void) 3791 { 3792 int rc; 3793 3794 rtnl_lock(); 3795 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops); 3796 phylib_register_stubs(); 3797 rtnl_unlock(); 3798 3799 rc = mdio_bus_init(); 3800 if (rc) 3801 goto err_ethtool_phy_ops; 3802 3803 features_init(); 3804 3805 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE); 3806 if (rc) 3807 goto err_mdio_bus; 3808 3809 rc = phy_driver_register(&genphy_driver, THIS_MODULE); 3810 if (rc) 3811 goto err_c45; 3812 3813 return 0; 3814 3815 err_c45: 3816 phy_driver_unregister(&genphy_c45_driver); 3817 err_mdio_bus: 3818 mdio_bus_exit(); 3819 err_ethtool_phy_ops: 3820 rtnl_lock(); 3821 phylib_unregister_stubs(); 3822 ethtool_set_ethtool_phy_ops(NULL); 3823 rtnl_unlock(); 3824 3825 return rc; 3826 } 3827 3828 static void __exit phy_exit(void) 3829 { 3830 phy_driver_unregister(&genphy_c45_driver); 3831 phy_driver_unregister(&genphy_driver); 3832 mdio_bus_exit(); 3833 rtnl_lock(); 3834 phylib_unregister_stubs(); 3835 ethtool_set_ethtool_phy_ops(NULL); 3836 rtnl_unlock(); 3837 } 3838 3839 subsys_initcall(phy_init); 3840 module_exit(phy_exit); 3841