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