drivers/net/phy/phy-core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Core PHY library, taken from phy.c
   4  */
   5 #include <linux/export.h>
   6 #include <linux/phy.h>
   7 #include <linux/of.h>
   8
   9 const char *phy_speed_to_str(int speed)
  10 {
  11         switch (speed) {
  12         case SPEED_10:
  13                 return "10Mbps";
  14         case SPEED_100:
  15                 return "100Mbps";
  16         case SPEED_1000:
  17                 return "1Gbps";
  18         case SPEED_2500:
  19                 return "2.5Gbps";
  20         case SPEED_5000:
  21                 return "5Gbps";
  22         case SPEED_10000:
  23                 return "10Gbps";
  24         case SPEED_14000:
  25                 return "14Gbps";
  26         case SPEED_20000:
  27                 return "20Gbps";
  28         case SPEED_25000:
  29                 return "25Gbps";
  30         case SPEED_40000:
  31                 return "40Gbps";
  32         case SPEED_50000:
  33                 return "50Gbps";
  34         case SPEED_56000:
  35                 return "56Gbps";
  36         case SPEED_100000:
  37                 return "100Gbps";
  38         case SPEED_UNKNOWN:
  39                 return "Unknown";
  40         default:
  41                 return "Unsupported (update phy-core.c)";
  42         }
  43 }
  44 EXPORT_SYMBOL_GPL(phy_speed_to_str);
  45
  46 const char *phy_duplex_to_str(unsigned int duplex)
  47 {
  48         if (duplex == DUPLEX_HALF)
  49                 return "Half";
  50         if (duplex == DUPLEX_FULL)
  51                 return "Full";
  52         if (duplex == DUPLEX_UNKNOWN)
  53                 return "Unknown";
  54         return "Unsupported (update phy-core.c)";
  55 }
  56 EXPORT_SYMBOL_GPL(phy_duplex_to_str);
  57
  58 /* A mapping of all SUPPORTED settings to speed/duplex.  This table
  59  * must be grouped by speed and sorted in descending match priority
  60  * - iow, descending speed. */
  61 static const struct phy_setting settings[] = {
  62         /* 100G */
  63         {
  64                 .speed = SPEED_100000,
  65                 .duplex = DUPLEX_FULL,
  66                 .bit = ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
  67         },
  68         {
  69                 .speed = SPEED_100000,
  70                 .duplex = DUPLEX_FULL,
  71                 .bit = ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
  72         },
  73         {
  74                 .speed = SPEED_100000,
  75                 .duplex = DUPLEX_FULL,
  76                 .bit = ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
  77         },
  78         {
  79                 .speed = SPEED_100000,
  80                 .duplex = DUPLEX_FULL,
  81                 .bit = ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
  82         },
  83         /* 56G */
  84         {
  85                 .speed = SPEED_56000,
  86                 .duplex = DUPLEX_FULL,
  87                 .bit = ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT,
  88         },
  89         {
  90                 .speed = SPEED_56000,
  91                 .duplex = DUPLEX_FULL,
  92                 .bit = ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT,
  93         },
  94         {
  95                 .speed = SPEED_56000,
  96                 .duplex = DUPLEX_FULL,
  97                 .bit = ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT,
  98         },
  99         {
 100                 .speed = SPEED_56000,
 101                 .duplex = DUPLEX_FULL,
 102                 .bit = ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT,
 103         },
 104         /* 50G */
 105         {
 106                 .speed = SPEED_50000,
 107                 .duplex = DUPLEX_FULL,
 108                 .bit = ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
 109         },
 110         {
 111                 .speed = SPEED_50000,
 112                 .duplex = DUPLEX_FULL,
 113                 .bit = ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
 114         },
 115         {
 116                 .speed = SPEED_50000,
 117                 .duplex = DUPLEX_FULL,
 118                 .bit = ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
 119         },
 120         /* 40G */
 121         {
 122                 .speed = SPEED_40000,
 123                 .duplex = DUPLEX_FULL,
 124                 .bit = ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
 125         },
 126         {
 127                 .speed = SPEED_40000,
 128                 .duplex = DUPLEX_FULL,
 129                 .bit = ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
 130         },
 131         {
 132                 .speed = SPEED_40000,
 133                 .duplex = DUPLEX_FULL,
 134                 .bit = ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT,
 135         },
 136         {
 137                 .speed = SPEED_40000,
 138                 .duplex = DUPLEX_FULL,
 139                 .bit = ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
 140         },
 141         /* 25G */
 142         {
 143                 .speed = SPEED_25000,
 144                 .duplex = DUPLEX_FULL,
 145                 .bit = ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
 146         },
 147         {
 148                 .speed = SPEED_25000,
 149                 .duplex = DUPLEX_FULL,
 150                 .bit = ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
 151         },
 152         {
 153                 .speed = SPEED_25000,
 154                 .duplex = DUPLEX_FULL,
 155                 .bit = ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
 156         },
 157
 158         /* 20G */
 159         {
 160                 .speed = SPEED_20000,
 161                 .duplex = DUPLEX_FULL,
 162                 .bit = ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT,
 163         },
 164         {
 165                 .speed = SPEED_20000,
 166                 .duplex = DUPLEX_FULL,
 167                 .bit = ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT,
 168         },
 169         /* 10G */
 170         {
 171                 .speed = SPEED_10000,
 172                 .duplex = DUPLEX_FULL,
 173                 .bit = ETHTOOL_LINK_MODE_10000baseCR_Full_BIT,
 174         },
 175         {
 176                 .speed = SPEED_10000,
 177                 .duplex = DUPLEX_FULL,
 178                 .bit = ETHTOOL_LINK_MODE_10000baseER_Full_BIT,
 179         },
 180         {
 181                 .speed = SPEED_10000,
 182                 .duplex = DUPLEX_FULL,
 183                 .bit = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
 184         },
 185         {
 186                 .speed = SPEED_10000,
 187                 .duplex = DUPLEX_FULL,
 188                 .bit = ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
 189         },
 190         {
 191                 .speed = SPEED_10000,
 192                 .duplex = DUPLEX_FULL,
 193                 .bit = ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
 194         },
 195         {
 196                 .speed = SPEED_10000,
 197                 .duplex = DUPLEX_FULL,
 198                 .bit = ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT,
 199         },
 200         {
 201                 .speed = SPEED_10000,
 202                 .duplex = DUPLEX_FULL,
 203                 .bit = ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
 204         },
 205         {
 206                 .speed = SPEED_10000,
 207                 .duplex = DUPLEX_FULL,
 208                 .bit = ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
 209         },
 210         {
 211                 .speed = SPEED_10000,
 212                 .duplex = DUPLEX_FULL,
 213                 .bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
 214         },
 215         /* 5G */
 216         {
 217                 .speed = SPEED_5000,
 218                 .duplex = DUPLEX_FULL,
 219                 .bit = ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
 220         },
 221
 222         /* 2.5G */
 223         {
 224                 .speed = SPEED_2500,
 225                 .duplex = DUPLEX_FULL,
 226                 .bit = ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
 227         },
 228         {
 229                 .speed = SPEED_2500,
 230                 .duplex = DUPLEX_FULL,
 231                 .bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
 232         },
 233         /* 1G */
 234         {
 235                 .speed = SPEED_1000,
 236                 .duplex = DUPLEX_FULL,
 237                 .bit = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
 238         },
 239         {
 240                 .speed = SPEED_1000,
 241                 .duplex = DUPLEX_FULL,
 242                 .bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
 243         },
 244         {
 245                 .speed = SPEED_1000,
 246                 .duplex = DUPLEX_HALF,
 247                 .bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
 248         },
 249         {
 250                 .speed = SPEED_1000,
 251                 .duplex = DUPLEX_FULL,
 252                 .bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
 253         },
 254         /* 100M */
 255         {
 256                 .speed = SPEED_100,
 257                 .duplex = DUPLEX_FULL,
 258                 .bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT,
 259         },
 260         {
 261                 .speed = SPEED_100,
 262                 .duplex = DUPLEX_HALF,
 263                 .bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT,
 264         },
 265         /* 10M */
 266         {
 267                 .speed = SPEED_10,
 268                 .duplex = DUPLEX_FULL,
 269                 .bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT,
 270         },
 271         {
 272                 .speed = SPEED_10,
 273                 .duplex = DUPLEX_HALF,
 274                 .bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT,
 275         },
 276 };
 277
 278 /**
 279  * phy_lookup_setting - lookup a PHY setting
 280  * @speed: speed to match
 281  * @duplex: duplex to match
 282  * @mask: allowed link modes
 283  * @exact: an exact match is required
 284  *
 285  * Search the settings array for a setting that matches the speed and
 286  * duplex, and which is supported.
 287  *
 288  * If @exact is unset, either an exact match or %NULL for no match will
 289  * be returned.
 290  *
 291  * If @exact is set, an exact match, the fastest supported setting at
 292  * or below the specified speed, the slowest supported setting, or if
 293  * they all fail, %NULL will be returned.
 294  */
 295 const struct phy_setting *
 296 phy_lookup_setting(int speed, int duplex, const unsigned long *mask, bool exact)
 297 {
 298         const struct phy_setting *p, *match = NULL, *last = NULL;
 299         int i;
 300
 301         for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
 302                 if (p->bit < __ETHTOOL_LINK_MODE_MASK_NBITS &&
 303                     test_bit(p->bit, mask)) {
 304                         last = p;
 305                         if (p->speed == speed && p->duplex == duplex) {
 306                                 /* Exact match for speed and duplex */
 307                                 match = p;
 308                                 break;
 309                         } else if (!exact) {
 310                                 if (!match && p->speed <= speed)
 311                                         /* Candidate */
 312                                         match = p;
 313
 314                                 if (p->speed < speed)
 315                                         break;
 316                         }
 317                 }
 318         }
 319
 320         if (!match && !exact)
 321                 match = last;
 322
 323         return match;
 324 }
 325 EXPORT_SYMBOL_GPL(phy_lookup_setting);
 326
 327 size_t phy_speeds(unsigned int *speeds, size_t size,
 328                   unsigned long *mask)
 329 {
 330         size_t count;
 331         int i;
 332
 333         for (i = 0, count = 0; i < ARRAY_SIZE(settings) && count < size; i++)
 334                 if (settings[i].bit < __ETHTOOL_LINK_MODE_MASK_NBITS &&
 335                     test_bit(settings[i].bit, mask) &&
 336                     (count == 0 || speeds[count - 1] != settings[i].speed))
 337                         speeds[count++] = settings[i].speed;
 338
 339         return count;
 340 }
 341
 342 static int __set_phy_supported(struct phy_device *phydev, u32 max_speed)
 343 {
 344         const struct phy_setting *p;
 345         int i;
 346
 347         for (i = 0, p = settings; i < ARRAY_SIZE(settings); i++, p++) {
 348                 if (p->speed > max_speed)
 349                         linkmode_clear_bit(p->bit, phydev->supported);
 350                 else
 351                         break;
 352         }
 353
 354         return 0;
 355 }
 356
 357 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
 358 {
 359         int err;
 360
 361         err = __set_phy_supported(phydev, max_speed);
 362         if (err)
 363                 return err;
 364
 365         linkmode_copy(phydev->advertising, phydev->supported);
 366
 367         return 0;
 368 }
 369 EXPORT_SYMBOL(phy_set_max_speed);
 370
 371 void of_set_phy_supported(struct phy_device *phydev)
 372 {
 373         struct device_node *node = phydev->mdio.dev.of_node;
 374         u32 max_speed;
 375
 376         if (!IS_ENABLED(CONFIG_OF_MDIO))
 377                 return;
 378
 379         if (!node)
 380                 return;
 381
 382         if (!of_property_read_u32(node, "max-speed", &max_speed))
 383                 __set_phy_supported(phydev, max_speed);
 384 }
 385
 386 void of_set_phy_eee_broken(struct phy_device *phydev)
 387 {
 388         struct device_node *node = phydev->mdio.dev.of_node;
 389         u32 broken = 0;
 390
 391         if (!IS_ENABLED(CONFIG_OF_MDIO))
 392                 return;
 393
 394         if (!node)
 395                 return;
 396
 397         if (of_property_read_bool(node, "eee-broken-100tx"))
 398                 broken |= MDIO_EEE_100TX;
 399         if (of_property_read_bool(node, "eee-broken-1000t"))
 400                 broken |= MDIO_EEE_1000T;
 401         if (of_property_read_bool(node, "eee-broken-10gt"))
 402                 broken |= MDIO_EEE_10GT;
 403         if (of_property_read_bool(node, "eee-broken-1000kx"))
 404                 broken |= MDIO_EEE_1000KX;
 405         if (of_property_read_bool(node, "eee-broken-10gkx4"))
 406                 broken |= MDIO_EEE_10GKX4;
 407         if (of_property_read_bool(node, "eee-broken-10gkr"))
 408                 broken |= MDIO_EEE_10GKR;
 409
 410         phydev->eee_broken_modes = broken;
 411 }
 412
 413 /**
 414  * phy_resolve_aneg_linkmode - resolve the advertisements into phy settings
 415  * @phydev: The phy_device struct
 416  *
 417  * Resolve our and the link partner advertisements into their corresponding
 418  * speed and duplex. If full duplex was negotiated, extract the pause mode
 419  * from the link partner mask.
 420  */
 421 void phy_resolve_aneg_linkmode(struct phy_device *phydev)
 422 {
 423         __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
 424         int i;
 425
 426         linkmode_and(common, phydev->lp_advertising, phydev->advertising);
 427
 428         for (i = 0; i < ARRAY_SIZE(settings); i++)
 429                 if (test_bit(settings[i].bit, common)) {
 430                         phydev->speed = settings[i].speed;
 431                         phydev->duplex = settings[i].duplex;
 432                         break;
 433                 }
 434
 435         if (phydev->duplex == DUPLEX_FULL) {
 436                 phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
 437                                                   phydev->lp_advertising);
 438                 phydev->asym_pause = linkmode_test_bit(
 439                         ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 440                         phydev->lp_advertising);
 441         }
 442 }
 443 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);
 444
 445 static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad,
 446                              u16 regnum)
 447 {
 448         /* Write the desired MMD Devad */
 449         __mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad);
 450
 451         /* Write the desired MMD register address */
 452         __mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum);
 453
 454         /* Select the Function : DATA with no post increment */
 455         __mdiobus_write(bus, phy_addr, MII_MMD_CTRL,
 456                         devad | MII_MMD_CTRL_NOINCR);
 457 }
 458
 459 /**
 460  * __phy_read_mmd - Convenience function for reading a register
 461  * from an MMD on a given PHY.
 462  * @phydev: The phy_device struct
 463  * @devad: The MMD to read from (0..31)
 464  * @regnum: The register on the MMD to read (0..65535)
 465  *
 466  * Same rules as for __phy_read();
 467  */
 468 int __phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
 469 {
 470         int val;
 471
 472         if (regnum > (u16)~0 || devad > 32)
 473                 return -EINVAL;
 474
 475         if (phydev->drv->read_mmd) {
 476                 val = phydev->drv->read_mmd(phydev, devad, regnum);
 477         } else if (phydev->is_c45) {
 478                 u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff);
 479
 480                 val = __mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, addr);
 481         } else {
 482                 struct mii_bus *bus = phydev->mdio.bus;
 483                 int phy_addr = phydev->mdio.addr;
 484
 485                 mmd_phy_indirect(bus, phy_addr, devad, regnum);
 486
 487                 /* Read the content of the MMD's selected register */
 488                 val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA);
 489         }
 490         return val;
 491 }
 492 EXPORT_SYMBOL(__phy_read_mmd);
 493
 494 /**
 495  * phy_read_mmd - Convenience function for reading a register
 496  * from an MMD on a given PHY.
 497  * @phydev: The phy_device struct
 498  * @devad: The MMD to read from
 499  * @regnum: The register on the MMD to read
 500  *
 501  * Same rules as for phy_read();
 502  */
 503 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
 504 {
 505         int ret;
 506
 507         mutex_lock(&phydev->mdio.bus->mdio_lock);
 508         ret = __phy_read_mmd(phydev, devad, regnum);
 509         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 510
 511         return ret;
 512 }
 513 EXPORT_SYMBOL(phy_read_mmd);
 514
 515 /**
 516  * __phy_write_mmd - Convenience function for writing a register
 517  * on an MMD on a given PHY.
 518  * @phydev: The phy_device struct
 519  * @devad: The MMD to read from
 520  * @regnum: The register on the MMD to read
 521  * @val: value to write to @regnum
 522  *
 523  * Same rules as for __phy_write();
 524  */
 525 int __phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
 526 {
 527         int ret;
 528
 529         if (regnum > (u16)~0 || devad > 32)
 530                 return -EINVAL;
 531
 532         if (phydev->drv->write_mmd) {
 533                 ret = phydev->drv->write_mmd(phydev, devad, regnum, val);
 534         } else if (phydev->is_c45) {
 535                 u32 addr = MII_ADDR_C45 | (devad << 16) | (regnum & 0xffff);
 536
 537                 ret = __mdiobus_write(phydev->mdio.bus, phydev->mdio.addr,
 538                                       addr, val);
 539         } else {
 540                 struct mii_bus *bus = phydev->mdio.bus;
 541                 int phy_addr = phydev->mdio.addr;
 542
 543                 mmd_phy_indirect(bus, phy_addr, devad, regnum);
 544
 545                 /* Write the data into MMD's selected register */
 546                 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, val);
 547
 548                 ret = 0;
 549         }
 550         return ret;
 551 }
 552 EXPORT_SYMBOL(__phy_write_mmd);
 553
 554 /**
 555  * phy_write_mmd - Convenience function for writing a register
 556  * on an MMD on a given PHY.
 557  * @phydev: The phy_device struct
 558  * @devad: The MMD to read from
 559  * @regnum: The register on the MMD to read
 560  * @val: value to write to @regnum
 561  *
 562  * Same rules as for phy_write();
 563  */
 564 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
 565 {
 566         int ret;
 567
 568         mutex_lock(&phydev->mdio.bus->mdio_lock);
 569         ret = __phy_write_mmd(phydev, devad, regnum, val);
 570         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 571
 572         return ret;
 573 }
 574 EXPORT_SYMBOL(phy_write_mmd);
 575
 576 /**
 577  * __phy_modify_changed() - Convenience function for modifying a PHY register
 578  * @phydev: a pointer to a &struct phy_device
 579  * @regnum: register number
 580  * @mask: bit mask of bits to clear
 581  * @set: bit mask of bits to set
 582  *
 583  * Unlocked helper function which allows a PHY register to be modified as
 584  * new register value = (old register value & ~mask) | set
 585  *
 586  * Returns negative errno, 0 if there was no change, and 1 in case of change
 587  */
 588 int __phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask,
 589                          u16 set)
 590 {
 591         int new, ret;
 592
 593         ret = __phy_read(phydev, regnum);
 594         if (ret < 0)
 595                 return ret;
 596
 597         new = (ret & ~mask) | set;
 598         if (new == ret)
 599                 return 0;
 600
 601         ret = __phy_write(phydev, regnum, new);
 602
 603         return ret < 0 ? ret : 1;
 604 }
 605 EXPORT_SYMBOL_GPL(__phy_modify_changed);
 606
 607 /**
 608  * phy_modify_changed - Function for modifying a PHY register
 609  * @phydev: the phy_device struct
 610  * @regnum: register number to modify
 611  * @mask: bit mask of bits to clear
 612  * @set: new value of bits set in mask to write to @regnum
 613  *
 614  * NOTE: MUST NOT be called from interrupt context,
 615  * because the bus read/write functions may wait for an interrupt
 616  * to conclude the operation.
 617  *
 618  * Returns negative errno, 0 if there was no change, and 1 in case of change
 619  */
 620 int phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
 621 {
 622         int ret;
 623
 624         mutex_lock(&phydev->mdio.bus->mdio_lock);
 625         ret = __phy_modify_changed(phydev, regnum, mask, set);
 626         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 627
 628         return ret;
 629 }
 630 EXPORT_SYMBOL_GPL(phy_modify_changed);
 631
 632 /**
 633  * __phy_modify - Convenience function for modifying a PHY register
 634  * @phydev: the phy_device struct
 635  * @regnum: register number to modify
 636  * @mask: bit mask of bits to clear
 637  * @set: new value of bits set in mask to write to @regnum
 638  *
 639  * NOTE: MUST NOT be called from interrupt context,
 640  * because the bus read/write functions may wait for an interrupt
 641  * to conclude the operation.
 642  */
 643 int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
 644 {
 645         int ret;
 646
 647         ret = __phy_modify_changed(phydev, regnum, mask, set);
 648
 649         return ret < 0 ? ret : 0;
 650 }
 651 EXPORT_SYMBOL_GPL(__phy_modify);
 652
 653 /**
 654  * phy_modify - Convenience function for modifying a given PHY register
 655  * @phydev: the phy_device struct
 656  * @regnum: register number to write
 657  * @mask: bit mask of bits to clear
 658  * @set: new value of bits set in mask to write to @regnum
 659  *
 660  * NOTE: MUST NOT be called from interrupt context,
 661  * because the bus read/write functions may wait for an interrupt
 662  * to conclude the operation.
 663  */
 664 int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
 665 {
 666         int ret;
 667
 668         mutex_lock(&phydev->mdio.bus->mdio_lock);
 669         ret = __phy_modify(phydev, regnum, mask, set);
 670         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 671
 672         return ret;
 673 }
 674 EXPORT_SYMBOL_GPL(phy_modify);
 675
 676 /**
 677  * __phy_modify_mmd_changed - Function for modifying a register on MMD
 678  * @phydev: the phy_device struct
 679  * @devad: the MMD containing register to modify
 680  * @regnum: register number to modify
 681  * @mask: bit mask of bits to clear
 682  * @set: new value of bits set in mask to write to @regnum
 683  *
 684  * Unlocked helper function which allows a MMD register to be modified as
 685  * new register value = (old register value & ~mask) | set
 686  *
 687  * Returns negative errno, 0 if there was no change, and 1 in case of change
 688  */
 689 int __phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
 690                              u16 mask, u16 set)
 691 {
 692         int new, ret;
 693
 694         ret = __phy_read_mmd(phydev, devad, regnum);
 695         if (ret < 0)
 696                 return ret;
 697
 698         new = (ret & ~mask) | set;
 699         if (new == ret)
 700                 return 0;
 701
 702         ret = __phy_write_mmd(phydev, devad, regnum, new);
 703
 704         return ret < 0 ? ret : 1;
 705 }
 706 EXPORT_SYMBOL_GPL(__phy_modify_mmd_changed);
 707
 708 /**
 709  * phy_modify_mmd_changed - Function for modifying a register on MMD
 710  * @phydev: the phy_device struct
 711  * @devad: the MMD containing register to modify
 712  * @regnum: register number to modify
 713  * @mask: bit mask of bits to clear
 714  * @set: new value of bits set in mask to write to @regnum
 715  *
 716  * NOTE: MUST NOT be called from interrupt context,
 717  * because the bus read/write functions may wait for an interrupt
 718  * to conclude the operation.
 719  *
 720  * Returns negative errno, 0 if there was no change, and 1 in case of change
 721  */
 722 int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
 723                            u16 mask, u16 set)
 724 {
 725         int ret;
 726
 727         mutex_lock(&phydev->mdio.bus->mdio_lock);
 728         ret = __phy_modify_mmd_changed(phydev, devad, regnum, mask, set);
 729         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 730
 731         return ret;
 732 }
 733 EXPORT_SYMBOL_GPL(phy_modify_mmd_changed);
 734
 735 /**
 736  * __phy_modify_mmd - Convenience function for modifying a register on MMD
 737  * @phydev: the phy_device struct
 738  * @devad: the MMD containing register to modify
 739  * @regnum: register number to modify
 740  * @mask: bit mask of bits to clear
 741  * @set: new value of bits set in mask to write to @regnum
 742  *
 743  * NOTE: MUST NOT be called from interrupt context,
 744  * because the bus read/write functions may wait for an interrupt
 745  * to conclude the operation.
 746  */
 747 int __phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
 748                      u16 mask, u16 set)
 749 {
 750         int ret;
 751
 752         ret = __phy_modify_mmd_changed(phydev, devad, regnum, mask, set);
 753
 754         return ret < 0 ? ret : 0;
 755 }
 756 EXPORT_SYMBOL_GPL(__phy_modify_mmd);
 757
 758 /**
 759  * phy_modify_mmd - Convenience function for modifying a register on MMD
 760  * @phydev: the phy_device struct
 761  * @devad: the MMD containing register to modify
 762  * @regnum: register number to modify
 763  * @mask: bit mask of bits to clear
 764  * @set: new value of bits set in mask to write to @regnum
 765  *
 766  * NOTE: MUST NOT be called from interrupt context,
 767  * because the bus read/write functions may wait for an interrupt
 768  * to conclude the operation.
 769  */
 770 int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
 771                    u16 mask, u16 set)
 772 {
 773         int ret;
 774
 775         mutex_lock(&phydev->mdio.bus->mdio_lock);
 776         ret = __phy_modify_mmd(phydev, devad, regnum, mask, set);
 777         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 778
 779         return ret;
 780 }
 781 EXPORT_SYMBOL_GPL(phy_modify_mmd);
 782
 783 static int __phy_read_page(struct phy_device *phydev)
 784 {
 785         return phydev->drv->read_page(phydev);
 786 }
 787
 788 static int __phy_write_page(struct phy_device *phydev, int page)
 789 {
 790         return phydev->drv->write_page(phydev, page);
 791 }
 792
 793 /**
 794  * phy_save_page() - take the bus lock and save the current page
 795  * @phydev: a pointer to a &struct phy_device
 796  *
 797  * Take the MDIO bus lock, and return the current page number. On error,
 798  * returns a negative errno. phy_restore_page() must always be called
 799  * after this, irrespective of success or failure of this call.
 800  */
 801 int phy_save_page(struct phy_device *phydev)
 802 {
 803         mutex_lock(&phydev->mdio.bus->mdio_lock);
 804         return __phy_read_page(phydev);
 805 }
 806 EXPORT_SYMBOL_GPL(phy_save_page);
 807
 808 /**
 809  * phy_select_page() - take the bus lock, save the current page, and set a page
 810  * @phydev: a pointer to a &struct phy_device
 811  * @page: desired page
 812  *
 813  * Take the MDIO bus lock to protect against concurrent access, save the
 814  * current PHY page, and set the current page.  On error, returns a
 815  * negative errno, otherwise returns the previous page number.
 816  * phy_restore_page() must always be called after this, irrespective
 817  * of success or failure of this call.
 818  */
 819 int phy_select_page(struct phy_device *phydev, int page)
 820 {
 821         int ret, oldpage;
 822
 823         oldpage = ret = phy_save_page(phydev);
 824         if (ret < 0)
 825                 return ret;
 826
 827         if (oldpage != page) {
 828                 ret = __phy_write_page(phydev, page);
 829                 if (ret < 0)
 830                         return ret;
 831         }
 832
 833         return oldpage;
 834 }
 835 EXPORT_SYMBOL_GPL(phy_select_page);
 836
 837 /**
 838  * phy_restore_page() - restore the page register and release the bus lock
 839  * @phydev: a pointer to a &struct phy_device
 840  * @oldpage: the old page, return value from phy_save_page() or phy_select_page()
 841  * @ret: operation's return code
 842  *
 843  * Release the MDIO bus lock, restoring @oldpage if it is a valid page.
 844  * This function propagates the earliest error code from the group of
 845  * operations.
 846  *
 847  * Returns:
 848  *   @oldpage if it was a negative value, otherwise
 849  *   @ret if it was a negative errno value, otherwise
 850  *   phy_write_page()'s negative value if it were in error, otherwise
 851  *   @ret.
 852  */
 853 int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)
 854 {
 855         int r;
 856
 857         if (oldpage >= 0) {
 858                 r = __phy_write_page(phydev, oldpage);
 859
 860                 /* Propagate the operation return code if the page write
 861                  * was successful.
 862                  */
 863                 if (ret >= 0 && r < 0)
 864                         ret = r;
 865         } else {
 866                 /* Propagate the phy page selection error code */
 867                 ret = oldpage;
 868         }
 869
 870         mutex_unlock(&phydev->mdio.bus->mdio_lock);
 871
 872         return ret;
 873 }
 874 EXPORT_SYMBOL_GPL(phy_restore_page);
 875
 876 /**
 877  * phy_read_paged() - Convenience function for reading a paged register
 878  * @phydev: a pointer to a &struct phy_device
 879  * @page: the page for the phy
 880  * @regnum: register number
 881  *
 882  * Same rules as for phy_read().
 883  */
 884 int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)
 885 {
 886         int ret = 0, oldpage;
 887
 888         oldpage = phy_select_page(phydev, page);
 889         if (oldpage >= 0)
 890                 ret = __phy_read(phydev, regnum);
 891
 892         return phy_restore_page(phydev, oldpage, ret);
 893 }
 894 EXPORT_SYMBOL(phy_read_paged);
 895
 896 /**
 897  * phy_write_paged() - Convenience function for writing a paged register
 898  * @phydev: a pointer to a &struct phy_device
 899  * @page: the page for the phy
 900  * @regnum: register number
 901  * @val: value to write
 902  *
 903  * Same rules as for phy_write().
 904  */
 905 int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)
 906 {
 907         int ret = 0, oldpage;
 908
 909         oldpage = phy_select_page(phydev, page);
 910         if (oldpage >= 0)
 911                 ret = __phy_write(phydev, regnum, val);
 912
 913         return phy_restore_page(phydev, oldpage, ret);
 914 }
 915 EXPORT_SYMBOL(phy_write_paged);
 916
 917 /**
 918  * phy_modify_paged() - Convenience function for modifying a paged register
 919  * @phydev: a pointer to a &struct phy_device
 920  * @page: the page for the phy
 921  * @regnum: register number
 922  * @mask: bit mask of bits to clear
 923  * @set: bit mask of bits to set
 924  *
 925  * Same rules as for phy_read() and phy_write().
 926  */
 927 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
 928                      u16 mask, u16 set)
 929 {
 930         int ret = 0, oldpage;
 931
 932         oldpage = phy_select_page(phydev, page);
 933         if (oldpage >= 0)
 934                 ret = __phy_modify(phydev, regnum, mask, set);
 935
 936         return phy_restore_page(phydev, oldpage, ret);
 937 }
 938 EXPORT_SYMBOL(phy_modify_paged);