1 // SPDX-License-Identifier: GPL-2.0+
3 * Core PHY library, taken from phy.c
5 #include <linux/export.h>
9 const char *phy_speed_to_str(int speed)
41 return "Unsupported (update phy-core.c)";
44 EXPORT_SYMBOL_GPL(phy_speed_to_str);
46 const char *phy_duplex_to_str(unsigned int duplex)
48 if (duplex == DUPLEX_HALF)
50 if (duplex == DUPLEX_FULL)
52 if (duplex == DUPLEX_UNKNOWN)
54 return "Unsupported (update phy-core.c)";
56 EXPORT_SYMBOL_GPL(phy_duplex_to_str);
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[] = {
64 .speed = SPEED_100000,
65 .duplex = DUPLEX_FULL,
66 .bit = ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
69 .speed = SPEED_100000,
70 .duplex = DUPLEX_FULL,
71 .bit = ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
74 .speed = SPEED_100000,
75 .duplex = DUPLEX_FULL,
76 .bit = ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
79 .speed = SPEED_100000,
80 .duplex = DUPLEX_FULL,
81 .bit = ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
86 .duplex = DUPLEX_FULL,
87 .bit = ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT,
91 .duplex = DUPLEX_FULL,
92 .bit = ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT,
96 .duplex = DUPLEX_FULL,
97 .bit = ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT,
100 .speed = SPEED_56000,
101 .duplex = DUPLEX_FULL,
102 .bit = ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT,
106 .speed = SPEED_50000,
107 .duplex = DUPLEX_FULL,
108 .bit = ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
111 .speed = SPEED_50000,
112 .duplex = DUPLEX_FULL,
113 .bit = ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
116 .speed = SPEED_50000,
117 .duplex = DUPLEX_FULL,
118 .bit = ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
122 .speed = SPEED_40000,
123 .duplex = DUPLEX_FULL,
124 .bit = ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
127 .speed = SPEED_40000,
128 .duplex = DUPLEX_FULL,
129 .bit = ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
132 .speed = SPEED_40000,
133 .duplex = DUPLEX_FULL,
134 .bit = ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT,
137 .speed = SPEED_40000,
138 .duplex = DUPLEX_FULL,
139 .bit = ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
143 .speed = SPEED_25000,
144 .duplex = DUPLEX_FULL,
145 .bit = ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
148 .speed = SPEED_25000,
149 .duplex = DUPLEX_FULL,
150 .bit = ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
153 .speed = SPEED_25000,
154 .duplex = DUPLEX_FULL,
155 .bit = ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
160 .speed = SPEED_20000,
161 .duplex = DUPLEX_FULL,
162 .bit = ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT,
165 .speed = SPEED_20000,
166 .duplex = DUPLEX_FULL,
167 .bit = ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT,
171 .speed = SPEED_10000,
172 .duplex = DUPLEX_FULL,
173 .bit = ETHTOOL_LINK_MODE_10000baseCR_Full_BIT,
176 .speed = SPEED_10000,
177 .duplex = DUPLEX_FULL,
178 .bit = ETHTOOL_LINK_MODE_10000baseER_Full_BIT,
181 .speed = SPEED_10000,
182 .duplex = DUPLEX_FULL,
183 .bit = ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
186 .speed = SPEED_10000,
187 .duplex = DUPLEX_FULL,
188 .bit = ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
191 .speed = SPEED_10000,
192 .duplex = DUPLEX_FULL,
193 .bit = ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
196 .speed = SPEED_10000,
197 .duplex = DUPLEX_FULL,
198 .bit = ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT,
201 .speed = SPEED_10000,
202 .duplex = DUPLEX_FULL,
203 .bit = ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
206 .speed = SPEED_10000,
207 .duplex = DUPLEX_FULL,
208 .bit = ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
211 .speed = SPEED_10000,
212 .duplex = DUPLEX_FULL,
213 .bit = ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
218 .duplex = DUPLEX_FULL,
219 .bit = ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
225 .duplex = DUPLEX_FULL,
226 .bit = ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
230 .duplex = DUPLEX_FULL,
231 .bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
236 .duplex = DUPLEX_FULL,
237 .bit = ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
241 .duplex = DUPLEX_FULL,
242 .bit = ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
246 .duplex = DUPLEX_HALF,
247 .bit = ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
251 .duplex = DUPLEX_FULL,
252 .bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
257 .duplex = DUPLEX_FULL,
258 .bit = ETHTOOL_LINK_MODE_100baseT_Full_BIT,
262 .duplex = DUPLEX_HALF,
263 .bit = ETHTOOL_LINK_MODE_100baseT_Half_BIT,
268 .duplex = DUPLEX_FULL,
269 .bit = ETHTOOL_LINK_MODE_10baseT_Full_BIT,
273 .duplex = DUPLEX_HALF,
274 .bit = ETHTOOL_LINK_MODE_10baseT_Half_BIT,
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
285 * Search the settings array for a setting that matches the speed and
286 * duplex, and which is supported.
288 * If @exact is unset, either an exact match or %NULL for no match will
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.
295 const struct phy_setting *
296 phy_lookup_setting(int speed, int duplex, const unsigned long *mask, bool exact)
298 const struct phy_setting *p, *match = NULL, *last = NULL;
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)) {
305 if (p->speed == speed && p->duplex == duplex) {
306 /* Exact match for speed and duplex */
310 if (!match && p->speed <= speed)
314 if (p->speed < speed)
320 if (!match && !exact)
325 EXPORT_SYMBOL_GPL(phy_lookup_setting);
327 size_t phy_speeds(unsigned int *speeds, size_t size,
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;
342 static int __set_phy_supported(struct phy_device *phydev, u32 max_speed)
344 const struct phy_setting *p;
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);
357 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
361 err = __set_phy_supported(phydev, max_speed);
365 linkmode_copy(phydev->advertising, phydev->supported);
369 EXPORT_SYMBOL(phy_set_max_speed);
371 void of_set_phy_supported(struct phy_device *phydev)
373 struct device_node *node = phydev->mdio.dev.of_node;
376 if (!IS_ENABLED(CONFIG_OF_MDIO))
382 if (!of_property_read_u32(node, "max-speed", &max_speed))
383 __set_phy_supported(phydev, max_speed);
386 void of_set_phy_eee_broken(struct phy_device *phydev)
388 struct device_node *node = phydev->mdio.dev.of_node;
391 if (!IS_ENABLED(CONFIG_OF_MDIO))
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;
410 phydev->eee_broken_modes = broken;
414 * phy_resolve_aneg_linkmode - resolve the advertisements into phy settings
415 * @phydev: The phy_device struct
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.
421 void phy_resolve_aneg_linkmode(struct phy_device *phydev)
423 __ETHTOOL_DECLARE_LINK_MODE_MASK(common);
426 linkmode_and(common, phydev->lp_advertising, phydev->advertising);
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;
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);
443 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode);
445 static void mmd_phy_indirect(struct mii_bus *bus, int phy_addr, int devad,
448 /* Write the desired MMD Devad */
449 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL, devad);
451 /* Write the desired MMD register address */
452 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, regnum);
454 /* Select the Function : DATA with no post increment */
455 __mdiobus_write(bus, phy_addr, MII_MMD_CTRL,
456 devad | MII_MMD_CTRL_NOINCR);
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)
466 * Same rules as for __phy_read();
468 int __phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
472 if (regnum > (u16)~0 || devad > 32)
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);
480 val = __mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, addr);
482 struct mii_bus *bus = phydev->mdio.bus;
483 int phy_addr = phydev->mdio.addr;
485 mmd_phy_indirect(bus, phy_addr, devad, regnum);
487 /* Read the content of the MMD's selected register */
488 val = __mdiobus_read(bus, phy_addr, MII_MMD_DATA);
492 EXPORT_SYMBOL(__phy_read_mmd);
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
501 * Same rules as for phy_read();
503 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
507 mutex_lock(&phydev->mdio.bus->mdio_lock);
508 ret = __phy_read_mmd(phydev, devad, regnum);
509 mutex_unlock(&phydev->mdio.bus->mdio_lock);
513 EXPORT_SYMBOL(phy_read_mmd);
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
523 * Same rules as for __phy_write();
525 int __phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
529 if (regnum > (u16)~0 || devad > 32)
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);
537 ret = __mdiobus_write(phydev->mdio.bus, phydev->mdio.addr,
540 struct mii_bus *bus = phydev->mdio.bus;
541 int phy_addr = phydev->mdio.addr;
543 mmd_phy_indirect(bus, phy_addr, devad, regnum);
545 /* Write the data into MMD's selected register */
546 __mdiobus_write(bus, phy_addr, MII_MMD_DATA, val);
552 EXPORT_SYMBOL(__phy_write_mmd);
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
562 * Same rules as for phy_write();
564 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)
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);
574 EXPORT_SYMBOL(phy_write_mmd);
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
583 * Unlocked helper function which allows a PHY register to be modified as
584 * new register value = (old register value & ~mask) | set
586 * Returns negative errno, 0 if there was no change, and 1 in case of change
588 int __phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask,
593 ret = __phy_read(phydev, regnum);
597 new = (ret & ~mask) | set;
601 ret = __phy_write(phydev, regnum, new);
603 return ret < 0 ? ret : 1;
605 EXPORT_SYMBOL_GPL(__phy_modify_changed);
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
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.
618 * Returns negative errno, 0 if there was no change, and 1 in case of change
620 int phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
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);
630 EXPORT_SYMBOL_GPL(phy_modify_changed);
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
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.
643 int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
647 ret = __phy_modify_changed(phydev, regnum, mask, set);
649 return ret < 0 ? ret : 0;
651 EXPORT_SYMBOL_GPL(__phy_modify);
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
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.
664 int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)
668 mutex_lock(&phydev->mdio.bus->mdio_lock);
669 ret = __phy_modify(phydev, regnum, mask, set);
670 mutex_unlock(&phydev->mdio.bus->mdio_lock);
674 EXPORT_SYMBOL_GPL(phy_modify);
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
684 * Unlocked helper function which allows a MMD register to be modified as
685 * new register value = (old register value & ~mask) | set
687 * Returns negative errno, 0 if there was no change, and 1 in case of change
689 int __phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
694 ret = __phy_read_mmd(phydev, devad, regnum);
698 new = (ret & ~mask) | set;
702 ret = __phy_write_mmd(phydev, devad, regnum, new);
704 return ret < 0 ? ret : 1;
706 EXPORT_SYMBOL_GPL(__phy_modify_mmd_changed);
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
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.
720 * Returns negative errno, 0 if there was no change, and 1 in case of change
722 int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
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);
733 EXPORT_SYMBOL_GPL(phy_modify_mmd_changed);
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
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.
747 int __phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
752 ret = __phy_modify_mmd_changed(phydev, devad, regnum, mask, set);
754 return ret < 0 ? ret : 0;
756 EXPORT_SYMBOL_GPL(__phy_modify_mmd);
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
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.
770 int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
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);
781 EXPORT_SYMBOL_GPL(phy_modify_mmd);
783 static int __phy_read_page(struct phy_device *phydev)
785 return phydev->drv->read_page(phydev);
788 static int __phy_write_page(struct phy_device *phydev, int page)
790 return phydev->drv->write_page(phydev, page);
794 * phy_save_page() - take the bus lock and save the current page
795 * @phydev: a pointer to a &struct phy_device
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.
801 int phy_save_page(struct phy_device *phydev)
803 mutex_lock(&phydev->mdio.bus->mdio_lock);
804 return __phy_read_page(phydev);
806 EXPORT_SYMBOL_GPL(phy_save_page);
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
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.
819 int phy_select_page(struct phy_device *phydev, int page)
823 oldpage = ret = phy_save_page(phydev);
827 if (oldpage != page) {
828 ret = __phy_write_page(phydev, page);
835 EXPORT_SYMBOL_GPL(phy_select_page);
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
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
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
853 int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)
858 r = __phy_write_page(phydev, oldpage);
860 /* Propagate the operation return code if the page write
863 if (ret >= 0 && r < 0)
866 /* Propagate the phy page selection error code */
870 mutex_unlock(&phydev->mdio.bus->mdio_lock);
874 EXPORT_SYMBOL_GPL(phy_restore_page);
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
882 * Same rules as for phy_read().
884 int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)
886 int ret = 0, oldpage;
888 oldpage = phy_select_page(phydev, page);
890 ret = __phy_read(phydev, regnum);
892 return phy_restore_page(phydev, oldpage, ret);
894 EXPORT_SYMBOL(phy_read_paged);
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
903 * Same rules as for phy_write().
905 int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)
907 int ret = 0, oldpage;
909 oldpage = phy_select_page(phydev, page);
911 ret = __phy_write(phydev, regnum, val);
913 return phy_restore_page(phydev, oldpage, ret);
915 EXPORT_SYMBOL(phy_write_paged);
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
925 * Same rules as for phy_read() and phy_write().
927 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
930 int ret = 0, oldpage;
932 oldpage = phy_select_page(phydev, page);
934 ret = __phy_modify(phydev, regnum, mask, set);
936 return phy_restore_page(phydev, oldpage, ret);
938 EXPORT_SYMBOL(phy_modify_paged);