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/mdio.h> 34 #include <linux/io.h> 35 #include <linux/uaccess.h> 36 #include <linux/of.h> 37 38 #include <asm/irq.h> 39 40 MODULE_DESCRIPTION("PHY library"); 41 MODULE_AUTHOR("Andy Fleming"); 42 MODULE_LICENSE("GPL"); 43 44 void phy_device_free(struct phy_device *phydev) 45 { 46 put_device(&phydev->dev); 47 } 48 EXPORT_SYMBOL(phy_device_free); 49 50 static void phy_device_release(struct device *dev) 51 { 52 kfree(to_phy_device(dev)); 53 } 54 55 enum genphy_driver { 56 GENPHY_DRV_1G, 57 GENPHY_DRV_10G, 58 GENPHY_DRV_MAX 59 }; 60 61 static struct phy_driver genphy_driver[GENPHY_DRV_MAX]; 62 63 static LIST_HEAD(phy_fixup_list); 64 static DEFINE_MUTEX(phy_fixup_lock); 65 66 /** 67 * phy_register_fixup - creates a new phy_fixup and adds it to the list 68 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID) 69 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY) 70 * It can also be PHY_ANY_UID 71 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before 72 * comparison 73 * @run: The actual code to be run when a matching PHY is found 74 */ 75 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, 76 int (*run)(struct phy_device *)) 77 { 78 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL); 79 80 if (!fixup) 81 return -ENOMEM; 82 83 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id)); 84 fixup->phy_uid = phy_uid; 85 fixup->phy_uid_mask = phy_uid_mask; 86 fixup->run = run; 87 88 mutex_lock(&phy_fixup_lock); 89 list_add_tail(&fixup->list, &phy_fixup_list); 90 mutex_unlock(&phy_fixup_lock); 91 92 return 0; 93 } 94 EXPORT_SYMBOL(phy_register_fixup); 95 96 /* Registers a fixup to be run on any PHY with the UID in phy_uid */ 97 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask, 98 int (*run)(struct phy_device *)) 99 { 100 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run); 101 } 102 EXPORT_SYMBOL(phy_register_fixup_for_uid); 103 104 /* Registers a fixup to be run on the PHY with id string bus_id */ 105 int phy_register_fixup_for_id(const char *bus_id, 106 int (*run)(struct phy_device *)) 107 { 108 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run); 109 } 110 EXPORT_SYMBOL(phy_register_fixup_for_id); 111 112 /* Returns 1 if fixup matches phydev in bus_id and phy_uid. 113 * Fixups can be set to match any in one or more fields. 114 */ 115 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup) 116 { 117 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0) 118 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0) 119 return 0; 120 121 if ((fixup->phy_uid & fixup->phy_uid_mask) != 122 (phydev->phy_id & fixup->phy_uid_mask)) 123 if (fixup->phy_uid != PHY_ANY_UID) 124 return 0; 125 126 return 1; 127 } 128 129 /* Runs any matching fixups for this phydev */ 130 static int phy_scan_fixups(struct phy_device *phydev) 131 { 132 struct phy_fixup *fixup; 133 134 mutex_lock(&phy_fixup_lock); 135 list_for_each_entry(fixup, &phy_fixup_list, list) { 136 if (phy_needs_fixup(phydev, fixup)) { 137 int err = fixup->run(phydev); 138 139 if (err < 0) { 140 mutex_unlock(&phy_fixup_lock); 141 return err; 142 } 143 phydev->has_fixups = true; 144 } 145 } 146 mutex_unlock(&phy_fixup_lock); 147 148 return 0; 149 } 150 151 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id, 152 bool is_c45, 153 struct phy_c45_device_ids *c45_ids) 154 { 155 struct phy_device *dev; 156 157 /* We allocate the device, and initialize the default values */ 158 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 159 if (NULL == dev) 160 return (struct phy_device *)PTR_ERR((void *)-ENOMEM); 161 162 dev->dev.release = phy_device_release; 163 164 dev->speed = 0; 165 dev->duplex = -1; 166 dev->pause = 0; 167 dev->asym_pause = 0; 168 dev->link = 1; 169 dev->interface = PHY_INTERFACE_MODE_GMII; 170 171 dev->autoneg = AUTONEG_ENABLE; 172 173 dev->is_c45 = is_c45; 174 dev->addr = addr; 175 dev->phy_id = phy_id; 176 if (c45_ids) 177 dev->c45_ids = *c45_ids; 178 dev->bus = bus; 179 dev->dev.parent = bus->parent; 180 dev->dev.bus = &mdio_bus_type; 181 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL; 182 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr); 183 184 dev->state = PHY_DOWN; 185 186 mutex_init(&dev->lock); 187 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); 188 INIT_WORK(&dev->phy_queue, phy_change); 189 190 /* Request the appropriate module unconditionally; don't 191 * bother trying to do so only if it isn't already loaded, 192 * because that gets complicated. A hotplug event would have 193 * done an unconditional modprobe anyway. 194 * We don't do normal hotplug because it won't work for MDIO 195 * -- because it relies on the device staying around for long 196 * enough for the driver to get loaded. With MDIO, the NIC 197 * driver will get bored and give up as soon as it finds that 198 * there's no driver _already_ loaded. 199 */ 200 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id)); 201 202 device_initialize(&dev->dev); 203 204 return dev; 205 } 206 EXPORT_SYMBOL(phy_device_create); 207 208 /** 209 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs. 210 * @bus: the target MII bus 211 * @addr: PHY address on the MII bus 212 * @phy_id: where to store the ID retrieved. 213 * @c45_ids: where to store the c45 ID information. 214 * 215 * If the PHY devices-in-package appears to be valid, it and the 216 * corresponding identifiers are stored in @c45_ids, zero is stored 217 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns 218 * zero on success. 219 * 220 */ 221 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id, 222 struct phy_c45_device_ids *c45_ids) { 223 int phy_reg; 224 int i, reg_addr; 225 const int num_ids = ARRAY_SIZE(c45_ids->device_ids); 226 227 /* Find first non-zero Devices In package. Device 228 * zero is reserved, so don't probe it. 229 */ 230 for (i = 1; 231 i < num_ids && c45_ids->devices_in_package == 0; 232 i++) { 233 reg_addr = MII_ADDR_C45 | i << 16 | MDIO_DEVS2; 234 phy_reg = mdiobus_read(bus, addr, reg_addr); 235 if (phy_reg < 0) 236 return -EIO; 237 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16; 238 239 reg_addr = MII_ADDR_C45 | i << 16 | MDIO_DEVS1; 240 phy_reg = mdiobus_read(bus, addr, reg_addr); 241 if (phy_reg < 0) 242 return -EIO; 243 c45_ids->devices_in_package |= (phy_reg & 0xffff); 244 245 /* If mostly Fs, there is no device there, 246 * let's get out of here. 247 */ 248 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) { 249 *phy_id = 0xffffffff; 250 return 0; 251 } 252 } 253 254 /* Now probe Device Identifiers for each device present. */ 255 for (i = 1; i < num_ids; i++) { 256 if (!(c45_ids->devices_in_package & (1 << i))) 257 continue; 258 259 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1; 260 phy_reg = mdiobus_read(bus, addr, reg_addr); 261 if (phy_reg < 0) 262 return -EIO; 263 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16; 264 265 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2; 266 phy_reg = mdiobus_read(bus, addr, reg_addr); 267 if (phy_reg < 0) 268 return -EIO; 269 c45_ids->device_ids[i] |= (phy_reg & 0xffff); 270 } 271 *phy_id = 0; 272 return 0; 273 } 274 275 /** 276 * get_phy_id - reads the specified addr for its ID. 277 * @bus: the target MII bus 278 * @addr: PHY address on the MII bus 279 * @phy_id: where to store the ID retrieved. 280 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 281 * @c45_ids: where to store the c45 ID information. 282 * 283 * Description: In the case of a 802.3-c22 PHY, reads the ID registers 284 * of the PHY at @addr on the @bus, stores it in @phy_id and returns 285 * zero on success. 286 * 287 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and 288 * its return value is in turn returned. 289 * 290 */ 291 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id, 292 bool is_c45, struct phy_c45_device_ids *c45_ids) 293 { 294 int phy_reg; 295 296 if (is_c45) 297 return get_phy_c45_ids(bus, addr, phy_id, c45_ids); 298 299 /* Grab the bits from PHYIR1, and put them in the upper half */ 300 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1); 301 if (phy_reg < 0) 302 return -EIO; 303 304 *phy_id = (phy_reg & 0xffff) << 16; 305 306 /* Grab the bits from PHYIR2, and put them in the lower half */ 307 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2); 308 if (phy_reg < 0) 309 return -EIO; 310 311 *phy_id |= (phy_reg & 0xffff); 312 313 return 0; 314 } 315 316 /** 317 * get_phy_device - reads the specified PHY device and returns its @phy_device 318 * struct 319 * @bus: the target MII bus 320 * @addr: PHY address on the MII bus 321 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol 322 * 323 * Description: Reads the ID registers of the PHY at @addr on the 324 * @bus, then allocates and returns the phy_device to represent it. 325 */ 326 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45) 327 { 328 struct phy_c45_device_ids c45_ids = {0}; 329 u32 phy_id = 0; 330 int r; 331 332 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids); 333 if (r) 334 return ERR_PTR(r); 335 336 /* If the phy_id is mostly Fs, there is no device there */ 337 if ((phy_id & 0x1fffffff) == 0x1fffffff) 338 return NULL; 339 340 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids); 341 } 342 EXPORT_SYMBOL(get_phy_device); 343 344 /** 345 * phy_device_register - Register the phy device on the MDIO bus 346 * @phydev: phy_device structure to be added to the MDIO bus 347 */ 348 int phy_device_register(struct phy_device *phydev) 349 { 350 int err; 351 352 /* Don't register a phy if one is already registered at this address */ 353 if (phydev->bus->phy_map[phydev->addr]) 354 return -EINVAL; 355 phydev->bus->phy_map[phydev->addr] = phydev; 356 357 /* Run all of the fixups for this PHY */ 358 err = phy_scan_fixups(phydev); 359 if (err) { 360 pr_err("PHY %d failed to initialize\n", phydev->addr); 361 goto out; 362 } 363 364 err = device_add(&phydev->dev); 365 if (err) { 366 pr_err("PHY %d failed to add\n", phydev->addr); 367 goto out; 368 } 369 370 return 0; 371 372 out: 373 phydev->bus->phy_map[phydev->addr] = NULL; 374 return err; 375 } 376 EXPORT_SYMBOL(phy_device_register); 377 378 /** 379 * phy_find_first - finds the first PHY device on the bus 380 * @bus: the target MII bus 381 */ 382 struct phy_device *phy_find_first(struct mii_bus *bus) 383 { 384 int addr; 385 386 for (addr = 0; addr < PHY_MAX_ADDR; addr++) { 387 if (bus->phy_map[addr]) 388 return bus->phy_map[addr]; 389 } 390 return NULL; 391 } 392 EXPORT_SYMBOL(phy_find_first); 393 394 /** 395 * phy_prepare_link - prepares the PHY layer to monitor link status 396 * @phydev: target phy_device struct 397 * @handler: callback function for link status change notifications 398 * 399 * Description: Tells the PHY infrastructure to handle the 400 * gory details on monitoring link status (whether through 401 * polling or an interrupt), and to call back to the 402 * connected device driver when the link status changes. 403 * If you want to monitor your own link state, don't call 404 * this function. 405 */ 406 static void phy_prepare_link(struct phy_device *phydev, 407 void (*handler)(struct net_device *)) 408 { 409 phydev->adjust_link = handler; 410 } 411 412 /** 413 * phy_connect_direct - connect an ethernet device to a specific phy_device 414 * @dev: the network device to connect 415 * @phydev: the pointer to the phy device 416 * @handler: callback function for state change notifications 417 * @interface: PHY device's interface 418 */ 419 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 420 void (*handler)(struct net_device *), 421 phy_interface_t interface) 422 { 423 int rc; 424 425 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 426 if (rc) 427 return rc; 428 429 phy_prepare_link(phydev, handler); 430 phy_start_machine(phydev); 431 if (phydev->irq > 0) 432 phy_start_interrupts(phydev); 433 434 return 0; 435 } 436 EXPORT_SYMBOL(phy_connect_direct); 437 438 /** 439 * phy_connect - connect an ethernet device to a PHY device 440 * @dev: the network device to connect 441 * @bus_id: the id string of the PHY device to connect 442 * @handler: callback function for state change notifications 443 * @interface: PHY device's interface 444 * 445 * Description: Convenience function for connecting ethernet 446 * devices to PHY devices. The default behavior is for 447 * the PHY infrastructure to handle everything, and only notify 448 * the connected driver when the link status changes. If you 449 * don't want, or can't use the provided functionality, you may 450 * choose to call only the subset of functions which provide 451 * the desired functionality. 452 */ 453 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, 454 void (*handler)(struct net_device *), 455 phy_interface_t interface) 456 { 457 struct phy_device *phydev; 458 struct device *d; 459 int rc; 460 461 /* Search the list of PHY devices on the mdio bus for the 462 * PHY with the requested name 463 */ 464 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id); 465 if (!d) { 466 pr_err("PHY %s not found\n", bus_id); 467 return ERR_PTR(-ENODEV); 468 } 469 phydev = to_phy_device(d); 470 471 rc = phy_connect_direct(dev, phydev, handler, interface); 472 if (rc) 473 return ERR_PTR(rc); 474 475 return phydev; 476 } 477 EXPORT_SYMBOL(phy_connect); 478 479 /** 480 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY 481 * device 482 * @phydev: target phy_device struct 483 */ 484 void phy_disconnect(struct phy_device *phydev) 485 { 486 if (phydev->irq > 0) 487 phy_stop_interrupts(phydev); 488 489 phy_stop_machine(phydev); 490 491 phydev->adjust_link = NULL; 492 493 phy_detach(phydev); 494 } 495 EXPORT_SYMBOL(phy_disconnect); 496 497 /** 498 * phy_poll_reset - Safely wait until a PHY reset has properly completed 499 * @phydev: The PHY device to poll 500 * 501 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as 502 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR 503 * register must be polled until the BMCR_RESET bit clears. 504 * 505 * Furthermore, any attempts to write to PHY registers may have no effect 506 * or even generate MDIO bus errors until this is complete. 507 * 508 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the 509 * standard and do not fully reset after the BMCR_RESET bit is set, and may 510 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an 511 * effort to support such broken PHYs, this function is separate from the 512 * standard phy_init_hw() which will zero all the other bits in the BMCR 513 * and reapply all driver-specific and board-specific fixups. 514 */ 515 static int phy_poll_reset(struct phy_device *phydev) 516 { 517 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */ 518 unsigned int retries = 12; 519 int ret; 520 521 do { 522 msleep(50); 523 ret = phy_read(phydev, MII_BMCR); 524 if (ret < 0) 525 return ret; 526 } while (ret & BMCR_RESET && --retries); 527 if (ret & BMCR_RESET) 528 return -ETIMEDOUT; 529 530 /* Some chips (smsc911x) may still need up to another 1ms after the 531 * BMCR_RESET bit is cleared before they are usable. 532 */ 533 msleep(1); 534 return 0; 535 } 536 537 int phy_init_hw(struct phy_device *phydev) 538 { 539 int ret = 0; 540 541 if (!phydev->drv || !phydev->drv->config_init) 542 return 0; 543 544 if (phydev->drv->soft_reset) 545 ret = phydev->drv->soft_reset(phydev); 546 else 547 ret = genphy_soft_reset(phydev); 548 549 if (ret < 0) 550 return ret; 551 552 ret = phy_scan_fixups(phydev); 553 if (ret < 0) 554 return ret; 555 556 return phydev->drv->config_init(phydev); 557 } 558 EXPORT_SYMBOL(phy_init_hw); 559 560 /** 561 * phy_attach_direct - attach a network device to a given PHY device pointer 562 * @dev: network device to attach 563 * @phydev: Pointer to phy_device to attach 564 * @flags: PHY device's dev_flags 565 * @interface: PHY device's interface 566 * 567 * Description: Called by drivers to attach to a particular PHY 568 * device. The phy_device is found, and properly hooked up 569 * to the phy_driver. If no driver is attached, then a 570 * generic driver is used. The phy_device is given a ptr to 571 * the attaching device, and given a callback for link status 572 * change. The phy_device is returned to the attaching driver. 573 */ 574 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 575 u32 flags, phy_interface_t interface) 576 { 577 struct device *d = &phydev->dev; 578 struct module *bus_module; 579 int err; 580 581 /* Assume that if there is no driver, that it doesn't 582 * exist, and we should use the genphy driver. 583 */ 584 if (NULL == d->driver) { 585 if (phydev->is_c45) 586 d->driver = &genphy_driver[GENPHY_DRV_10G].driver; 587 else 588 d->driver = &genphy_driver[GENPHY_DRV_1G].driver; 589 590 err = d->driver->probe(d); 591 if (err >= 0) 592 err = device_bind_driver(d); 593 594 if (err) 595 return err; 596 } 597 598 if (phydev->attached_dev) { 599 dev_err(&dev->dev, "PHY already attached\n"); 600 return -EBUSY; 601 } 602 603 /* Increment the bus module reference count */ 604 bus_module = phydev->bus->dev.driver ? 605 phydev->bus->dev.driver->owner : NULL; 606 if (!try_module_get(bus_module)) { 607 dev_err(&dev->dev, "failed to get the bus module\n"); 608 return -EIO; 609 } 610 611 phydev->attached_dev = dev; 612 dev->phydev = phydev; 613 614 phydev->dev_flags = flags; 615 616 phydev->interface = interface; 617 618 phydev->state = PHY_READY; 619 620 /* Do initial configuration here, now that 621 * we have certain key parameters 622 * (dev_flags and interface) 623 */ 624 err = phy_init_hw(phydev); 625 if (err) 626 phy_detach(phydev); 627 else 628 phy_resume(phydev); 629 630 return err; 631 } 632 EXPORT_SYMBOL(phy_attach_direct); 633 634 /** 635 * phy_attach - attach a network device to a particular PHY device 636 * @dev: network device to attach 637 * @bus_id: Bus ID of PHY device to attach 638 * @interface: PHY device's interface 639 * 640 * Description: Same as phy_attach_direct() except that a PHY bus_id 641 * string is passed instead of a pointer to a struct phy_device. 642 */ 643 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, 644 phy_interface_t interface) 645 { 646 struct bus_type *bus = &mdio_bus_type; 647 struct phy_device *phydev; 648 struct device *d; 649 int rc; 650 651 /* Search the list of PHY devices on the mdio bus for the 652 * PHY with the requested name 653 */ 654 d = bus_find_device_by_name(bus, NULL, bus_id); 655 if (!d) { 656 pr_err("PHY %s not found\n", bus_id); 657 return ERR_PTR(-ENODEV); 658 } 659 phydev = to_phy_device(d); 660 661 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface); 662 if (rc) 663 return ERR_PTR(rc); 664 665 return phydev; 666 } 667 EXPORT_SYMBOL(phy_attach); 668 669 /** 670 * phy_detach - detach a PHY device from its network device 671 * @phydev: target phy_device struct 672 */ 673 void phy_detach(struct phy_device *phydev) 674 { 675 int i; 676 677 if (phydev->bus->dev.driver) 678 module_put(phydev->bus->dev.driver->owner); 679 680 phydev->attached_dev->phydev = NULL; 681 phydev->attached_dev = NULL; 682 phy_suspend(phydev); 683 684 /* If the device had no specific driver before (i.e. - it 685 * was using the generic driver), we unbind the device 686 * from the generic driver so that there's a chance a 687 * real driver could be loaded 688 */ 689 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) { 690 if (phydev->dev.driver == &genphy_driver[i].driver) { 691 device_release_driver(&phydev->dev); 692 break; 693 } 694 } 695 } 696 EXPORT_SYMBOL(phy_detach); 697 698 int phy_suspend(struct phy_device *phydev) 699 { 700 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver); 701 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL }; 702 703 /* If the device has WOL enabled, we cannot suspend the PHY */ 704 phy_ethtool_get_wol(phydev, &wol); 705 if (wol.wolopts) 706 return -EBUSY; 707 708 if (phydrv->suspend) 709 return phydrv->suspend(phydev); 710 return 0; 711 } 712 EXPORT_SYMBOL(phy_suspend); 713 714 int phy_resume(struct phy_device *phydev) 715 { 716 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver); 717 718 if (phydrv->resume) 719 return phydrv->resume(phydev); 720 return 0; 721 } 722 EXPORT_SYMBOL(phy_resume); 723 724 /* Generic PHY support and helper functions */ 725 726 /** 727 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 728 * @phydev: target phy_device struct 729 * 730 * Description: Writes MII_ADVERTISE with the appropriate values, 731 * after sanitizing the values to make sure we only advertise 732 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 733 * hasn't changed, and > 0 if it has changed. 734 */ 735 static int genphy_config_advert(struct phy_device *phydev) 736 { 737 u32 advertise; 738 int oldadv, adv, bmsr; 739 int err, changed = 0; 740 741 /* Only allow advertising what this PHY supports */ 742 phydev->advertising &= phydev->supported; 743 advertise = phydev->advertising; 744 745 /* Setup standard advertisement */ 746 adv = phy_read(phydev, MII_ADVERTISE); 747 if (adv < 0) 748 return adv; 749 750 oldadv = adv; 751 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 752 ADVERTISE_PAUSE_ASYM); 753 adv |= ethtool_adv_to_mii_adv_t(advertise); 754 755 if (adv != oldadv) { 756 err = phy_write(phydev, MII_ADVERTISE, adv); 757 758 if (err < 0) 759 return err; 760 changed = 1; 761 } 762 763 bmsr = phy_read(phydev, MII_BMSR); 764 if (bmsr < 0) 765 return bmsr; 766 767 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all 768 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a 769 * logical 1. 770 */ 771 if (!(bmsr & BMSR_ESTATEN)) 772 return changed; 773 774 /* Configure gigabit if it's supported */ 775 adv = phy_read(phydev, MII_CTRL1000); 776 if (adv < 0) 777 return adv; 778 779 oldadv = adv; 780 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 781 782 if (phydev->supported & (SUPPORTED_1000baseT_Half | 783 SUPPORTED_1000baseT_Full)) { 784 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); 785 if (adv != oldadv) 786 changed = 1; 787 } 788 789 err = phy_write(phydev, MII_CTRL1000, adv); 790 if (err < 0) 791 return err; 792 793 return changed; 794 } 795 796 /** 797 * genphy_setup_forced - configures/forces speed/duplex from @phydev 798 * @phydev: target phy_device struct 799 * 800 * Description: Configures MII_BMCR to force speed/duplex 801 * to the values in phydev. Assumes that the values are valid. 802 * Please see phy_sanitize_settings(). 803 */ 804 int genphy_setup_forced(struct phy_device *phydev) 805 { 806 int ctl = 0; 807 808 phydev->pause = 0; 809 phydev->asym_pause = 0; 810 811 if (SPEED_1000 == phydev->speed) 812 ctl |= BMCR_SPEED1000; 813 else if (SPEED_100 == phydev->speed) 814 ctl |= BMCR_SPEED100; 815 816 if (DUPLEX_FULL == phydev->duplex) 817 ctl |= BMCR_FULLDPLX; 818 819 return phy_write(phydev, MII_BMCR, ctl); 820 } 821 EXPORT_SYMBOL(genphy_setup_forced); 822 823 /** 824 * genphy_restart_aneg - Enable and Restart Autonegotiation 825 * @phydev: target phy_device struct 826 */ 827 int genphy_restart_aneg(struct phy_device *phydev) 828 { 829 int ctl = phy_read(phydev, MII_BMCR); 830 831 if (ctl < 0) 832 return ctl; 833 834 ctl |= BMCR_ANENABLE | BMCR_ANRESTART; 835 836 /* Don't isolate the PHY if we're negotiating */ 837 ctl &= ~BMCR_ISOLATE; 838 839 return phy_write(phydev, MII_BMCR, ctl); 840 } 841 EXPORT_SYMBOL(genphy_restart_aneg); 842 843 /** 844 * genphy_config_aneg - restart auto-negotiation or write BMCR 845 * @phydev: target phy_device struct 846 * 847 * Description: If auto-negotiation is enabled, we configure the 848 * advertising, and then restart auto-negotiation. If it is not 849 * enabled, then we write the BMCR. 850 */ 851 int genphy_config_aneg(struct phy_device *phydev) 852 { 853 int result; 854 855 if (AUTONEG_ENABLE != phydev->autoneg) 856 return genphy_setup_forced(phydev); 857 858 result = genphy_config_advert(phydev); 859 if (result < 0) /* error */ 860 return result; 861 if (result == 0) { 862 /* Advertisement hasn't changed, but maybe aneg was never on to 863 * begin with? Or maybe phy was isolated? 864 */ 865 int ctl = phy_read(phydev, MII_BMCR); 866 867 if (ctl < 0) 868 return ctl; 869 870 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 871 result = 1; /* do restart aneg */ 872 } 873 874 /* Only restart aneg if we are advertising something different 875 * than we were before. 876 */ 877 if (result > 0) 878 result = genphy_restart_aneg(phydev); 879 880 return result; 881 } 882 EXPORT_SYMBOL(genphy_config_aneg); 883 884 /** 885 * genphy_aneg_done - return auto-negotiation status 886 * @phydev: target phy_device struct 887 * 888 * Description: Reads the status register and returns 0 either if 889 * auto-negotiation is incomplete, or if there was an error. 890 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 891 */ 892 int genphy_aneg_done(struct phy_device *phydev) 893 { 894 int retval = phy_read(phydev, MII_BMSR); 895 896 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 897 } 898 EXPORT_SYMBOL(genphy_aneg_done); 899 900 static int gen10g_config_aneg(struct phy_device *phydev) 901 { 902 return 0; 903 } 904 905 /** 906 * genphy_update_link - update link status in @phydev 907 * @phydev: target phy_device struct 908 * 909 * Description: Update the value in phydev->link to reflect the 910 * current link value. In order to do this, we need to read 911 * the status register twice, keeping the second value. 912 */ 913 int genphy_update_link(struct phy_device *phydev) 914 { 915 int status; 916 917 /* Do a fake read */ 918 status = phy_read(phydev, MII_BMSR); 919 if (status < 0) 920 return status; 921 922 /* Read link and autonegotiation status */ 923 status = phy_read(phydev, MII_BMSR); 924 if (status < 0) 925 return status; 926 927 if ((status & BMSR_LSTATUS) == 0) 928 phydev->link = 0; 929 else 930 phydev->link = 1; 931 932 return 0; 933 } 934 EXPORT_SYMBOL(genphy_update_link); 935 936 /** 937 * genphy_read_status - check the link status and update current link state 938 * @phydev: target phy_device struct 939 * 940 * Description: Check the link, then figure out the current state 941 * by comparing what we advertise with what the link partner 942 * advertises. Start by checking the gigabit possibilities, 943 * then move on to 10/100. 944 */ 945 int genphy_read_status(struct phy_device *phydev) 946 { 947 int adv; 948 int err; 949 int lpa; 950 int lpagb = 0; 951 int common_adv; 952 int common_adv_gb = 0; 953 954 /* Update the link, but return if there was an error */ 955 err = genphy_update_link(phydev); 956 if (err) 957 return err; 958 959 phydev->lp_advertising = 0; 960 961 if (AUTONEG_ENABLE == phydev->autoneg) { 962 if (phydev->supported & (SUPPORTED_1000baseT_Half 963 | SUPPORTED_1000baseT_Full)) { 964 lpagb = phy_read(phydev, MII_STAT1000); 965 if (lpagb < 0) 966 return lpagb; 967 968 adv = phy_read(phydev, MII_CTRL1000); 969 if (adv < 0) 970 return adv; 971 972 phydev->lp_advertising = 973 mii_stat1000_to_ethtool_lpa_t(lpagb); 974 common_adv_gb = lpagb & adv << 2; 975 } 976 977 lpa = phy_read(phydev, MII_LPA); 978 if (lpa < 0) 979 return lpa; 980 981 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa); 982 983 adv = phy_read(phydev, MII_ADVERTISE); 984 if (adv < 0) 985 return adv; 986 987 common_adv = lpa & adv; 988 989 phydev->speed = SPEED_10; 990 phydev->duplex = DUPLEX_HALF; 991 phydev->pause = 0; 992 phydev->asym_pause = 0; 993 994 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) { 995 phydev->speed = SPEED_1000; 996 997 if (common_adv_gb & LPA_1000FULL) 998 phydev->duplex = DUPLEX_FULL; 999 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) { 1000 phydev->speed = SPEED_100; 1001 1002 if (common_adv & LPA_100FULL) 1003 phydev->duplex = DUPLEX_FULL; 1004 } else 1005 if (common_adv & LPA_10FULL) 1006 phydev->duplex = DUPLEX_FULL; 1007 1008 if (phydev->duplex == DUPLEX_FULL) { 1009 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0; 1010 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0; 1011 } 1012 } else { 1013 int bmcr = phy_read(phydev, MII_BMCR); 1014 1015 if (bmcr < 0) 1016 return bmcr; 1017 1018 if (bmcr & BMCR_FULLDPLX) 1019 phydev->duplex = DUPLEX_FULL; 1020 else 1021 phydev->duplex = DUPLEX_HALF; 1022 1023 if (bmcr & BMCR_SPEED1000) 1024 phydev->speed = SPEED_1000; 1025 else if (bmcr & BMCR_SPEED100) 1026 phydev->speed = SPEED_100; 1027 else 1028 phydev->speed = SPEED_10; 1029 1030 phydev->pause = 0; 1031 phydev->asym_pause = 0; 1032 } 1033 1034 return 0; 1035 } 1036 EXPORT_SYMBOL(genphy_read_status); 1037 1038 static int gen10g_read_status(struct phy_device *phydev) 1039 { 1040 int devad, reg; 1041 u32 mmd_mask = phydev->c45_ids.devices_in_package; 1042 1043 phydev->link = 1; 1044 1045 /* For now just lie and say it's 10G all the time */ 1046 phydev->speed = SPEED_10000; 1047 phydev->duplex = DUPLEX_FULL; 1048 1049 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) { 1050 if (!(mmd_mask & 1)) 1051 continue; 1052 1053 /* Read twice because link state is latched and a 1054 * read moves the current state into the register 1055 */ 1056 phy_read_mmd(phydev, devad, MDIO_STAT1); 1057 reg = phy_read_mmd(phydev, devad, MDIO_STAT1); 1058 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS)) 1059 phydev->link = 0; 1060 } 1061 1062 return 0; 1063 } 1064 1065 /** 1066 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit 1067 * @phydev: target phy_device struct 1068 * 1069 * Description: Perform a software PHY reset using the standard 1070 * BMCR_RESET bit and poll for the reset bit to be cleared. 1071 * 1072 * Returns: 0 on success, < 0 on failure 1073 */ 1074 int genphy_soft_reset(struct phy_device *phydev) 1075 { 1076 int ret; 1077 1078 ret = phy_write(phydev, MII_BMCR, BMCR_RESET); 1079 if (ret < 0) 1080 return ret; 1081 1082 return phy_poll_reset(phydev); 1083 } 1084 EXPORT_SYMBOL(genphy_soft_reset); 1085 1086 int genphy_config_init(struct phy_device *phydev) 1087 { 1088 int val; 1089 u32 features; 1090 1091 features = (SUPPORTED_TP | SUPPORTED_MII 1092 | SUPPORTED_AUI | SUPPORTED_FIBRE | 1093 SUPPORTED_BNC); 1094 1095 /* Do we support autonegotiation? */ 1096 val = phy_read(phydev, MII_BMSR); 1097 if (val < 0) 1098 return val; 1099 1100 if (val & BMSR_ANEGCAPABLE) 1101 features |= SUPPORTED_Autoneg; 1102 1103 if (val & BMSR_100FULL) 1104 features |= SUPPORTED_100baseT_Full; 1105 if (val & BMSR_100HALF) 1106 features |= SUPPORTED_100baseT_Half; 1107 if (val & BMSR_10FULL) 1108 features |= SUPPORTED_10baseT_Full; 1109 if (val & BMSR_10HALF) 1110 features |= SUPPORTED_10baseT_Half; 1111 1112 if (val & BMSR_ESTATEN) { 1113 val = phy_read(phydev, MII_ESTATUS); 1114 if (val < 0) 1115 return val; 1116 1117 if (val & ESTATUS_1000_TFULL) 1118 features |= SUPPORTED_1000baseT_Full; 1119 if (val & ESTATUS_1000_THALF) 1120 features |= SUPPORTED_1000baseT_Half; 1121 } 1122 1123 phydev->supported &= features; 1124 phydev->advertising &= features; 1125 1126 return 0; 1127 } 1128 1129 static int gen10g_soft_reset(struct phy_device *phydev) 1130 { 1131 /* Do nothing for now */ 1132 return 0; 1133 } 1134 EXPORT_SYMBOL(genphy_config_init); 1135 1136 static int gen10g_config_init(struct phy_device *phydev) 1137 { 1138 /* Temporarily just say we support everything */ 1139 phydev->supported = SUPPORTED_10000baseT_Full; 1140 phydev->advertising = SUPPORTED_10000baseT_Full; 1141 1142 return 0; 1143 } 1144 1145 int genphy_suspend(struct phy_device *phydev) 1146 { 1147 int value; 1148 1149 mutex_lock(&phydev->lock); 1150 1151 value = phy_read(phydev, MII_BMCR); 1152 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN); 1153 1154 mutex_unlock(&phydev->lock); 1155 1156 return 0; 1157 } 1158 EXPORT_SYMBOL(genphy_suspend); 1159 1160 static int gen10g_suspend(struct phy_device *phydev) 1161 { 1162 return 0; 1163 } 1164 1165 int genphy_resume(struct phy_device *phydev) 1166 { 1167 int value; 1168 1169 mutex_lock(&phydev->lock); 1170 1171 value = phy_read(phydev, MII_BMCR); 1172 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN); 1173 1174 mutex_unlock(&phydev->lock); 1175 1176 return 0; 1177 } 1178 EXPORT_SYMBOL(genphy_resume); 1179 1180 static int gen10g_resume(struct phy_device *phydev) 1181 { 1182 return 0; 1183 } 1184 1185 static void of_set_phy_supported(struct phy_device *phydev) 1186 { 1187 struct device_node *node = phydev->dev.of_node; 1188 u32 max_speed; 1189 1190 if (!IS_ENABLED(CONFIG_OF_MDIO)) 1191 return; 1192 1193 if (!node) 1194 return; 1195 1196 if (!of_property_read_u32(node, "max-speed", &max_speed)) { 1197 /* The default values for phydev->supported are provided by the PHY 1198 * driver "features" member, we want to reset to sane defaults fist 1199 * before supporting higher speeds. 1200 */ 1201 phydev->supported &= PHY_DEFAULT_FEATURES; 1202 1203 switch (max_speed) { 1204 default: 1205 return; 1206 1207 case SPEED_1000: 1208 phydev->supported |= PHY_1000BT_FEATURES; 1209 case SPEED_100: 1210 phydev->supported |= PHY_100BT_FEATURES; 1211 case SPEED_10: 1212 phydev->supported |= PHY_10BT_FEATURES; 1213 } 1214 } 1215 } 1216 1217 /** 1218 * phy_probe - probe and init a PHY device 1219 * @dev: device to probe and init 1220 * 1221 * Description: Take care of setting up the phy_device structure, 1222 * set the state to READY (the driver's init function should 1223 * set it to STARTING if needed). 1224 */ 1225 static int phy_probe(struct device *dev) 1226 { 1227 struct phy_device *phydev = to_phy_device(dev); 1228 struct device_driver *drv = phydev->dev.driver; 1229 struct phy_driver *phydrv = to_phy_driver(drv); 1230 int err = 0; 1231 1232 phydev->drv = phydrv; 1233 1234 /* Disable the interrupt if the PHY doesn't support it 1235 * but the interrupt is still a valid one 1236 */ 1237 if (!(phydrv->flags & PHY_HAS_INTERRUPT) && 1238 phy_interrupt_is_valid(phydev)) 1239 phydev->irq = PHY_POLL; 1240 1241 if (phydrv->flags & PHY_IS_INTERNAL) 1242 phydev->is_internal = true; 1243 1244 mutex_lock(&phydev->lock); 1245 1246 /* Start out supporting everything. Eventually, 1247 * a controller will attach, and may modify one 1248 * or both of these values 1249 */ 1250 phydev->supported = phydrv->features; 1251 of_set_phy_supported(phydev); 1252 phydev->advertising = phydev->supported; 1253 1254 /* Set the state to READY by default */ 1255 phydev->state = PHY_READY; 1256 1257 if (phydev->drv->probe) 1258 err = phydev->drv->probe(phydev); 1259 1260 mutex_unlock(&phydev->lock); 1261 1262 return err; 1263 } 1264 1265 static int phy_remove(struct device *dev) 1266 { 1267 struct phy_device *phydev = to_phy_device(dev); 1268 1269 mutex_lock(&phydev->lock); 1270 phydev->state = PHY_DOWN; 1271 mutex_unlock(&phydev->lock); 1272 1273 if (phydev->drv->remove) 1274 phydev->drv->remove(phydev); 1275 phydev->drv = NULL; 1276 1277 return 0; 1278 } 1279 1280 /** 1281 * phy_driver_register - register a phy_driver with the PHY layer 1282 * @new_driver: new phy_driver to register 1283 */ 1284 int phy_driver_register(struct phy_driver *new_driver) 1285 { 1286 int retval; 1287 1288 new_driver->driver.name = new_driver->name; 1289 new_driver->driver.bus = &mdio_bus_type; 1290 new_driver->driver.probe = phy_probe; 1291 new_driver->driver.remove = phy_remove; 1292 1293 retval = driver_register(&new_driver->driver); 1294 if (retval) { 1295 pr_err("%s: Error %d in registering driver\n", 1296 new_driver->name, retval); 1297 1298 return retval; 1299 } 1300 1301 pr_debug("%s: Registered new driver\n", new_driver->name); 1302 1303 return 0; 1304 } 1305 EXPORT_SYMBOL(phy_driver_register); 1306 1307 int phy_drivers_register(struct phy_driver *new_driver, int n) 1308 { 1309 int i, ret = 0; 1310 1311 for (i = 0; i < n; i++) { 1312 ret = phy_driver_register(new_driver + i); 1313 if (ret) { 1314 while (i-- > 0) 1315 phy_driver_unregister(new_driver + i); 1316 break; 1317 } 1318 } 1319 return ret; 1320 } 1321 EXPORT_SYMBOL(phy_drivers_register); 1322 1323 void phy_driver_unregister(struct phy_driver *drv) 1324 { 1325 driver_unregister(&drv->driver); 1326 } 1327 EXPORT_SYMBOL(phy_driver_unregister); 1328 1329 void phy_drivers_unregister(struct phy_driver *drv, int n) 1330 { 1331 int i; 1332 1333 for (i = 0; i < n; i++) 1334 phy_driver_unregister(drv + i); 1335 } 1336 EXPORT_SYMBOL(phy_drivers_unregister); 1337 1338 static struct phy_driver genphy_driver[] = { 1339 { 1340 .phy_id = 0xffffffff, 1341 .phy_id_mask = 0xffffffff, 1342 .name = "Generic PHY", 1343 .soft_reset = genphy_soft_reset, 1344 .config_init = genphy_config_init, 1345 .features = PHY_GBIT_FEATURES | SUPPORTED_MII | 1346 SUPPORTED_AUI | SUPPORTED_FIBRE | 1347 SUPPORTED_BNC, 1348 .config_aneg = genphy_config_aneg, 1349 .aneg_done = genphy_aneg_done, 1350 .read_status = genphy_read_status, 1351 .suspend = genphy_suspend, 1352 .resume = genphy_resume, 1353 .driver = { .owner = THIS_MODULE, }, 1354 }, { 1355 .phy_id = 0xffffffff, 1356 .phy_id_mask = 0xffffffff, 1357 .name = "Generic 10G PHY", 1358 .soft_reset = gen10g_soft_reset, 1359 .config_init = gen10g_config_init, 1360 .features = 0, 1361 .config_aneg = gen10g_config_aneg, 1362 .read_status = gen10g_read_status, 1363 .suspend = gen10g_suspend, 1364 .resume = gen10g_resume, 1365 .driver = {.owner = THIS_MODULE, }, 1366 } }; 1367 1368 static int __init phy_init(void) 1369 { 1370 int rc; 1371 1372 rc = mdio_bus_init(); 1373 if (rc) 1374 return rc; 1375 1376 rc = phy_drivers_register(genphy_driver, 1377 ARRAY_SIZE(genphy_driver)); 1378 if (rc) 1379 mdio_bus_exit(); 1380 1381 return rc; 1382 } 1383 1384 static void __exit phy_exit(void) 1385 { 1386 phy_drivers_unregister(genphy_driver, 1387 ARRAY_SIZE(genphy_driver)); 1388 mdio_bus_exit(); 1389 } 1390 1391 subsys_initcall(phy_init); 1392 module_exit(phy_exit); 1393