drivers/net/phy/phy_device.c

   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);