1 /* Framework for finding and configuring PHYs. 2 * Also contains generic PHY driver 3 * 4 * Author: Andy Fleming 5 * 6 * Copyright (c) 2004 Freescale Semiconductor, Inc. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 */ 14 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17 #include <linux/kernel.h> 18 #include <linux/string.h> 19 #include <linux/errno.h> 20 #include <linux/unistd.h> 21 #include <linux/slab.h> 22 #include <linux/interrupt.h> 23 #include <linux/init.h> 24 #include <linux/delay.h> 25 #include <linux/netdevice.h> 26 #include <linux/etherdevice.h> 27 #include <linux/skbuff.h> 28 #include <linux/mm.h> 29 #include <linux/module.h> 30 #include <linux/mii.h> 31 #include <linux/ethtool.h> 32 #include <linux/bitmap.h> 33 #include <linux/phy.h> 34 #include <linux/phy_led_triggers.h> 35 #include <linux/mdio.h> 36 #include <linux/io.h> 37 #include <linux/uaccess.h> 38 #include <linux/of.h> 39 40 #include <asm/irq.h> 41 42 MODULE_DESCRIPTION("PHY library"); 43 MODULE_AUTHOR("Andy Fleming"); 44 MODULE_LICENSE("GPL"); 45 46 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init; 47 EXPORT_SYMBOL_GPL(phy_basic_features); 48 49 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init; 50 EXPORT_SYMBOL_GPL(phy_basic_t1_features); 51 52 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init; 53 EXPORT_SYMBOL_GPL(phy_gbit_features); 54 55 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init; 56 EXPORT_SYMBOL_GPL(phy_gbit_fibre_features); 57 58 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init; 59 EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features); 60 61 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init; 62 EXPORT_SYMBOL_GPL(phy_10gbit_features); 63 64 static const int phy_basic_ports_array[] = { 65 ETHTOOL_LINK_MODE_Autoneg_BIT, 66 ETHTOOL_LINK_MODE_TP_BIT, 67 ETHTOOL_LINK_MODE_MII_BIT, 68 }; 69 EXPORT_SYMBOL_GPL(phy_basic_ports_array); 70 71 static const int phy_fibre_port_array[] = { 72 ETHTOOL_LINK_MODE_FIBRE_BIT, 73 }; 74 EXPORT_SYMBOL_GPL(phy_fibre_port_array); 75 76 static const int phy_all_ports_features_array[] = { 77 ETHTOOL_LINK_MODE_Autoneg_BIT, 78 ETHTOOL_LINK_MODE_TP_BIT, 79 ETHTOOL_LINK_MODE_MII_BIT, 80 ETHTOOL_LINK_MODE_FIBRE_BIT, 81 ETHTOOL_LINK_MODE_AUI_BIT, 82 ETHTOOL_LINK_MODE_BNC_BIT, 83 ETHTOOL_LINK_MODE_Backplane_BIT, 84 }; 85 EXPORT_SYMBOL_GPL(phy_all_ports_features_array); 86 87 const int phy_10_100_features_array[4] = { 88 ETHTOOL_LINK_MODE_10baseT_Half_BIT, 89 ETHTOOL_LINK_MODE_10baseT_Full_BIT, 90 ETHTOOL_LINK_MODE_100baseT_Half_BIT, 91 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 92 }; 93 EXPORT_SYMBOL_GPL(phy_10_100_features_array); 94 95 const int phy_basic_t1_features_array[2] = { 96 ETHTOOL_LINK_MODE_TP_BIT, 97 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 98 }; 99 EXPORT_SYMBOL_GPL(phy_basic_t1_features_array); 100 101 const int phy_gbit_features_array[2] = { 102 ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 103 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 104 }; 105 EXPORT_SYMBOL_GPL(phy_gbit_features_array); 106 107 const int phy_10gbit_features_array[1] = { 108 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 109 }; 110 EXPORT_SYMBOL_GPL(phy_10gbit_features_array); 111 112 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init; 113 EXPORT_SYMBOL_GPL(phy_10gbit_full_features); 114 115 static const int phy_10gbit_full_features_array[] = { 116 ETHTOOL_LINK_MODE_10baseT_Full_BIT, 117 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 118 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 119 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 120 }; 121 122 static void features_init(void) 123 { 124 /* 10/100 half/full*/ 125 linkmode_set_bit_array(phy_basic_ports_array, 126 ARRAY_SIZE(phy_basic_ports_array), 127 phy_basic_features); 128 linkmode_set_bit_array(phy_10_100_features_array, 129 ARRAY_SIZE(phy_10_100_features_array), 130 phy_basic_features); 131 132 /* 100 full, TP */ 133 linkmode_set_bit_array(phy_basic_t1_features_array, 134 ARRAY_SIZE(phy_basic_t1_features_array), 135 phy_basic_t1_features); 136 137 /* 10/100 half/full + 1000 half/full */ 138 linkmode_set_bit_array(phy_basic_ports_array, 139 ARRAY_SIZE(phy_basic_ports_array), 140 phy_gbit_features); 141 linkmode_set_bit_array(phy_10_100_features_array, 142 ARRAY_SIZE(phy_10_100_features_array), 143 phy_gbit_features); 144 linkmode_set_bit_array(phy_gbit_features_array, 145 ARRAY_SIZE(phy_gbit_features_array), 146 phy_gbit_features); 147 148 /* 10/100 half/full + 1000 half/full + fibre*/ 149 linkmode_set_bit_array(phy_basic_ports_array, 150 ARRAY_SIZE(phy_basic_ports_array), 151 phy_gbit_fibre_features); 152 linkmode_set_bit_array(phy_10_100_features_array, 153 ARRAY_SIZE(phy_10_100_features_array), 154 phy_gbit_fibre_features); 155 linkmode_set_bit_array(phy_gbit_features_array, 156 ARRAY_SIZE(phy_gbit_features_array), 157 phy_gbit_fibre_features); 158 linkmode_set_bit_array(phy_fibre_port_array, 159 ARRAY_SIZE(phy_fibre_port_array), 160 phy_gbit_fibre_features); 161 162 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/ 163 linkmode_set_bit_array(phy_all_ports_features_array, 164 ARRAY_SIZE(phy_all_ports_features_array), 165 phy_gbit_all_ports_features); 166 linkmode_set_bit_array(phy_10_100_features_array, 167 ARRAY_SIZE(phy_10_100_features_array), 168 phy_gbit_all_ports_features); 169 linkmode_set_bit_array(phy_gbit_features_array, 170 ARRAY_SIZE(phy_gbit_features_array), 171 phy_gbit_all_ports_features); 172 173 /* 10/100 half/full + 1000 half/full + 10G full*/ 174 linkmode_set_bit_array(phy_all_ports_features_array, 175 ARRAY_SIZE(phy_all_ports_features_array), 176 phy_10gbit_features); 177 linkmode_set_bit_array(phy_10_100_features_array, 178 ARRAY_SIZE(phy_10_100_features_array), 179 phy_10gbit_features); 180 linkmode_set_bit_array(phy_gbit_features_array, 181 ARRAY_SIZE(phy_gbit_features_array), 182 phy_10gbit_features); 183 linkmode_set_bit_array(phy_10gbit_features_array, 184 ARRAY_SIZE(phy_10gbit_features_array), 185 phy_10gbit_features); 186 187 /* 10/100/1000/10G full */ 188 linkmode_set_bit_array(phy_all_ports_features_array, 189 ARRAY_SIZE(phy_all_ports_features_array), 190 phy_10gbit_full_features); 191 linkmode_set_bit_array(phy_10gbit_full_features_array, 192 ARRAY_SIZE(phy_10gbit_full_features_array), 193 phy_10gbit_full_features); 194 } 195 196 void phy_device_free(struct phy_device *phydev) 197 { 198 put_device(&phydev->mdio.dev); 199 } 200 EXPORT_SYMBOL(phy_device_free); 201 202 static void phy_mdio_device_free(struct mdio_device *mdiodev) 203 { 204 struct phy_device *phydev; 205 206 phydev = container_of(mdiodev, struct phy_device, mdio); 207 phy_device_free(phydev); 208 } 209 210 static void phy_device_release(struct device *dev) 211 { 212 kfree(to_phy_device(dev)); 213 } 214 215 static void phy_mdio_device_remove(struct mdio_device *mdiodev) 216 { 217 struct phy_device *phydev; 218 219 phydev = container_of(mdiodev, struct phy_device, mdio); 220 phy_device_remove(phydev); 221 } 222 223 static struct phy_driver genphy_driver; 224 extern struct phy_driver genphy_10g_driver; 225 226 static LIST_HEAD(phy_fixup_list); 227 static DEFINE_MUTEX(phy_fixup_lock); 228 229 #ifdef CONFIG_PM 230 static bool mdio_bus_phy_may_suspend(struct phy_device *phydev) 231 { 232 struct device_driver *drv = phydev->mdio.dev.driver; 233 struct phy_driver *phydrv = to_phy_driver(drv); 234 struct net_device *netdev = phydev->attached_dev; 235 236 if (!drv || !phydrv->suspend) 237 return false; 238 239 /* PHY not attached? May suspend if the PHY has not already been 240 * suspended as part of a prior call to phy_disconnect() -> 241 * phy_detach() -> phy_suspend() because the parent netdev might be the 242 * MDIO bus driver and clock gated at this point. 243 */ 244 if (!netdev) 245 return !phydev->suspended; 246 247 if (netdev->wol_enabled) 248 return false; 249 250 /* As long as not all affected network drivers support the 251 * wol_enabled flag, let's check for hints that WoL is enabled. 252 * Don't suspend PHY if the attached netdev parent may wake up. 253 * The parent may point to a PCI device, as in tg3 driver. 254 */ 255 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent)) 256 return false; 257 258 /* Also don't suspend PHY if the netdev itself may wakeup. This 259 * is the case for devices w/o underlaying pwr. mgmt. aware bus, 260 * e.g. SoC devices. 261 */ 262 if (device_may_wakeup(&netdev->dev)) 263 return false; 264 265 return true; 266 } 267 268 static int mdio_bus_phy_suspend(struct device *dev) 269 { 270 struct phy_device *phydev = to_phy_device(dev); 271 272 /* We must stop the state machine manually, otherwise it stops out of 273 * control, possibly with the phydev->lock held. Upon resume, netdev 274 * may call phy routines that try to grab the same lock, and that may 275 * lead to a deadlock. 276 */ 277 if (phydev->attached_dev && phydev->adjust_link) 278 phy_stop_machine(phydev); 279 280 if (!mdio_bus_phy_may_suspend(phydev)) 281 return 0; 282 283 return phy_suspend(phydev); 284 } 285 286 static int mdio_bus_phy_resume(struct device *dev) 287 { 288 struct phy_device *phydev = to_phy_device(dev); 289 int ret; 290 291 if (!mdio_bus_phy_may_suspend(phydev)) 292 goto no_resume; 293 294 ret = phy_resume(phydev); 295 if (ret < 0) 296 return ret; 297 298 no_resume: 299 if (phydev->attached_dev && phydev->adjust_link) 300 phy_start_machine(phydev); 301 302 return 0; 303 } 304 305 static int mdio_bus_phy_restore(struct device *dev) 306 { 307 struct phy_device *phydev = to_phy_device(dev); 308 struct net_device *netdev = phydev->attached_dev; 309 int ret; 310 311 if (!netdev) 312 return 0; 313 314 ret = phy_init_hw(phydev); 315 if (ret < 0) 316 return ret; 317 318 if (phydev->attached_dev && phydev->adjust_link) 319 phy_start_machine(phydev); 320 321 return 0; 322 } 323 324 static const struct dev_pm_ops mdio_bus_phy_pm_ops = { 325 .suspend = mdio_bus_phy_suspend, 326 .resume = mdio_bus_phy_resume, 327 .freeze = mdio_bus_phy_suspend, 328 .thaw = mdio_bus_phy_resume, 329 .restore = mdio_bus_phy_restore, 330 }; 331 332 #define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops) 333 334 #else 335 336 #define MDIO_BUS_PHY_PM_OPS NULL 337 338 #endif /* CONFIG_PM */ 339 340 /** 341 * phy_register_fixup - creates a new phy_fixup and adds it to the list 342 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID) 343 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY) 344 * It can also be PHY_ANY_UID 345 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before 346 * comparison 347 * @run: The actual code to be run when a matching PHY is found 348 */ 349 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, 350 int (*run)(struct phy_device *)) 351 { 352 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL); 353 354 if (!fixup) 355 return -ENOMEM; 356 357 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id)); 358 fixup->phy_uid = phy_uid; 359 fixup->phy_uid_mask = phy_uid_mask; 360 fixup->run = run; 361 362 mutex_lock(&phy_fixup_lock); 363 list_add_tail(&fixup->list, &phy_fixup_list); 364 mutex_unlock(&phy_fixup_lock); 365 366 return 0; 367 } 368 EXPORT_SYMBOL(phy_register_fixup); 369 370 /* Registers a fixup to be run on any PHY with the UID in phy_uid */ 371 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask, 372 int (*run)(struct phy_device *)) 373 { 374 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run); 375 } 376 EXPORT_SYMBOL(phy_register_fixup_for_uid); 377 378 /* Registers a fixup to be run on the PHY with id string bus_id */ 379 int phy_register_fixup_for_id(const char *bus_id, 380 int (*run)(struct phy_device *)) 381 { 382 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run); 383 } 384 EXPORT_SYMBOL(phy_register_fixup_for_id); 385 386 /** 387 * phy_unregister_fixup - remove a phy_fixup from the list 388 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list 389 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list 390 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison 391 */ 392 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask) 393 { 394 struct list_head *pos, *n; 395 struct phy_fixup *fixup; 396 int ret; 397 398 ret = -ENODEV; 399 400 mutex_lock(&phy_fixup_lock); 401 list_for_each_safe(pos, n, &phy_fixup_list) { 402 fixup = list_entry(pos, struct phy_fixup, list); 403 404 if ((!strcmp(fixup->bus_id, bus_id)) && 405 ((fixup->phy_uid & phy_uid_mask) == 406 (phy_uid & phy_uid_mask))) { 407 list_del(&fixup->list); 408 kfree(fixup); 409 ret = 0; 410 break; 411 } 412 } 413 mutex_unlock(&phy_fixup_lock); 414 415 return ret; 416 } 417 EXPORT_SYMBOL(phy_unregister_fixup); 418 419 /* Unregisters a fixup of any PHY with the UID in phy_uid */ 420 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask) 421 { 422 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask); 423 } 424 EXPORT_SYMBOL(phy_unregister_fixup_for_uid); 425 426 /* Unregisters a fixup of the PHY with id string bus_id */ 427 int phy_unregister_fixup_for_id(const char *bus_id) 428 { 429 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff); 430 } 431 EXPORT_SYMBOL(phy_unregister_fixup_for_id); 432 433 /* Returns 1 if fixup matches phydev in bus_id and phy_uid. 434 * Fixups can be set to match any in one or more fields. 435 */ 436 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup) 437 { 438 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0) 439 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0) 440 return 0; 441 442 if ((fixup->phy_uid & fixup->phy_uid_mask) != 443 (phydev->phy_id & fixup->phy_uid_mask)) 444 if (fixup->phy_uid != PHY_ANY_UID) 445 return 0; 446 447 return 1; 448 } 449 450 /* Runs any matching fixups for this phydev */ 451 static int phy_scan_fixups(struct phy_device *phydev) 452 { 453 struct phy_fixup *fixup; 454 455 mutex_lock(&phy_fixup_lock); 456 list_for_each_entry(fixup, &phy_fixup_list, list) { 457 if (phy_needs_fixup(phydev, fixup)) { 458 int err = fixup->run(phydev); 459 460 if (err < 0) { 461 mutex_unlock(&phy_fixup_lock); 462 return err; 463 } 464 phydev->has_fixups = true; 465 } 466 } 467 mutex_unlock(&phy_fixup_lock); 468 469 return 0; 470 } 471 472 static int phy_bus_match(struct device *dev, struct device_driver *drv) 473 { 474 struct phy_device *phydev = to_phy_device(dev); 475 struct phy_driver *phydrv = to_phy_driver(drv); 476 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids); 477 int i; 478 479 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)) 480 return 0; 481 482 if (phydrv->match_phy_device) 483 return phydrv->match_phy_device(phydev); 484 485 if (phydev->is_c45) { 486 for (i = 1; i < num_ids; i++) { 487 if (!(phydev->c45_ids.devices_in_package & (1 << i))) 488 continue; 489 490 if ((phydrv->phy_id & phydrv->phy_id_mask) == 491 (phydev->c45_ids.device_ids[i] & 492 phydrv->phy_id_mask)) 493 return 1; 494 } 495 return 0; 496 } else { 497 return (phydrv->phy_id & phydrv->phy_id_mask) == 498 (phydev->phy_id & phydrv->phy_id_mask); 499 } 500 } 501 502 static ssize_t 503 phy_id_show(struct device *dev, struct device_attribute *attr, char *buf) 504 { 505 struct phy_device *phydev = to_phy_device(dev); 506 507 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id); 508 } 509 static DEVICE_ATTR_RO(phy_id); 510 511 static ssize_t 512 phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf) 513 { 514 struct phy_device *phydev = to_phy_device(dev); 515 const char *mode = NULL; 516 517 if (phy_is_internal(phydev)) 518 mode = "internal"; 519 else 520 mode = phy_modes(phydev->interface); 521 522 return sprintf(buf, "%s\n", mode); 523 } 524 static DEVICE_ATTR_RO(phy_interface); 525 526 static ssize_t 527 phy_has_fixups_show(struct device *dev, struct device_attribute *attr, 528 char *buf) 529 { 530 struct phy_device *phydev = to_phy_device(dev); 531 532 return sprintf(buf, "%d\n", phydev->has_fixups); 533 } 534 static DEVICE_ATTR_RO(phy_has_fixups); 535 536 static struct attribute *phy_dev_attrs[] = { 537 &dev_attr_phy_id.attr, 538 &dev_attr_phy_interface.attr, 539 &dev_attr_phy_has_fixups.attr, 540 NULL, 541 }; 542 ATTRIBUTE_GROUPS(phy_dev); 543 544 static const struct device_type mdio_bus_phy_type = { 545 .name = "PHY", 546 .groups = phy_dev_groups, 547 .release = phy_device_release, 548 .pm = MDIO_BUS_PHY_PM_OPS, 549 }; 550 551 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id, 552 bool is_c45, 553 struct phy_c45_device_ids *c45_ids) 554 { 555 struct phy_device *dev; 556 struct mdio_device *mdiodev; 557 558 /* We allocate the device, and initialize the default values */ 559 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 560 if (!dev) 561 return ERR_PTR(-ENOMEM); 562 563 mdiodev = &dev->mdio; 564 mdiodev->dev.parent = &bus->dev; 565 mdiodev->dev.bus = &mdio_bus_type; 566 mdiodev->dev.type = &mdio_bus_phy_type; 567 mdiodev->bus = bus; 568 mdiodev->bus_match = phy_bus_match; 569 mdiodev->addr = addr; 570 mdiodev->flags = MDIO_DEVICE_FLAG_PHY; 571 mdiodev->device_free = phy_mdio_device_free; 572 mdiodev->device_remove = phy_mdio_device_remove; 573 574 dev->speed = 0; 575 dev->duplex = -1; 576 dev->pause = 0; 577 dev->asym_pause = 0; 578 dev->link = 0; 579 dev->interface = PHY_INTERFACE_MODE_GMII; 580 581 dev->autoneg = AUTONEG_ENABLE; 582 583 dev->is_c45 = is_c45; 584 dev->phy_id = phy_id; 585 if (c45_ids) 586 dev->c45_ids = *c45_ids; 587 dev->irq = bus->irq[addr]; 588 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr); 589 590 dev->state = PHY_DOWN; 591 592 mutex_init(&dev->lock); 593 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); 594 595 /* Request the appropriate module unconditionally; don't 596 * bother trying to do so only if it isn't already loaded, 597 * because that gets complicated. A hotplug event would have 598 * done an unconditional modprobe anyway. 599 * We don't do normal hotplug because it won't work for MDIO 600 * -- because it relies on the device staying around for long 601 * enough for the driver to get loaded. With MDIO, the NIC 602 * driver will get bored and give up as soon as it finds that 603 * there's no driver _already_ loaded. 604 */ 605 if (is_c45 && c45_ids) { 606 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 607 int i; 608 609 for (i = 1; i < num_ids; i++) { 610 if (!(c45_ids->devices_in_package & (1 << i))) 611 continue; 612 613 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, 614 MDIO_ID_ARGS(c45_ids->device_ids[i])); 615 } 616 } else { 617 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, 618 MDIO_ID_ARGS(phy_id)); 619 } 620 621 device_initialize(&mdiodev->dev); 622 623 return dev; 624 } 625 EXPORT_SYMBOL(phy_device_create); 626 627 /* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers. 628 * @bus: the target MII bus 629 * @addr: PHY address on the MII bus 630 * @dev_addr: MMD address in the PHY. 631 * @devices_in_package: where to store the devices in package information. 632 * 633 * Description: reads devices in package registers of a MMD at @dev_addr 634 * from PHY at @addr on @bus. 635 * 636 * Returns: 0 on success, -EIO on failure. 637 */ 638 static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr, 639 u32 *devices_in_package) 640 { 641 int phy_reg, reg_addr; 642 643 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2; 644 phy_reg = mdiobus_read(bus, addr, reg_addr); 645 if (phy_reg < 0) 646 return -EIO; 647 *devices_in_package = (phy_reg & 0xffff) << 16; 648 649 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1; 650 phy_reg = mdiobus_read(bus, addr, reg_addr); 651 if (phy_reg < 0) 652 return -EIO; 653 *devices_in_package |= (phy_reg & 0xffff); 654 655 return 0; 656 } 657 658 /** 659 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs. 660 * @bus: the target MII bus 661 * @addr: PHY address on the MII bus 662 * @phy_id: where to store the ID retrieved. 663 * @c45_ids: where to store the c45 ID information. 664 * 665 * If the PHY devices-in-package appears to be valid, it and the 666 * corresponding identifiers are stored in @c45_ids, zero is stored 667 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns 668 * zero on success. 669 * 670 */ 671 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id, 672 struct phy_c45_device_ids *c45_ids) { 673 int phy_reg; 674 int i, reg_addr; 675 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 676 u32 *devs = &c45_ids->devices_in_package; 677 678 /* Find first non-zero Devices In package. Device zero is reserved 679 * for 802.3 c45 complied PHYs, so don't probe it at first. 680 */ 681 for (i = 1; i < num_ids && *devs == 0; i++) { 682 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs); 683 if (phy_reg < 0) 684 return -EIO; 685 686 if ((*devs & 0x1fffffff) == 0x1fffffff) { 687 /* If mostly Fs, there is no device there, 688 * then let's continue to probe more, as some 689 * 10G PHYs have zero Devices In package, 690 * e.g. Cortina CS4315/CS4340 PHY. 691 */ 692 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs); 693 if (phy_reg < 0) 694 return -EIO; 695 /* no device there, let's get out of here */ 696 if ((*devs & 0x1fffffff) == 0x1fffffff) { 697 *phy_id = 0xffffffff; 698 return 0; 699 } else { 700 break; 701 } 702 } 703 } 704 705 /* Now probe Device Identifiers for each device present. */ 706 for (i = 1; i < num_ids; i++) { 707 if (!(c45_ids->devices_in_package & (1 << i))) 708 continue; 709 710 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1; 711 phy_reg = mdiobus_read(bus, addr, reg_addr); 712 if (phy_reg < 0) 713 return -EIO; 714 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16; 715 716 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2; 717 phy_reg = mdiobus_read(bus, addr, reg_addr); 718 if (phy_reg < 0) 719 return -EIO; 720 c45_ids->device_ids[i] |= (phy_reg & 0xffff); 721 } 722 *phy_id = 0; 723 return 0; 724 } 725 726 /** 727 * get_phy_id - reads the specified addr for its ID. 728 * @bus: the target MII bus 729 * @addr: PHY address on the MII bus 730 * @phy_id: where to store the ID retrieved. 731 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 732 * @c45_ids: where to store the c45 ID information. 733 * 734 * Description: In the case of a 802.3-c22 PHY, reads the ID registers 735 * of the PHY at @addr on the @bus, stores it in @phy_id and returns 736 * zero on success. 737 * 738 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and 739 * its return value is in turn returned. 740 * 741 */ 742 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id, 743 bool is_c45, struct phy_c45_device_ids *c45_ids) 744 { 745 int phy_reg; 746 747 if (is_c45) 748 return get_phy_c45_ids(bus, addr, phy_id, c45_ids); 749 750 /* Grab the bits from PHYIR1, and put them in the upper half */ 751 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1); 752 if (phy_reg < 0) { 753 /* if there is no device, return without an error so scanning 754 * the bus works properly 755 */ 756 if (phy_reg == -EIO || phy_reg == -ENODEV) { 757 *phy_id = 0xffffffff; 758 return 0; 759 } 760 761 return -EIO; 762 } 763 764 *phy_id = (phy_reg & 0xffff) << 16; 765 766 /* Grab the bits from PHYIR2, and put them in the lower half */ 767 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2); 768 if (phy_reg < 0) 769 return -EIO; 770 771 *phy_id |= (phy_reg & 0xffff); 772 773 return 0; 774 } 775 776 /** 777 * get_phy_device - reads the specified PHY device and returns its @phy_device 778 * struct 779 * @bus: the target MII bus 780 * @addr: PHY address on the MII bus 781 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 782 * 783 * Description: Reads the ID registers of the PHY at @addr on the 784 * @bus, then allocates and returns the phy_device to represent it. 785 */ 786 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45) 787 { 788 struct phy_c45_device_ids c45_ids = {0}; 789 u32 phy_id = 0; 790 int r; 791 792 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids); 793 if (r) 794 return ERR_PTR(r); 795 796 /* If the phy_id is mostly Fs, there is no device there */ 797 if ((phy_id & 0x1fffffff) == 0x1fffffff) 798 return ERR_PTR(-ENODEV); 799 800 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids); 801 } 802 EXPORT_SYMBOL(get_phy_device); 803 804 /** 805 * phy_device_register - Register the phy device on the MDIO bus 806 * @phydev: phy_device structure to be added to the MDIO bus 807 */ 808 int phy_device_register(struct phy_device *phydev) 809 { 810 int err; 811 812 err = mdiobus_register_device(&phydev->mdio); 813 if (err) 814 return err; 815 816 /* Deassert the reset signal */ 817 phy_device_reset(phydev, 0); 818 819 /* Run all of the fixups for this PHY */ 820 err = phy_scan_fixups(phydev); 821 if (err) { 822 pr_err("PHY %d failed to initialize\n", phydev->mdio.addr); 823 goto out; 824 } 825 826 err = device_add(&phydev->mdio.dev); 827 if (err) { 828 pr_err("PHY %d failed to add\n", phydev->mdio.addr); 829 goto out; 830 } 831 832 return 0; 833 834 out: 835 /* Assert the reset signal */ 836 phy_device_reset(phydev, 1); 837 838 mdiobus_unregister_device(&phydev->mdio); 839 return err; 840 } 841 EXPORT_SYMBOL(phy_device_register); 842 843 /** 844 * phy_device_remove - Remove a previously registered phy device from the MDIO bus 845 * @phydev: phy_device structure to remove 846 * 847 * This doesn't free the phy_device itself, it merely reverses the effects 848 * of phy_device_register(). Use phy_device_free() to free the device 849 * after calling this function. 850 */ 851 void phy_device_remove(struct phy_device *phydev) 852 { 853 device_del(&phydev->mdio.dev); 854 855 /* Assert the reset signal */ 856 phy_device_reset(phydev, 1); 857 858 mdiobus_unregister_device(&phydev->mdio); 859 } 860 EXPORT_SYMBOL(phy_device_remove); 861 862 /** 863 * phy_find_first - finds the first PHY device on the bus 864 * @bus: the target MII bus 865 */ 866 struct phy_device *phy_find_first(struct mii_bus *bus) 867 { 868 struct phy_device *phydev; 869 int addr; 870 871 for (addr = 0; addr < PHY_MAX_ADDR; addr++) { 872 phydev = mdiobus_get_phy(bus, addr); 873 if (phydev) 874 return phydev; 875 } 876 return NULL; 877 } 878 EXPORT_SYMBOL(phy_find_first); 879 880 static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier) 881 { 882 struct net_device *netdev = phydev->attached_dev; 883 884 if (do_carrier) { 885 if (up) 886 netif_carrier_on(netdev); 887 else 888 netif_carrier_off(netdev); 889 } 890 phydev->adjust_link(netdev); 891 } 892 893 /** 894 * phy_prepare_link - prepares the PHY layer to monitor link status 895 * @phydev: target phy_device struct 896 * @handler: callback function for link status change notifications 897 * 898 * Description: Tells the PHY infrastructure to handle the 899 * gory details on monitoring link status (whether through 900 * polling or an interrupt), and to call back to the 901 * connected device driver when the link status changes. 902 * If you want to monitor your own link state, don't call 903 * this function. 904 */ 905 static void phy_prepare_link(struct phy_device *phydev, 906 void (*handler)(struct net_device *)) 907 { 908 phydev->adjust_link = handler; 909 } 910 911 /** 912 * phy_connect_direct - connect an ethernet device to a specific phy_device 913 * @dev: the network device to connect 914 * @phydev: the pointer to the phy device 915 * @handler: callback function for state change notifications 916 * @interface: PHY device's interface 917 */ 918 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 919 void (*handler)(struct net_device *), 920 phy_interface_t interface) 921 { 922 int rc; 923 924 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 925 if (rc) 926 return rc; 927 928 phy_prepare_link(phydev, handler); 929 phy_start_machine(phydev); 930 if (phydev->irq > 0) 931 phy_start_interrupts(phydev); 932 933 return 0; 934 } 935 EXPORT_SYMBOL(phy_connect_direct); 936 937 /** 938 * phy_connect - connect an ethernet device to a PHY device 939 * @dev: the network device to connect 940 * @bus_id: the id string of the PHY device to connect 941 * @handler: callback function for state change notifications 942 * @interface: PHY device's interface 943 * 944 * Description: Convenience function for connecting ethernet 945 * devices to PHY devices. The default behavior is for 946 * the PHY infrastructure to handle everything, and only notify 947 * the connected driver when the link status changes. If you 948 * don't want, or can't use the provided functionality, you may 949 * choose to call only the subset of functions which provide 950 * the desired functionality. 951 */ 952 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, 953 void (*handler)(struct net_device *), 954 phy_interface_t interface) 955 { 956 struct phy_device *phydev; 957 struct device *d; 958 int rc; 959 960 /* Search the list of PHY devices on the mdio bus for the 961 * PHY with the requested name 962 */ 963 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 964 if (!d) { 965 pr_err("PHY %s not found\n", bus_id); 966 return ERR_PTR(-ENODEV); 967 } 968 phydev = to_phy_device(d); 969 970 rc = phy_connect_direct(dev, phydev, handler, interface); 971 put_device(d); 972 if (rc) 973 return ERR_PTR(rc); 974 975 return phydev; 976 } 977 EXPORT_SYMBOL(phy_connect); 978 979 /** 980 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY 981 * device 982 * @phydev: target phy_device struct 983 */ 984 void phy_disconnect(struct phy_device *phydev) 985 { 986 if (phydev->irq > 0) 987 phy_stop_interrupts(phydev); 988 989 phy_stop_machine(phydev); 990 991 phydev->adjust_link = NULL; 992 993 phy_detach(phydev); 994 } 995 EXPORT_SYMBOL(phy_disconnect); 996 997 /** 998 * phy_poll_reset - Safely wait until a PHY reset has properly completed 999 * @phydev: The PHY device to poll 1000 * 1001 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as 1002 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR 1003 * register must be polled until the BMCR_RESET bit clears. 1004 * 1005 * Furthermore, any attempts to write to PHY registers may have no effect 1006 * or even generate MDIO bus errors until this is complete. 1007 * 1008 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the 1009 * standard and do not fully reset after the BMCR_RESET bit is set, and may 1010 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an 1011 * effort to support such broken PHYs, this function is separate from the 1012 * standard phy_init_hw() which will zero all the other bits in the BMCR 1013 * and reapply all driver-specific and board-specific fixups. 1014 */ 1015 static int phy_poll_reset(struct phy_device *phydev) 1016 { 1017 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */ 1018 unsigned int retries = 12; 1019 int ret; 1020 1021 do { 1022 msleep(50); 1023 ret = phy_read(phydev, MII_BMCR); 1024 if (ret < 0) 1025 return ret; 1026 } while (ret & BMCR_RESET && --retries); 1027 if (ret & BMCR_RESET) 1028 return -ETIMEDOUT; 1029 1030 /* Some chips (smsc911x) may still need up to another 1ms after the 1031 * BMCR_RESET bit is cleared before they are usable. 1032 */ 1033 msleep(1); 1034 return 0; 1035 } 1036 1037 int phy_init_hw(struct phy_device *phydev) 1038 { 1039 int ret = 0; 1040 1041 /* Deassert the reset signal */ 1042 phy_device_reset(phydev, 0); 1043 1044 if (!phydev->drv || !phydev->drv->config_init) 1045 return 0; 1046 1047 if (phydev->drv->soft_reset) 1048 ret = phydev->drv->soft_reset(phydev); 1049 1050 if (ret < 0) 1051 return ret; 1052 1053 ret = phy_scan_fixups(phydev); 1054 if (ret < 0) 1055 return ret; 1056 1057 return phydev->drv->config_init(phydev); 1058 } 1059 EXPORT_SYMBOL(phy_init_hw); 1060 1061 void phy_attached_info(struct phy_device *phydev) 1062 { 1063 phy_attached_print(phydev, NULL); 1064 } 1065 EXPORT_SYMBOL(phy_attached_info); 1066 1067 #define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)" 1068 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...) 1069 { 1070 const char *drv_name = phydev->drv ? phydev->drv->name : "unbound"; 1071 char *irq_str; 1072 char irq_num[8]; 1073 1074 switch(phydev->irq) { 1075 case PHY_POLL: 1076 irq_str = "POLL"; 1077 break; 1078 case PHY_IGNORE_INTERRUPT: 1079 irq_str = "IGNORE"; 1080 break; 1081 default: 1082 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq); 1083 irq_str = irq_num; 1084 break; 1085 } 1086 1087 1088 if (!fmt) { 1089 phydev_info(phydev, ATTACHED_FMT "\n", 1090 drv_name, phydev_name(phydev), 1091 irq_str); 1092 } else { 1093 va_list ap; 1094 1095 phydev_info(phydev, ATTACHED_FMT, 1096 drv_name, phydev_name(phydev), 1097 irq_str); 1098 1099 va_start(ap, fmt); 1100 vprintk(fmt, ap); 1101 va_end(ap); 1102 } 1103 } 1104 EXPORT_SYMBOL(phy_attached_print); 1105 1106 /** 1107 * phy_attach_direct - attach a network device to a given PHY device pointer 1108 * @dev: network device to attach 1109 * @phydev: Pointer to phy_device to attach 1110 * @flags: PHY device's dev_flags 1111 * @interface: PHY device's interface 1112 * 1113 * Description: Called by drivers to attach to a particular PHY 1114 * device. The phy_device is found, and properly hooked up 1115 * to the phy_driver. If no driver is attached, then a 1116 * generic driver is used. The phy_device is given a ptr to 1117 * the attaching device, and given a callback for link status 1118 * change. The phy_device is returned to the attaching driver. 1119 * This function takes a reference on the phy device. 1120 */ 1121 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 1122 u32 flags, phy_interface_t interface) 1123 { 1124 struct module *ndev_owner = dev->dev.parent->driver->owner; 1125 struct mii_bus *bus = phydev->mdio.bus; 1126 struct device *d = &phydev->mdio.dev; 1127 bool using_genphy = false; 1128 int err; 1129 1130 /* For Ethernet device drivers that register their own MDIO bus, we 1131 * will have bus->owner match ndev_mod, so we do not want to increment 1132 * our own module->refcnt here, otherwise we would not be able to 1133 * unload later on. 1134 */ 1135 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) { 1136 dev_err(&dev->dev, "failed to get the bus module\n"); 1137 return -EIO; 1138 } 1139 1140 get_device(d); 1141 1142 /* Assume that if there is no driver, that it doesn't 1143 * exist, and we should use the genphy driver. 1144 */ 1145 if (!d->driver) { 1146 if (phydev->is_c45) 1147 d->driver = &genphy_10g_driver.mdiodrv.driver; 1148 else 1149 d->driver = &genphy_driver.mdiodrv.driver; 1150 1151 using_genphy = true; 1152 } 1153 1154 if (!try_module_get(d->driver->owner)) { 1155 dev_err(&dev->dev, "failed to get the device driver module\n"); 1156 err = -EIO; 1157 goto error_put_device; 1158 } 1159 1160 if (using_genphy) { 1161 err = d->driver->probe(d); 1162 if (err >= 0) 1163 err = device_bind_driver(d); 1164 1165 if (err) 1166 goto error_module_put; 1167 } 1168 1169 if (phydev->attached_dev) { 1170 dev_err(&dev->dev, "PHY already attached\n"); 1171 err = -EBUSY; 1172 goto error; 1173 } 1174 1175 phydev->phy_link_change = phy_link_change; 1176 phydev->attached_dev = dev; 1177 dev->phydev = phydev; 1178 1179 /* Some Ethernet drivers try to connect to a PHY device before 1180 * calling register_netdevice() -> netdev_register_kobject() and 1181 * does the dev->dev.kobj initialization. Here we only check for 1182 * success which indicates that the network device kobject is 1183 * ready. Once we do that we still need to keep track of whether 1184 * links were successfully set up or not for phy_detach() to 1185 * remove them accordingly. 1186 */ 1187 phydev->sysfs_links = false; 1188 1189 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj, 1190 "attached_dev"); 1191 if (!err) { 1192 err = sysfs_create_link_nowarn(&dev->dev.kobj, 1193 &phydev->mdio.dev.kobj, 1194 "phydev"); 1195 if (err) { 1196 dev_err(&dev->dev, "could not add device link to %s err %d\n", 1197 kobject_name(&phydev->mdio.dev.kobj), 1198 err); 1199 /* non-fatal - some net drivers can use one netdevice 1200 * with more then one phy 1201 */ 1202 } 1203 1204 phydev->sysfs_links = true; 1205 } 1206 1207 phydev->dev_flags = flags; 1208 1209 phydev->interface = interface; 1210 1211 phydev->state = PHY_READY; 1212 1213 /* Initial carrier state is off as the phy is about to be 1214 * (re)initialized. 1215 */ 1216 netif_carrier_off(phydev->attached_dev); 1217 1218 /* Do initial configuration here, now that 1219 * we have certain key parameters 1220 * (dev_flags and interface) 1221 */ 1222 err = phy_init_hw(phydev); 1223 if (err) 1224 goto error; 1225 1226 phy_resume(phydev); 1227 phy_led_triggers_register(phydev); 1228 1229 return err; 1230 1231 error: 1232 /* phy_detach() does all of the cleanup below */ 1233 phy_detach(phydev); 1234 return err; 1235 1236 error_module_put: 1237 module_put(d->driver->owner); 1238 error_put_device: 1239 put_device(d); 1240 if (ndev_owner != bus->owner) 1241 module_put(bus->owner); 1242 return err; 1243 } 1244 EXPORT_SYMBOL(phy_attach_direct); 1245 1246 /** 1247 * phy_attach - attach a network device to a particular PHY device 1248 * @dev: network device to attach 1249 * @bus_id: Bus ID of PHY device to attach 1250 * @interface: PHY device's interface 1251 * 1252 * Description: Same as phy_attach_direct() except that a PHY bus_id 1253 * string is passed instead of a pointer to a struct phy_device. 1254 */ 1255 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, 1256 phy_interface_t interface) 1257 { 1258 struct bus_type *bus = &mdio_bus_type; 1259 struct phy_device *phydev; 1260 struct device *d; 1261 int rc; 1262 1263 /* Search the list of PHY devices on the mdio bus for the 1264 * PHY with the requested name 1265 */ 1266 d = bus_find_device_by_name(bus, NULL, bus_id); 1267 if (!d) { 1268 pr_err("PHY %s not found\n", bus_id); 1269 return ERR_PTR(-ENODEV); 1270 } 1271 phydev = to_phy_device(d); 1272 1273 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 1274 put_device(d); 1275 if (rc) 1276 return ERR_PTR(rc); 1277 1278 return phydev; 1279 } 1280 EXPORT_SYMBOL(phy_attach); 1281 1282 /** 1283 * phy_detach - detach a PHY device from its network device 1284 * @phydev: target phy_device struct 1285 * 1286 * This detaches the phy device from its network device and the phy 1287 * driver, and drops the reference count taken in phy_attach_direct(). 1288 */ 1289 void phy_detach(struct phy_device *phydev) 1290 { 1291 struct net_device *dev = phydev->attached_dev; 1292 struct module *ndev_owner = dev->dev.parent->driver->owner; 1293 struct mii_bus *bus; 1294 1295 if (phydev->sysfs_links) { 1296 sysfs_remove_link(&dev->dev.kobj, "phydev"); 1297 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev"); 1298 } 1299 phy_suspend(phydev); 1300 phydev->attached_dev->phydev = NULL; 1301 phydev->attached_dev = NULL; 1302 phydev->phylink = NULL; 1303 1304 phy_led_triggers_unregister(phydev); 1305 1306 module_put(phydev->mdio.dev.driver->owner); 1307 1308 /* If the device had no specific driver before (i.e. - it 1309 * was using the generic driver), we unbind the device 1310 * from the generic driver so that there's a chance a 1311 * real driver could be loaded 1312 */ 1313 if (phydev->mdio.dev.driver == &genphy_10g_driver.mdiodrv.driver || 1314 phydev->mdio.dev.driver == &genphy_driver.mdiodrv.driver) 1315 device_release_driver(&phydev->mdio.dev); 1316 1317 /* 1318 * The phydev might go away on the put_device() below, so avoid 1319 * a use-after-free bug by reading the underlying bus first. 1320 */ 1321 bus = phydev->mdio.bus; 1322 1323 put_device(&phydev->mdio.dev); 1324 if (ndev_owner != bus->owner) 1325 module_put(bus->owner); 1326 1327 /* Assert the reset signal */ 1328 phy_device_reset(phydev, 1); 1329 } 1330 EXPORT_SYMBOL(phy_detach); 1331 1332 int phy_suspend(struct phy_device *phydev) 1333 { 1334 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver); 1335 struct net_device *netdev = phydev->attached_dev; 1336 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL }; 1337 int ret = 0; 1338 1339 /* If the device has WOL enabled, we cannot suspend the PHY */ 1340 phy_ethtool_get_wol(phydev, &wol); 1341 if (wol.wolopts || (netdev && netdev->wol_enabled)) 1342 return -EBUSY; 1343 1344 if (phydev->drv && phydrv->suspend) 1345 ret = phydrv->suspend(phydev); 1346 1347 if (ret) 1348 return ret; 1349 1350 phydev->suspended = true; 1351 1352 return ret; 1353 } 1354 EXPORT_SYMBOL(phy_suspend); 1355 1356 int __phy_resume(struct phy_device *phydev) 1357 { 1358 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver); 1359 int ret = 0; 1360 1361 WARN_ON(!mutex_is_locked(&phydev->lock)); 1362 1363 if (phydev->drv && phydrv->resume) 1364 ret = phydrv->resume(phydev); 1365 1366 if (ret) 1367 return ret; 1368 1369 phydev->suspended = false; 1370 1371 return ret; 1372 } 1373 EXPORT_SYMBOL(__phy_resume); 1374 1375 int phy_resume(struct phy_device *phydev) 1376 { 1377 int ret; 1378 1379 mutex_lock(&phydev->lock); 1380 ret = __phy_resume(phydev); 1381 mutex_unlock(&phydev->lock); 1382 1383 return ret; 1384 } 1385 EXPORT_SYMBOL(phy_resume); 1386 1387 int phy_loopback(struct phy_device *phydev, bool enable) 1388 { 1389 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver); 1390 int ret = 0; 1391 1392 mutex_lock(&phydev->lock); 1393 1394 if (enable && phydev->loopback_enabled) { 1395 ret = -EBUSY; 1396 goto out; 1397 } 1398 1399 if (!enable && !phydev->loopback_enabled) { 1400 ret = -EINVAL; 1401 goto out; 1402 } 1403 1404 if (phydev->drv && phydrv->set_loopback) 1405 ret = phydrv->set_loopback(phydev, enable); 1406 else 1407 ret = -EOPNOTSUPP; 1408 1409 if (ret) 1410 goto out; 1411 1412 phydev->loopback_enabled = enable; 1413 1414 out: 1415 mutex_unlock(&phydev->lock); 1416 return ret; 1417 } 1418 EXPORT_SYMBOL(phy_loopback); 1419 1420 /** 1421 * phy_reset_after_clk_enable - perform a PHY reset if needed 1422 * @phydev: target phy_device struct 1423 * 1424 * Description: Some PHYs are known to need a reset after their refclk was 1425 * enabled. This function evaluates the flags and perform the reset if it's 1426 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy 1427 * was reset. 1428 */ 1429 int phy_reset_after_clk_enable(struct phy_device *phydev) 1430 { 1431 if (!phydev || !phydev->drv) 1432 return -ENODEV; 1433 1434 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) { 1435 phy_device_reset(phydev, 1); 1436 phy_device_reset(phydev, 0); 1437 return 1; 1438 } 1439 1440 return 0; 1441 } 1442 EXPORT_SYMBOL(phy_reset_after_clk_enable); 1443 1444 /* Generic PHY support and helper functions */ 1445 1446 /** 1447 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 1448 * @phydev: target phy_device struct 1449 * 1450 * Description: Writes MII_ADVERTISE with the appropriate values, 1451 * after sanitizing the values to make sure we only advertise 1452 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 1453 * hasn't changed, and > 0 if it has changed. 1454 */ 1455 static int genphy_config_advert(struct phy_device *phydev) 1456 { 1457 u32 advertise; 1458 int oldadv, adv, bmsr; 1459 int err, changed = 0; 1460 1461 /* Only allow advertising what this PHY supports */ 1462 linkmode_and(phydev->advertising, phydev->advertising, 1463 phydev->supported); 1464 if (!ethtool_convert_link_mode_to_legacy_u32(&advertise, 1465 phydev->advertising)) 1466 phydev_warn(phydev, "PHY advertising (%*pb) more modes than genphy supports, some modes not advertised.\n", 1467 __ETHTOOL_LINK_MODE_MASK_NBITS, 1468 phydev->advertising); 1469 1470 /* Setup standard advertisement */ 1471 adv = phy_read(phydev, MII_ADVERTISE); 1472 if (adv < 0) 1473 return adv; 1474 1475 oldadv = adv; 1476 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 1477 ADVERTISE_PAUSE_ASYM); 1478 adv |= ethtool_adv_to_mii_adv_t(advertise); 1479 1480 if (adv != oldadv) { 1481 err = phy_write(phydev, MII_ADVERTISE, adv); 1482 1483 if (err < 0) 1484 return err; 1485 changed = 1; 1486 } 1487 1488 bmsr = phy_read(phydev, MII_BMSR); 1489 if (bmsr < 0) 1490 return bmsr; 1491 1492 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all 1493 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a 1494 * logical 1. 1495 */ 1496 if (!(bmsr & BMSR_ESTATEN)) 1497 return changed; 1498 1499 /* Configure gigabit if it's supported */ 1500 adv = phy_read(phydev, MII_CTRL1000); 1501 if (adv < 0) 1502 return adv; 1503 1504 oldadv = adv; 1505 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 1506 1507 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1508 phydev->supported) || 1509 linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1510 phydev->supported)) 1511 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); 1512 1513 if (adv != oldadv) 1514 changed = 1; 1515 1516 err = phy_write(phydev, MII_CTRL1000, adv); 1517 if (err < 0) 1518 return err; 1519 1520 return changed; 1521 } 1522 1523 /** 1524 * genphy_config_eee_advert - disable unwanted eee mode advertisement 1525 * @phydev: target phy_device struct 1526 * 1527 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy 1528 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't 1529 * changed, and 1 if it has changed. 1530 */ 1531 static int genphy_config_eee_advert(struct phy_device *phydev) 1532 { 1533 int broken = phydev->eee_broken_modes; 1534 int old_adv, adv; 1535 1536 /* Nothing to disable */ 1537 if (!broken) 1538 return 0; 1539 1540 /* If the following call fails, we assume that EEE is not 1541 * supported by the phy. If we read 0, EEE is not advertised 1542 * In both case, we don't need to continue 1543 */ 1544 adv = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV); 1545 if (adv <= 0) 1546 return 0; 1547 1548 old_adv = adv; 1549 adv &= ~broken; 1550 1551 /* Advertising remains unchanged with the broken mask */ 1552 if (old_adv == adv) 1553 return 0; 1554 1555 phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, adv); 1556 1557 return 1; 1558 } 1559 1560 /** 1561 * genphy_setup_forced - configures/forces speed/duplex from @phydev 1562 * @phydev: target phy_device struct 1563 * 1564 * Description: Configures MII_BMCR to force speed/duplex 1565 * to the values in phydev. Assumes that the values are valid. 1566 * Please see phy_sanitize_settings(). 1567 */ 1568 int genphy_setup_forced(struct phy_device *phydev) 1569 { 1570 u16 ctl = 0; 1571 1572 phydev->pause = 0; 1573 phydev->asym_pause = 0; 1574 1575 if (SPEED_1000 == phydev->speed) 1576 ctl |= BMCR_SPEED1000; 1577 else if (SPEED_100 == phydev->speed) 1578 ctl |= BMCR_SPEED100; 1579 1580 if (DUPLEX_FULL == phydev->duplex) 1581 ctl |= BMCR_FULLDPLX; 1582 1583 return phy_modify(phydev, MII_BMCR, 1584 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl); 1585 } 1586 EXPORT_SYMBOL(genphy_setup_forced); 1587 1588 /** 1589 * genphy_restart_aneg - Enable and Restart Autonegotiation 1590 * @phydev: target phy_device struct 1591 */ 1592 int genphy_restart_aneg(struct phy_device *phydev) 1593 { 1594 /* Don't isolate the PHY if we're negotiating */ 1595 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, 1596 BMCR_ANENABLE | BMCR_ANRESTART); 1597 } 1598 EXPORT_SYMBOL(genphy_restart_aneg); 1599 1600 /** 1601 * genphy_config_aneg - restart auto-negotiation or write BMCR 1602 * @phydev: target phy_device struct 1603 * 1604 * Description: If auto-negotiation is enabled, we configure the 1605 * advertising, and then restart auto-negotiation. If it is not 1606 * enabled, then we write the BMCR. 1607 */ 1608 int genphy_config_aneg(struct phy_device *phydev) 1609 { 1610 int err, changed; 1611 1612 changed = genphy_config_eee_advert(phydev); 1613 1614 if (AUTONEG_ENABLE != phydev->autoneg) 1615 return genphy_setup_forced(phydev); 1616 1617 err = genphy_config_advert(phydev); 1618 if (err < 0) /* error */ 1619 return err; 1620 1621 changed |= err; 1622 1623 if (changed == 0) { 1624 /* Advertisement hasn't changed, but maybe aneg was never on to 1625 * begin with? Or maybe phy was isolated? 1626 */ 1627 int ctl = phy_read(phydev, MII_BMCR); 1628 1629 if (ctl < 0) 1630 return ctl; 1631 1632 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 1633 changed = 1; /* do restart aneg */ 1634 } 1635 1636 /* Only restart aneg if we are advertising something different 1637 * than we were before. 1638 */ 1639 if (changed > 0) 1640 return genphy_restart_aneg(phydev); 1641 1642 return 0; 1643 } 1644 EXPORT_SYMBOL(genphy_config_aneg); 1645 1646 /** 1647 * genphy_aneg_done - return auto-negotiation status 1648 * @phydev: target phy_device struct 1649 * 1650 * Description: Reads the status register and returns 0 either if 1651 * auto-negotiation is incomplete, or if there was an error. 1652 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 1653 */ 1654 int genphy_aneg_done(struct phy_device *phydev) 1655 { 1656 int retval = phy_read(phydev, MII_BMSR); 1657 1658 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 1659 } 1660 EXPORT_SYMBOL(genphy_aneg_done); 1661 1662 /** 1663 * genphy_update_link - update link status in @phydev 1664 * @phydev: target phy_device struct 1665 * 1666 * Description: Update the value in phydev->link to reflect the 1667 * current link value. In order to do this, we need to read 1668 * the status register twice, keeping the second value. 1669 */ 1670 int genphy_update_link(struct phy_device *phydev) 1671 { 1672 int status; 1673 1674 /* Do a fake read */ 1675 status = phy_read(phydev, MII_BMSR); 1676 if (status < 0) 1677 return status; 1678 1679 /* Read link and autonegotiation status */ 1680 status = phy_read(phydev, MII_BMSR); 1681 if (status < 0) 1682 return status; 1683 1684 if ((status & BMSR_LSTATUS) == 0) 1685 phydev->link = 0; 1686 else 1687 phydev->link = 1; 1688 1689 return 0; 1690 } 1691 EXPORT_SYMBOL(genphy_update_link); 1692 1693 /** 1694 * genphy_read_status - check the link status and update current link state 1695 * @phydev: target phy_device struct 1696 * 1697 * Description: Check the link, then figure out the current state 1698 * by comparing what we advertise with what the link partner 1699 * advertises. Start by checking the gigabit possibilities, 1700 * then move on to 10/100. 1701 */ 1702 int genphy_read_status(struct phy_device *phydev) 1703 { 1704 int adv; 1705 int err; 1706 int lpa; 1707 int lpagb = 0; 1708 int common_adv; 1709 int common_adv_gb = 0; 1710 1711 /* Update the link, but return if there was an error */ 1712 err = genphy_update_link(phydev); 1713 if (err) 1714 return err; 1715 1716 linkmode_zero(phydev->lp_advertising); 1717 1718 if (AUTONEG_ENABLE == phydev->autoneg) { 1719 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1720 phydev->supported) || 1721 linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1722 phydev->supported)) { 1723 lpagb = phy_read(phydev, MII_STAT1000); 1724 if (lpagb < 0) 1725 return lpagb; 1726 1727 adv = phy_read(phydev, MII_CTRL1000); 1728 if (adv < 0) 1729 return adv; 1730 1731 if (lpagb & LPA_1000MSFAIL) { 1732 if (adv & CTL1000_ENABLE_MASTER) 1733 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n"); 1734 else 1735 phydev_err(phydev, "Master/Slave resolution failed\n"); 1736 return -ENOLINK; 1737 } 1738 1739 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising, 1740 lpagb); 1741 common_adv_gb = lpagb & adv << 2; 1742 } 1743 1744 lpa = phy_read(phydev, MII_LPA); 1745 if (lpa < 0) 1746 return lpa; 1747 1748 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa); 1749 1750 adv = phy_read(phydev, MII_ADVERTISE); 1751 if (adv < 0) 1752 return adv; 1753 1754 common_adv = lpa & adv; 1755 1756 phydev->speed = SPEED_10; 1757 phydev->duplex = DUPLEX_HALF; 1758 phydev->pause = 0; 1759 phydev->asym_pause = 0; 1760 1761 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) { 1762 phydev->speed = SPEED_1000; 1763 1764 if (common_adv_gb & LPA_1000FULL) 1765 phydev->duplex = DUPLEX_FULL; 1766 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) { 1767 phydev->speed = SPEED_100; 1768 1769 if (common_adv & LPA_100FULL) 1770 phydev->duplex = DUPLEX_FULL; 1771 } else 1772 if (common_adv & LPA_10FULL) 1773 phydev->duplex = DUPLEX_FULL; 1774 1775 if (phydev->duplex == DUPLEX_FULL) { 1776 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0; 1777 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0; 1778 } 1779 } else { 1780 int bmcr = phy_read(phydev, MII_BMCR); 1781 1782 if (bmcr < 0) 1783 return bmcr; 1784 1785 if (bmcr & BMCR_FULLDPLX) 1786 phydev->duplex = DUPLEX_FULL; 1787 else 1788 phydev->duplex = DUPLEX_HALF; 1789 1790 if (bmcr & BMCR_SPEED1000) 1791 phydev->speed = SPEED_1000; 1792 else if (bmcr & BMCR_SPEED100) 1793 phydev->speed = SPEED_100; 1794 else 1795 phydev->speed = SPEED_10; 1796 1797 phydev->pause = 0; 1798 phydev->asym_pause = 0; 1799 } 1800 1801 return 0; 1802 } 1803 EXPORT_SYMBOL(genphy_read_status); 1804 1805 /** 1806 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit 1807 * @phydev: target phy_device struct 1808 * 1809 * Description: Perform a software PHY reset using the standard 1810 * BMCR_RESET bit and poll for the reset bit to be cleared. 1811 * 1812 * Returns: 0 on success, < 0 on failure 1813 */ 1814 int genphy_soft_reset(struct phy_device *phydev) 1815 { 1816 int ret; 1817 1818 ret = phy_write(phydev, MII_BMCR, BMCR_RESET); 1819 if (ret < 0) 1820 return ret; 1821 1822 return phy_poll_reset(phydev); 1823 } 1824 EXPORT_SYMBOL(genphy_soft_reset); 1825 1826 int genphy_config_init(struct phy_device *phydev) 1827 { 1828 int val; 1829 __ETHTOOL_DECLARE_LINK_MODE_MASK(features) = { 0, }; 1830 1831 linkmode_set_bit_array(phy_basic_ports_array, 1832 ARRAY_SIZE(phy_basic_ports_array), 1833 features); 1834 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, features); 1835 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, features); 1836 1837 /* Do we support autonegotiation? */ 1838 val = phy_read(phydev, MII_BMSR); 1839 if (val < 0) 1840 return val; 1841 1842 if (val & BMSR_ANEGCAPABLE) 1843 linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, features); 1844 1845 if (val & BMSR_100FULL) 1846 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, features); 1847 if (val & BMSR_100HALF) 1848 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, features); 1849 if (val & BMSR_10FULL) 1850 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, features); 1851 if (val & BMSR_10HALF) 1852 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, features); 1853 1854 if (val & BMSR_ESTATEN) { 1855 val = phy_read(phydev, MII_ESTATUS); 1856 if (val < 0) 1857 return val; 1858 1859 if (val & ESTATUS_1000_TFULL) 1860 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1861 features); 1862 if (val & ESTATUS_1000_THALF) 1863 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1864 features); 1865 } 1866 1867 linkmode_and(phydev->supported, phydev->supported, features); 1868 linkmode_and(phydev->advertising, phydev->advertising, features); 1869 1870 return 0; 1871 } 1872 EXPORT_SYMBOL(genphy_config_init); 1873 1874 /* This is used for the phy device which doesn't support the MMD extended 1875 * register access, but it does have side effect when we are trying to access 1876 * the MMD register via indirect method. 1877 */ 1878 int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum) 1879 { 1880 return -EOPNOTSUPP; 1881 } 1882 EXPORT_SYMBOL(genphy_read_mmd_unsupported); 1883 1884 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum, 1885 u16 regnum, u16 val) 1886 { 1887 return -EOPNOTSUPP; 1888 } 1889 EXPORT_SYMBOL(genphy_write_mmd_unsupported); 1890 1891 int genphy_suspend(struct phy_device *phydev) 1892 { 1893 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN); 1894 } 1895 EXPORT_SYMBOL(genphy_suspend); 1896 1897 int genphy_resume(struct phy_device *phydev) 1898 { 1899 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN); 1900 } 1901 EXPORT_SYMBOL(genphy_resume); 1902 1903 int genphy_loopback(struct phy_device *phydev, bool enable) 1904 { 1905 return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 1906 enable ? BMCR_LOOPBACK : 0); 1907 } 1908 EXPORT_SYMBOL(genphy_loopback); 1909 1910 static int __set_phy_supported(struct phy_device *phydev, u32 max_speed) 1911 { 1912 switch (max_speed) { 1913 case SPEED_10: 1914 linkmode_clear_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, 1915 phydev->supported); 1916 linkmode_clear_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1917 phydev->supported); 1918 /* fall through */ 1919 case SPEED_100: 1920 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1921 phydev->supported); 1922 linkmode_clear_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1923 phydev->supported); 1924 break; 1925 case SPEED_1000: 1926 break; 1927 default: 1928 return -ENOTSUPP; 1929 } 1930 1931 return 0; 1932 } 1933 1934 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed) 1935 { 1936 int err; 1937 1938 err = __set_phy_supported(phydev, max_speed); 1939 if (err) 1940 return err; 1941 1942 linkmode_copy(phydev->advertising, phydev->supported); 1943 1944 return 0; 1945 } 1946 EXPORT_SYMBOL(phy_set_max_speed); 1947 1948 /** 1949 * phy_remove_link_mode - Remove a supported link mode 1950 * @phydev: phy_device structure to remove link mode from 1951 * @link_mode: Link mode to be removed 1952 * 1953 * Description: Some MACs don't support all link modes which the PHY 1954 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper 1955 * to remove a link mode. 1956 */ 1957 void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode) 1958 { 1959 linkmode_clear_bit(link_mode, phydev->supported); 1960 linkmode_copy(phydev->advertising, phydev->supported); 1961 } 1962 EXPORT_SYMBOL(phy_remove_link_mode); 1963 1964 /** 1965 * phy_support_sym_pause - Enable support of symmetrical pause 1966 * @phydev: target phy_device struct 1967 * 1968 * Description: Called by the MAC to indicate is supports symmetrical 1969 * Pause, but not asym pause. 1970 */ 1971 void phy_support_sym_pause(struct phy_device *phydev) 1972 { 1973 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported); 1974 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported); 1975 linkmode_copy(phydev->advertising, phydev->supported); 1976 } 1977 EXPORT_SYMBOL(phy_support_sym_pause); 1978 1979 /** 1980 * phy_support_asym_pause - Enable support of asym pause 1981 * @phydev: target phy_device struct 1982 * 1983 * Description: Called by the MAC to indicate is supports Asym Pause. 1984 */ 1985 void phy_support_asym_pause(struct phy_device *phydev) 1986 { 1987 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported); 1988 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported); 1989 linkmode_copy(phydev->advertising, phydev->supported); 1990 } 1991 EXPORT_SYMBOL(phy_support_asym_pause); 1992 1993 /** 1994 * phy_set_sym_pause - Configure symmetric Pause 1995 * @phydev: target phy_device struct 1996 * @rx: Receiver Pause is supported 1997 * @tx: Transmit Pause is supported 1998 * @autoneg: Auto neg should be used 1999 * 2000 * Description: Configure advertised Pause support depending on if 2001 * receiver pause and pause auto neg is supported. Generally called 2002 * from the set_pauseparam .ndo. 2003 */ 2004 void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx, 2005 bool autoneg) 2006 { 2007 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported); 2008 2009 if (rx && tx && autoneg) 2010 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2011 phydev->supported); 2012 2013 linkmode_copy(phydev->advertising, phydev->supported); 2014 } 2015 EXPORT_SYMBOL(phy_set_sym_pause); 2016 2017 /** 2018 * phy_set_asym_pause - Configure Pause and Asym Pause 2019 * @phydev: target phy_device struct 2020 * @rx: Receiver Pause is supported 2021 * @tx: Transmit Pause is supported 2022 * 2023 * Description: Configure advertised Pause support depending on if 2024 * transmit and receiver pause is supported. If there has been a 2025 * change in adverting, trigger a new autoneg. Generally called from 2026 * the set_pauseparam .ndo. 2027 */ 2028 void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx) 2029 { 2030 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv); 2031 2032 linkmode_copy(oldadv, phydev->advertising); 2033 2034 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2035 phydev->advertising); 2036 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2037 phydev->advertising); 2038 2039 if (rx) { 2040 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2041 phydev->advertising); 2042 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2043 phydev->advertising); 2044 } 2045 2046 if (tx) 2047 linkmode_change_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2048 phydev->advertising); 2049 2050 if (!linkmode_equal(oldadv, phydev->advertising) && 2051 phydev->autoneg) 2052 phy_start_aneg(phydev); 2053 } 2054 EXPORT_SYMBOL(phy_set_asym_pause); 2055 2056 /** 2057 * phy_validate_pause - Test if the PHY/MAC support the pause configuration 2058 * @phydev: phy_device struct 2059 * @pp: requested pause configuration 2060 * 2061 * Description: Test if the PHY/MAC combination supports the Pause 2062 * configuration the user is requesting. Returns True if it is 2063 * supported, false otherwise. 2064 */ 2065 bool phy_validate_pause(struct phy_device *phydev, 2066 struct ethtool_pauseparam *pp) 2067 { 2068 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2069 phydev->supported) || 2070 (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2071 phydev->supported) && 2072 pp->rx_pause != pp->tx_pause)) 2073 return false; 2074 return true; 2075 } 2076 EXPORT_SYMBOL(phy_validate_pause); 2077 2078 static void of_set_phy_supported(struct phy_device *phydev) 2079 { 2080 struct device_node *node = phydev->mdio.dev.of_node; 2081 u32 max_speed; 2082 2083 if (!IS_ENABLED(CONFIG_OF_MDIO)) 2084 return; 2085 2086 if (!node) 2087 return; 2088 2089 if (!of_property_read_u32(node, "max-speed", &max_speed)) 2090 __set_phy_supported(phydev, max_speed); 2091 } 2092 2093 static void of_set_phy_eee_broken(struct phy_device *phydev) 2094 { 2095 struct device_node *node = phydev->mdio.dev.of_node; 2096 u32 broken = 0; 2097 2098 if (!IS_ENABLED(CONFIG_OF_MDIO)) 2099 return; 2100 2101 if (!node) 2102 return; 2103 2104 if (of_property_read_bool(node, "eee-broken-100tx")) 2105 broken |= MDIO_EEE_100TX; 2106 if (of_property_read_bool(node, "eee-broken-1000t")) 2107 broken |= MDIO_EEE_1000T; 2108 if (of_property_read_bool(node, "eee-broken-10gt")) 2109 broken |= MDIO_EEE_10GT; 2110 if (of_property_read_bool(node, "eee-broken-1000kx")) 2111 broken |= MDIO_EEE_1000KX; 2112 if (of_property_read_bool(node, "eee-broken-10gkx4")) 2113 broken |= MDIO_EEE_10GKX4; 2114 if (of_property_read_bool(node, "eee-broken-10gkr")) 2115 broken |= MDIO_EEE_10GKR; 2116 2117 phydev->eee_broken_modes = broken; 2118 } 2119 2120 static bool phy_drv_supports_irq(struct phy_driver *phydrv) 2121 { 2122 return phydrv->config_intr && phydrv->ack_interrupt; 2123 } 2124 2125 /** 2126 * phy_probe - probe and init a PHY device 2127 * @dev: device to probe and init 2128 * 2129 * Description: Take care of setting up the phy_device structure, 2130 * set the state to READY (the driver's init function should 2131 * set it to STARTING if needed). 2132 */ 2133 static int phy_probe(struct device *dev) 2134 { 2135 struct phy_device *phydev = to_phy_device(dev); 2136 struct device_driver *drv = phydev->mdio.dev.driver; 2137 struct phy_driver *phydrv = to_phy_driver(drv); 2138 int err = 0; 2139 2140 phydev->drv = phydrv; 2141 2142 /* Disable the interrupt if the PHY doesn't support it 2143 * but the interrupt is still a valid one 2144 */ 2145 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev)) 2146 phydev->irq = PHY_POLL; 2147 2148 if (phydrv->flags & PHY_IS_INTERNAL) 2149 phydev->is_internal = true; 2150 2151 mutex_lock(&phydev->lock); 2152 2153 /* Start out supporting everything. Eventually, 2154 * a controller will attach, and may modify one 2155 * or both of these values 2156 */ 2157 linkmode_copy(phydev->supported, phydrv->features); 2158 of_set_phy_supported(phydev); 2159 linkmode_copy(phydev->advertising, phydev->supported); 2160 2161 /* Get the EEE modes we want to prohibit. We will ask 2162 * the PHY stop advertising these mode later on 2163 */ 2164 of_set_phy_eee_broken(phydev); 2165 2166 /* The Pause Frame bits indicate that the PHY can support passing 2167 * pause frames. During autonegotiation, the PHYs will determine if 2168 * they should allow pause frames to pass. The MAC driver should then 2169 * use that result to determine whether to enable flow control via 2170 * pause frames. 2171 * 2172 * Normally, PHY drivers should not set the Pause bits, and instead 2173 * allow phylib to do that. However, there may be some situations 2174 * (e.g. hardware erratum) where the driver wants to set only one 2175 * of these bits. 2176 */ 2177 if (test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydrv->features) || 2178 test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydrv->features)) { 2179 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2180 phydev->supported); 2181 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2182 phydev->supported); 2183 if (test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydrv->features)) 2184 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2185 phydev->supported); 2186 if (test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2187 phydrv->features)) 2188 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2189 phydev->supported); 2190 } else { 2191 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 2192 phydev->supported); 2193 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 2194 phydev->supported); 2195 } 2196 2197 /* Set the state to READY by default */ 2198 phydev->state = PHY_READY; 2199 2200 if (phydev->drv->probe) { 2201 /* Deassert the reset signal */ 2202 phy_device_reset(phydev, 0); 2203 2204 err = phydev->drv->probe(phydev); 2205 if (err) { 2206 /* Assert the reset signal */ 2207 phy_device_reset(phydev, 1); 2208 } 2209 } 2210 2211 mutex_unlock(&phydev->lock); 2212 2213 return err; 2214 } 2215 2216 static int phy_remove(struct device *dev) 2217 { 2218 struct phy_device *phydev = to_phy_device(dev); 2219 2220 cancel_delayed_work_sync(&phydev->state_queue); 2221 2222 mutex_lock(&phydev->lock); 2223 phydev->state = PHY_DOWN; 2224 mutex_unlock(&phydev->lock); 2225 2226 if (phydev->drv && phydev->drv->remove) { 2227 phydev->drv->remove(phydev); 2228 2229 /* Assert the reset signal */ 2230 phy_device_reset(phydev, 1); 2231 } 2232 phydev->drv = NULL; 2233 2234 return 0; 2235 } 2236 2237 /** 2238 * phy_driver_register - register a phy_driver with the PHY layer 2239 * @new_driver: new phy_driver to register 2240 * @owner: module owning this PHY 2241 */ 2242 int phy_driver_register(struct phy_driver *new_driver, struct module *owner) 2243 { 2244 int retval; 2245 2246 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY; 2247 new_driver->mdiodrv.driver.name = new_driver->name; 2248 new_driver->mdiodrv.driver.bus = &mdio_bus_type; 2249 new_driver->mdiodrv.driver.probe = phy_probe; 2250 new_driver->mdiodrv.driver.remove = phy_remove; 2251 new_driver->mdiodrv.driver.owner = owner; 2252 2253 /* The following works around an issue where the PHY driver doesn't bind 2254 * to the device, resulting in the genphy driver being used instead of 2255 * the dedicated driver. The root cause of the issue isn't known yet 2256 * and seems to be in the base driver core. Once this is fixed we may 2257 * remove this workaround. 2258 */ 2259 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS; 2260 2261 retval = driver_register(&new_driver->mdiodrv.driver); 2262 if (retval) { 2263 pr_err("%s: Error %d in registering driver\n", 2264 new_driver->name, retval); 2265 2266 return retval; 2267 } 2268 2269 pr_debug("%s: Registered new driver\n", new_driver->name); 2270 2271 return 0; 2272 } 2273 EXPORT_SYMBOL(phy_driver_register); 2274 2275 int phy_drivers_register(struct phy_driver *new_driver, int n, 2276 struct module *owner) 2277 { 2278 int i, ret = 0; 2279 2280 for (i = 0; i < n; i++) { 2281 ret = phy_driver_register(new_driver + i, owner); 2282 if (ret) { 2283 while (i-- > 0) 2284 phy_driver_unregister(new_driver + i); 2285 break; 2286 } 2287 } 2288 return ret; 2289 } 2290 EXPORT_SYMBOL(phy_drivers_register); 2291 2292 void phy_driver_unregister(struct phy_driver *drv) 2293 { 2294 driver_unregister(&drv->mdiodrv.driver); 2295 } 2296 EXPORT_SYMBOL(phy_driver_unregister); 2297 2298 void phy_drivers_unregister(struct phy_driver *drv, int n) 2299 { 2300 int i; 2301 2302 for (i = 0; i < n; i++) 2303 phy_driver_unregister(drv + i); 2304 } 2305 EXPORT_SYMBOL(phy_drivers_unregister); 2306 2307 static struct phy_driver genphy_driver = { 2308 .phy_id = 0xffffffff, 2309 .phy_id_mask = 0xffffffff, 2310 .name = "Generic PHY", 2311 .soft_reset = genphy_no_soft_reset, 2312 .config_init = genphy_config_init, 2313 .features = PHY_GBIT_ALL_PORTS_FEATURES, 2314 .aneg_done = genphy_aneg_done, 2315 .suspend = genphy_suspend, 2316 .resume = genphy_resume, 2317 .set_loopback = genphy_loopback, 2318 }; 2319 2320 static int __init phy_init(void) 2321 { 2322 int rc; 2323 2324 rc = mdio_bus_init(); 2325 if (rc) 2326 return rc; 2327 2328 features_init(); 2329 2330 rc = phy_driver_register(&genphy_10g_driver, THIS_MODULE); 2331 if (rc) 2332 goto err_10g; 2333 2334 rc = phy_driver_register(&genphy_driver, THIS_MODULE); 2335 if (rc) { 2336 phy_driver_unregister(&genphy_10g_driver); 2337 err_10g: 2338 mdio_bus_exit(); 2339 } 2340 2341 return rc; 2342 } 2343 2344 static void __exit phy_exit(void) 2345 { 2346 phy_driver_unregister(&genphy_10g_driver); 2347 phy_driver_unregister(&genphy_driver); 2348 mdio_bus_exit(); 2349 } 2350 2351 subsys_initcall(phy_init); 2352 module_exit(phy_exit); 2353