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