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 40MODULE_DESCRIPTION("PHY library"); 41MODULE_AUTHOR("Andy Fleming"); 42MODULE_LICENSE("GPL"); 43 44void phy_device_free(struct phy_device *phydev) 45{ 46 put_device(&phydev->dev); 47} 48EXPORT_SYMBOL(phy_device_free); 49 50static void phy_device_release(struct device *dev) 51{ 52 kfree(to_phy_device(dev)); 53} 54 55enum genphy_driver { 56 GENPHY_DRV_1G, 57 GENPHY_DRV_10G, 58 GENPHY_DRV_MAX 59}; 60 61static struct phy_driver genphy_driver[GENPHY_DRV_MAX]; 62 63static LIST_HEAD(phy_fixup_list); 64static 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 */ 75int 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} 94EXPORT_SYMBOL(phy_register_fixup); 95 96/* Registers a fixup to be run on any PHY with the UID in phy_uid */ 97int 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} 102EXPORT_SYMBOL(phy_register_fixup_for_uid); 103 104/* Registers a fixup to be run on the PHY with id string bus_id */ 105int 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} 110EXPORT_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 */ 115static 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 */ 130static 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 151struct 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} 206EXPORT_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 */ 221static 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 */ 291static 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 */ 326struct 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} 342EXPORT_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 */ 348int 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} 376EXPORT_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 */ 382struct 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} 392EXPORT_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 */ 406static 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 */ 419int 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} 436EXPORT_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 */ 453struct 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} 477EXPORT_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 */ 484void 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} 495EXPORT_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 */ 515static 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 537int 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} 558EXPORT_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 */ 574int 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} 632EXPORT_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 */ 643struct 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} 667EXPORT_SYMBOL(phy_attach); 668 669/** 670 * phy_detach - detach a PHY device from its network device 671 * @phydev: target phy_device struct 672 */ 673void 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} 696EXPORT_SYMBOL(phy_detach); 697 698int 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 int ret = 0; 703 704 /* If the device has WOL enabled, we cannot suspend the PHY */ 705 phy_ethtool_get_wol(phydev, &wol); 706 if (wol.wolopts) 707 return -EBUSY; 708 709 if (phydrv->suspend) 710 ret = phydrv->suspend(phydev); 711 712 if (ret) 713 return ret; 714 715 phydev->suspended = true; 716 717 return ret; 718} 719EXPORT_SYMBOL(phy_suspend); 720 721int phy_resume(struct phy_device *phydev) 722{ 723 struct phy_driver *phydrv = to_phy_driver(phydev->dev.driver); 724 int ret = 0; 725 726 if (phydrv->resume) 727 ret = phydrv->resume(phydev); 728 729 if (ret) 730 return ret; 731 732 phydev->suspended = false; 733 734 return ret; 735} 736EXPORT_SYMBOL(phy_resume); 737 738/* Generic PHY support and helper functions */ 739 740/** 741 * genphy_config_advert - sanitize and advertise auto-negotiation parameters 742 * @phydev: target phy_device struct 743 * 744 * Description: Writes MII_ADVERTISE with the appropriate values, 745 * after sanitizing the values to make sure we only advertise 746 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 747 * hasn't changed, and > 0 if it has changed. 748 */ 749static int genphy_config_advert(struct phy_device *phydev) 750{ 751 u32 advertise; 752 int oldadv, adv, bmsr; 753 int err, changed = 0; 754 755 /* Only allow advertising what this PHY supports */ 756 phydev->advertising &= phydev->supported; 757 advertise = phydev->advertising; 758 759 /* Setup standard advertisement */ 760 adv = phy_read(phydev, MII_ADVERTISE); 761 if (adv < 0) 762 return adv; 763 764 oldadv = adv; 765 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 766 ADVERTISE_PAUSE_ASYM); 767 adv |= ethtool_adv_to_mii_adv_t(advertise); 768 769 if (adv != oldadv) { 770 err = phy_write(phydev, MII_ADVERTISE, adv); 771 772 if (err < 0) 773 return err; 774 changed = 1; 775 } 776 777 bmsr = phy_read(phydev, MII_BMSR); 778 if (bmsr < 0) 779 return bmsr; 780 781 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all 782 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a 783 * logical 1. 784 */ 785 if (!(bmsr & BMSR_ESTATEN)) 786 return changed; 787 788 /* Configure gigabit if it's supported */ 789 adv = phy_read(phydev, MII_CTRL1000); 790 if (adv < 0) 791 return adv; 792 793 oldadv = adv; 794 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 795 796 if (phydev->supported & (SUPPORTED_1000baseT_Half | 797 SUPPORTED_1000baseT_Full)) { 798 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise); 799 } 800 801 if (adv != oldadv) 802 changed = 1; 803 804 err = phy_write(phydev, MII_CTRL1000, adv); 805 if (err < 0) 806 return err; 807 808 return changed; 809} 810 811/** 812 * genphy_setup_forced - configures/forces speed/duplex from @phydev 813 * @phydev: target phy_device struct 814 * 815 * Description: Configures MII_BMCR to force speed/duplex 816 * to the values in phydev. Assumes that the values are valid. 817 * Please see phy_sanitize_settings(). 818 */ 819int genphy_setup_forced(struct phy_device *phydev) 820{ 821 int ctl = 0; 822 823 phydev->pause = 0; 824 phydev->asym_pause = 0; 825 826 if (SPEED_1000 == phydev->speed) 827 ctl |= BMCR_SPEED1000; 828 else if (SPEED_100 == phydev->speed) 829 ctl |= BMCR_SPEED100; 830 831 if (DUPLEX_FULL == phydev->duplex) 832 ctl |= BMCR_FULLDPLX; 833 834 return phy_write(phydev, MII_BMCR, ctl); 835} 836EXPORT_SYMBOL(genphy_setup_forced); 837 838/** 839 * genphy_restart_aneg - Enable and Restart Autonegotiation 840 * @phydev: target phy_device struct 841 */ 842int genphy_restart_aneg(struct phy_device *phydev) 843{ 844 int ctl = phy_read(phydev, MII_BMCR); 845 846 if (ctl < 0) 847 return ctl; 848 849 ctl |= BMCR_ANENABLE | BMCR_ANRESTART; 850 851 /* Don't isolate the PHY if we're negotiating */ 852 ctl &= ~BMCR_ISOLATE; 853 854 return phy_write(phydev, MII_BMCR, ctl); 855} 856EXPORT_SYMBOL(genphy_restart_aneg); 857 858/** 859 * genphy_config_aneg - restart auto-negotiation or write BMCR 860 * @phydev: target phy_device struct 861 * 862 * Description: If auto-negotiation is enabled, we configure the 863 * advertising, and then restart auto-negotiation. If it is not 864 * enabled, then we write the BMCR. 865 */ 866int genphy_config_aneg(struct phy_device *phydev) 867{ 868 int result; 869 870 if (AUTONEG_ENABLE != phydev->autoneg) 871 return genphy_setup_forced(phydev); 872 873 result = genphy_config_advert(phydev); 874 if (result < 0) /* error */ 875 return result; 876 if (result == 0) { 877 /* Advertisement hasn't changed, but maybe aneg was never on to 878 * begin with? Or maybe phy was isolated? 879 */ 880 int ctl = phy_read(phydev, MII_BMCR); 881 882 if (ctl < 0) 883 return ctl; 884 885 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 886 result = 1; /* do restart aneg */ 887 } 888 889 /* Only restart aneg if we are advertising something different 890 * than we were before. 891 */ 892 if (result > 0) 893 result = genphy_restart_aneg(phydev); 894 895 return result; 896} 897EXPORT_SYMBOL(genphy_config_aneg); 898 899/** 900 * genphy_aneg_done - return auto-negotiation status 901 * @phydev: target phy_device struct 902 * 903 * Description: Reads the status register and returns 0 either if 904 * auto-negotiation is incomplete, or if there was an error. 905 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 906 */ 907int genphy_aneg_done(struct phy_device *phydev) 908{ 909 int retval = phy_read(phydev, MII_BMSR); 910 911 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 912} 913EXPORT_SYMBOL(genphy_aneg_done); 914 915static int gen10g_config_aneg(struct phy_device *phydev) 916{ 917 return 0; 918} 919 920/** 921 * genphy_update_link - update link status in @phydev 922 * @phydev: target phy_device struct 923 * 924 * Description: Update the value in phydev->link to reflect the 925 * current link value. In order to do this, we need to read 926 * the status register twice, keeping the second value. 927 */ 928int genphy_update_link(struct phy_device *phydev) 929{ 930 int status; 931 932 /* Do a fake read */ 933 status = phy_read(phydev, MII_BMSR); 934 if (status < 0) 935 return status; 936 937 /* Read link and autonegotiation status */ 938 status = phy_read(phydev, MII_BMSR); 939 if (status < 0) 940 return status; 941 942 if ((status & BMSR_LSTATUS) == 0) 943 phydev->link = 0; 944 else 945 phydev->link = 1; 946 947 return 0; 948} 949EXPORT_SYMBOL(genphy_update_link); 950 951/** 952 * genphy_read_status - check the link status and update current link state 953 * @phydev: target phy_device struct 954 * 955 * Description: Check the link, then figure out the current state 956 * by comparing what we advertise with what the link partner 957 * advertises. Start by checking the gigabit possibilities, 958 * then move on to 10/100. 959 */ 960int genphy_read_status(struct phy_device *phydev) 961{ 962 int adv; 963 int err; 964 int lpa; 965 int lpagb = 0; 966 int common_adv; 967 int common_adv_gb = 0; 968 969 /* Update the link, but return if there was an error */ 970 err = genphy_update_link(phydev); 971 if (err) 972 return err; 973 974 phydev->lp_advertising = 0; 975 976 if (AUTONEG_ENABLE == phydev->autoneg) { 977 if (phydev->supported & (SUPPORTED_1000baseT_Half 978 | SUPPORTED_1000baseT_Full)) { 979 lpagb = phy_read(phydev, MII_STAT1000); 980 if (lpagb < 0) 981 return lpagb; 982 983 adv = phy_read(phydev, MII_CTRL1000); 984 if (adv < 0) 985 return adv; 986 987 phydev->lp_advertising = 988 mii_stat1000_to_ethtool_lpa_t(lpagb); 989 common_adv_gb = lpagb & adv << 2; 990 } 991 992 lpa = phy_read(phydev, MII_LPA); 993 if (lpa < 0) 994 return lpa; 995 996 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa); 997 998 adv = phy_read(phydev, MII_ADVERTISE); 999 if (adv < 0) 1000 return adv; 1001 1002 common_adv = lpa & adv; 1003 1004 phydev->speed = SPEED_10; 1005 phydev->duplex = DUPLEX_HALF; 1006 phydev->pause = 0; 1007 phydev->asym_pause = 0; 1008 1009 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) { 1010 phydev->speed = SPEED_1000; 1011 1012 if (common_adv_gb & LPA_1000FULL) 1013 phydev->duplex = DUPLEX_FULL; 1014 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) { 1015 phydev->speed = SPEED_100; 1016 1017 if (common_adv & LPA_100FULL) 1018 phydev->duplex = DUPLEX_FULL; 1019 } else 1020 if (common_adv & LPA_10FULL) 1021 phydev->duplex = DUPLEX_FULL; 1022 1023 if (phydev->duplex == DUPLEX_FULL) { 1024 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0; 1025 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0; 1026 } 1027 } else { 1028 int bmcr = phy_read(phydev, MII_BMCR); 1029 1030 if (bmcr < 0) 1031 return bmcr; 1032 1033 if (bmcr & BMCR_FULLDPLX) 1034 phydev->duplex = DUPLEX_FULL; 1035 else 1036 phydev->duplex = DUPLEX_HALF; 1037 1038 if (bmcr & BMCR_SPEED1000) 1039 phydev->speed = SPEED_1000; 1040 else if (bmcr & BMCR_SPEED100) 1041 phydev->speed = SPEED_100; 1042 else 1043 phydev->speed = SPEED_10; 1044 1045 phydev->pause = 0; 1046 phydev->asym_pause = 0; 1047 } 1048 1049 return 0; 1050} 1051EXPORT_SYMBOL(genphy_read_status); 1052 1053static int gen10g_read_status(struct phy_device *phydev) 1054{ 1055 int devad, reg; 1056 u32 mmd_mask = phydev->c45_ids.devices_in_package; 1057 1058 phydev->link = 1; 1059 1060 /* For now just lie and say it's 10G all the time */ 1061 phydev->speed = SPEED_10000; 1062 phydev->duplex = DUPLEX_FULL; 1063 1064 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) { 1065 if (!(mmd_mask & 1)) 1066 continue; 1067 1068 /* Read twice because link state is latched and a 1069 * read moves the current state into the register 1070 */ 1071 phy_read_mmd(phydev, devad, MDIO_STAT1); 1072 reg = phy_read_mmd(phydev, devad, MDIO_STAT1); 1073 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS)) 1074 phydev->link = 0; 1075 } 1076 1077 return 0; 1078} 1079 1080/** 1081 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit 1082 * @phydev: target phy_device struct 1083 * 1084 * Description: Perform a software PHY reset using the standard 1085 * BMCR_RESET bit and poll for the reset bit to be cleared. 1086 * 1087 * Returns: 0 on success, < 0 on failure 1088 */ 1089int genphy_soft_reset(struct phy_device *phydev) 1090{ 1091 int ret; 1092 1093 ret = phy_write(phydev, MII_BMCR, BMCR_RESET); 1094 if (ret < 0) 1095 return ret; 1096 1097 return phy_poll_reset(phydev); 1098} 1099EXPORT_SYMBOL(genphy_soft_reset); 1100 1101int genphy_config_init(struct phy_device *phydev) 1102{ 1103 int val; 1104 u32 features; 1105 1106 features = (SUPPORTED_TP | SUPPORTED_MII 1107 | SUPPORTED_AUI | SUPPORTED_FIBRE | 1108 SUPPORTED_BNC); 1109 1110 /* Do we support autonegotiation? */ 1111 val = phy_read(phydev, MII_BMSR); 1112 if (val < 0) 1113 return val; 1114 1115 if (val & BMSR_ANEGCAPABLE) 1116 features |= SUPPORTED_Autoneg; 1117 1118 if (val & BMSR_100FULL) 1119 features |= SUPPORTED_100baseT_Full; 1120 if (val & BMSR_100HALF) 1121 features |= SUPPORTED_100baseT_Half; 1122 if (val & BMSR_10FULL) 1123 features |= SUPPORTED_10baseT_Full; 1124 if (val & BMSR_10HALF) 1125 features |= SUPPORTED_10baseT_Half; 1126 1127 if (val & BMSR_ESTATEN) { 1128 val = phy_read(phydev, MII_ESTATUS); 1129 if (val < 0) 1130 return val; 1131 1132 if (val & ESTATUS_1000_TFULL) 1133 features |= SUPPORTED_1000baseT_Full; 1134 if (val & ESTATUS_1000_THALF) 1135 features |= SUPPORTED_1000baseT_Half; 1136 } 1137 1138 phydev->supported &= features; 1139 phydev->advertising &= features; 1140 1141 return 0; 1142} 1143 1144static int gen10g_soft_reset(struct phy_device *phydev) 1145{ 1146 /* Do nothing for now */ 1147 return 0; 1148} 1149EXPORT_SYMBOL(genphy_config_init); 1150 1151static int gen10g_config_init(struct phy_device *phydev) 1152{ 1153 /* Temporarily just say we support everything */ 1154 phydev->supported = SUPPORTED_10000baseT_Full; 1155 phydev->advertising = SUPPORTED_10000baseT_Full; 1156 1157 return 0; 1158} 1159 1160int genphy_suspend(struct phy_device *phydev) 1161{ 1162 int value; 1163 1164 mutex_lock(&phydev->lock); 1165 1166 value = phy_read(phydev, MII_BMCR); 1167 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN); 1168 1169 mutex_unlock(&phydev->lock); 1170 1171 return 0; 1172} 1173EXPORT_SYMBOL(genphy_suspend); 1174 1175static int gen10g_suspend(struct phy_device *phydev) 1176{ 1177 return 0; 1178} 1179 1180int genphy_resume(struct phy_device *phydev) 1181{ 1182 int value; 1183 1184 mutex_lock(&phydev->lock); 1185 1186 value = phy_read(phydev, MII_BMCR); 1187 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN); 1188 1189 mutex_unlock(&phydev->lock); 1190 1191 return 0; 1192} 1193EXPORT_SYMBOL(genphy_resume); 1194 1195static int gen10g_resume(struct phy_device *phydev) 1196{ 1197 return 0; 1198} 1199 1200static void of_set_phy_supported(struct phy_device *phydev) 1201{ 1202 struct device_node *node = phydev->dev.of_node; 1203 u32 max_speed; 1204 1205 if (!IS_ENABLED(CONFIG_OF_MDIO)) 1206 return; 1207 1208 if (!node) 1209 return; 1210 1211 if (!of_property_read_u32(node, "max-speed", &max_speed)) { 1212 /* The default values for phydev->supported are provided by the PHY 1213 * driver "features" member, we want to reset to sane defaults fist 1214 * before supporting higher speeds. 1215 */ 1216 phydev->supported &= PHY_DEFAULT_FEATURES; 1217 1218 switch (max_speed) { 1219 default: 1220 return; 1221 1222 case SPEED_1000: 1223 phydev->supported |= PHY_1000BT_FEATURES; 1224 case SPEED_100: 1225 phydev->supported |= PHY_100BT_FEATURES; 1226 case SPEED_10: 1227 phydev->supported |= PHY_10BT_FEATURES; 1228 } 1229 } 1230} 1231 1232/** 1233 * phy_probe - probe and init a PHY device 1234 * @dev: device to probe and init 1235 * 1236 * Description: Take care of setting up the phy_device structure, 1237 * set the state to READY (the driver's init function should 1238 * set it to STARTING if needed). 1239 */ 1240static int phy_probe(struct device *dev) 1241{ 1242 struct phy_device *phydev = to_phy_device(dev); 1243 struct device_driver *drv = phydev->dev.driver; 1244 struct phy_driver *phydrv = to_phy_driver(drv); 1245 int err = 0; 1246 1247 phydev->drv = phydrv; 1248 1249 /* Disable the interrupt if the PHY doesn't support it 1250 * but the interrupt is still a valid one 1251 */ 1252 if (!(phydrv->flags & PHY_HAS_INTERRUPT) && 1253 phy_interrupt_is_valid(phydev)) 1254 phydev->irq = PHY_POLL; 1255 1256 if (phydrv->flags & PHY_IS_INTERNAL) 1257 phydev->is_internal = true; 1258 1259 mutex_lock(&phydev->lock); 1260 1261 /* Start out supporting everything. Eventually, 1262 * a controller will attach, and may modify one 1263 * or both of these values 1264 */ 1265 phydev->supported = phydrv->features; 1266 of_set_phy_supported(phydev); 1267 phydev->advertising = phydev->supported; 1268 1269 /* Set the state to READY by default */ 1270 phydev->state = PHY_READY; 1271 1272 if (phydev->drv->probe) 1273 err = phydev->drv->probe(phydev); 1274 1275 mutex_unlock(&phydev->lock); 1276 1277 return err; 1278} 1279 1280static int phy_remove(struct device *dev) 1281{ 1282 struct phy_device *phydev = to_phy_device(dev); 1283 1284 mutex_lock(&phydev->lock); 1285 phydev->state = PHY_DOWN; 1286 mutex_unlock(&phydev->lock); 1287 1288 if (phydev->drv->remove) 1289 phydev->drv->remove(phydev); 1290 phydev->drv = NULL; 1291 1292 return 0; 1293} 1294 1295/** 1296 * phy_driver_register - register a phy_driver with the PHY layer 1297 * @new_driver: new phy_driver to register 1298 */ 1299int phy_driver_register(struct phy_driver *new_driver) 1300{ 1301 int retval; 1302 1303 new_driver->driver.name = new_driver->name; 1304 new_driver->driver.bus = &mdio_bus_type; 1305 new_driver->driver.probe = phy_probe; 1306 new_driver->driver.remove = phy_remove; 1307 1308 retval = driver_register(&new_driver->driver); 1309 if (retval) { 1310 pr_err("%s: Error %d in registering driver\n", 1311 new_driver->name, retval); 1312 1313 return retval; 1314 } 1315 1316 pr_debug("%s: Registered new driver\n", new_driver->name); 1317 1318 return 0; 1319} 1320EXPORT_SYMBOL(phy_driver_register); 1321 1322int phy_drivers_register(struct phy_driver *new_driver, int n) 1323{ 1324 int i, ret = 0; 1325 1326 for (i = 0; i < n; i++) { 1327 ret = phy_driver_register(new_driver + i); 1328 if (ret) { 1329 while (i-- > 0) 1330 phy_driver_unregister(new_driver + i); 1331 break; 1332 } 1333 } 1334 return ret; 1335} 1336EXPORT_SYMBOL(phy_drivers_register); 1337 1338void phy_driver_unregister(struct phy_driver *drv) 1339{ 1340 driver_unregister(&drv->driver); 1341} 1342EXPORT_SYMBOL(phy_driver_unregister); 1343 1344void phy_drivers_unregister(struct phy_driver *drv, int n) 1345{ 1346 int i; 1347 1348 for (i = 0; i < n; i++) 1349 phy_driver_unregister(drv + i); 1350} 1351EXPORT_SYMBOL(phy_drivers_unregister); 1352 1353static struct phy_driver genphy_driver[] = { 1354{ 1355 .phy_id = 0xffffffff, 1356 .phy_id_mask = 0xffffffff, 1357 .name = "Generic PHY", 1358 .soft_reset = genphy_soft_reset, 1359 .config_init = genphy_config_init, 1360 .features = PHY_GBIT_FEATURES | SUPPORTED_MII | 1361 SUPPORTED_AUI | SUPPORTED_FIBRE | 1362 SUPPORTED_BNC, 1363 .config_aneg = genphy_config_aneg, 1364 .aneg_done = genphy_aneg_done, 1365 .read_status = genphy_read_status, 1366 .suspend = genphy_suspend, 1367 .resume = genphy_resume, 1368 .driver = { .owner = THIS_MODULE, }, 1369}, { 1370 .phy_id = 0xffffffff, 1371 .phy_id_mask = 0xffffffff, 1372 .name = "Generic 10G PHY", 1373 .soft_reset = gen10g_soft_reset, 1374 .config_init = gen10g_config_init, 1375 .features = 0, 1376 .config_aneg = gen10g_config_aneg, 1377 .read_status = gen10g_read_status, 1378 .suspend = gen10g_suspend, 1379 .resume = gen10g_resume, 1380 .driver = {.owner = THIS_MODULE, }, 1381} }; 1382 1383static int __init phy_init(void) 1384{ 1385 int rc; 1386 1387 rc = mdio_bus_init(); 1388 if (rc) 1389 return rc; 1390 1391 rc = phy_drivers_register(genphy_driver, 1392 ARRAY_SIZE(genphy_driver)); 1393 if (rc) 1394 mdio_bus_exit(); 1395 1396 return rc; 1397} 1398 1399static void __exit phy_exit(void) 1400{ 1401 phy_drivers_unregister(genphy_driver, 1402 ARRAY_SIZE(genphy_driver)); 1403 mdio_bus_exit(); 1404} 1405 1406subsys_initcall(phy_init); 1407module_exit(phy_exit); 1408