drivers/net/phy/phy_device.c

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