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