Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...

[drm/drm-misc.git] / drivers / net / phy / motorcomm.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Motorcomm 8511/8521/8531/8531S/8821 PHY driver.
 *
 * Author: Peter Geis <pgwipeout@gmail.com>
 * Author: Frank <Frank.Sae@motor-comm.com>
 */

#include <linux/etherdevice.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/phy.h>
#include <linux/of.h>

#define PHY_ID_YT8511           0x0000010a
#define PHY_ID_YT8521           0x0000011a
#define PHY_ID_YT8531           0x4f51e91b
#define PHY_ID_YT8531S          0x4f51e91a
#define PHY_ID_YT8821           0x4f51ea19
/* YT8521/YT8531S/YT8821 Register Overview
 *      UTP Register space      |       FIBER Register space
 *  ------------------------------------------------------------
 * |    UTP MII                 |       FIBER MII               |
 * |    UTP MMD                 |                               |
 * |    UTP Extended            |       FIBER Extended          |
 *  ------------------------------------------------------------
 * |                    Common Extended                         |
 *  ------------------------------------------------------------
 */

/* 0x10 ~ 0x15 , 0x1E and 0x1F are common MII registers of yt phy */

/* Specific Function Control Register */
#define YTPHY_SPECIFIC_FUNCTION_CONTROL_REG     0x10

/* 2b00 Manual MDI configuration
 * 2b01 Manual MDIX configuration
 * 2b10 Reserved
 * 2b11 Enable automatic crossover for all modes  *default*
 */
#define YTPHY_SFCR_MDI_CROSSOVER_MODE_MASK      (BIT(6) | BIT(5))
#define YTPHY_SFCR_CROSSOVER_EN                 BIT(3)
#define YTPHY_SFCR_SQE_TEST_EN                  BIT(2)
#define YTPHY_SFCR_POLARITY_REVERSAL_EN         BIT(1)
#define YTPHY_SFCR_JABBER_DIS                   BIT(0)

/* Specific Status Register */
#define YTPHY_SPECIFIC_STATUS_REG               0x11
#define YTPHY_SSR_SPEED_MASK                    ((0x3 << 14) | BIT(9))
#define YTPHY_SSR_SPEED_10M                     ((0x0 << 14))
#define YTPHY_SSR_SPEED_100M                    ((0x1 << 14))
#define YTPHY_SSR_SPEED_1000M                   ((0x2 << 14))
#define YTPHY_SSR_SPEED_10G                     ((0x3 << 14))
#define YTPHY_SSR_SPEED_2500M                   ((0x0 << 14) | BIT(9))
#define YTPHY_SSR_DUPLEX_OFFSET                 13
#define YTPHY_SSR_DUPLEX                        BIT(13)
#define YTPHY_SSR_PAGE_RECEIVED                 BIT(12)
#define YTPHY_SSR_SPEED_DUPLEX_RESOLVED         BIT(11)
#define YTPHY_SSR_LINK                          BIT(10)
#define YTPHY_SSR_MDIX_CROSSOVER                BIT(6)
#define YTPHY_SSR_DOWNGRADE                     BIT(5)
#define YTPHY_SSR_TRANSMIT_PAUSE                BIT(3)
#define YTPHY_SSR_RECEIVE_PAUSE                 BIT(2)
#define YTPHY_SSR_POLARITY                      BIT(1)
#define YTPHY_SSR_JABBER                        BIT(0)

/* Interrupt enable Register */
#define YTPHY_INTERRUPT_ENABLE_REG              0x12
#define YTPHY_IER_WOL                           BIT(6)

/* Interrupt Status Register */
#define YTPHY_INTERRUPT_STATUS_REG              0x13
#define YTPHY_ISR_AUTONEG_ERR                   BIT(15)
#define YTPHY_ISR_SPEED_CHANGED                 BIT(14)
#define YTPHY_ISR_DUPLEX_CHANGED                BIT(13)
#define YTPHY_ISR_PAGE_RECEIVED                 BIT(12)
#define YTPHY_ISR_LINK_FAILED                   BIT(11)
#define YTPHY_ISR_LINK_SUCCESSED                BIT(10)
#define YTPHY_ISR_WOL                           BIT(6)
#define YTPHY_ISR_WIRESPEED_DOWNGRADE           BIT(5)
#define YTPHY_ISR_SERDES_LINK_FAILED            BIT(3)
#define YTPHY_ISR_SERDES_LINK_SUCCESSED         BIT(2)
#define YTPHY_ISR_POLARITY_CHANGED              BIT(1)
#define YTPHY_ISR_JABBER_HAPPENED               BIT(0)

/* Speed Auto Downgrade Control Register */
#define YTPHY_SPEED_AUTO_DOWNGRADE_CONTROL_REG  0x14
#define YTPHY_SADCR_SPEED_DOWNGRADE_EN          BIT(5)

/* If these bits are set to 3, the PHY attempts five times ( 3(set value) +
 * additional 2) before downgrading, default 0x3
 */
#define YTPHY_SADCR_SPEED_RETRY_LIMIT           (0x3 << 2)

/* Rx Error Counter Register */
#define YTPHY_RX_ERROR_COUNTER_REG              0x15

/* Extended Register's Address Offset Register */
#define YTPHY_PAGE_SELECT                       0x1E

/* Extended Register's Data Register */
#define YTPHY_PAGE_DATA                         0x1F

/* FIBER Auto-Negotiation link partner ability */
#define YTPHY_FLPA_PAUSE                        (0x3 << 7)
#define YTPHY_FLPA_ASYM_PAUSE                   (0x2 << 7)

#define YT8511_PAGE_SELECT      0x1e
#define YT8511_PAGE             0x1f
#define YT8511_EXT_CLK_GATE     0x0c
#define YT8511_EXT_DELAY_DRIVE  0x0d
#define YT8511_EXT_SLEEP_CTRL   0x27

/* 2b00 25m from pll
 * 2b01 25m from xtl *default*
 * 2b10 62.m from pll
 * 2b11 125m from pll
 */
#define YT8511_CLK_125M         (BIT(2) | BIT(1))
#define YT8511_PLLON_SLP        BIT(14)

/* RX Delay enabled = 1.8ns 1000T, 8ns 10/100T */
#define YT8511_DELAY_RX         BIT(0)

/* TX Gig-E Delay is bits 7:4, default 0x5
 * TX Fast-E Delay is bits 15:12, default 0xf
 * Delay = 150ps * N - 250ps
 * On = 2000ps, off = 50ps
 */
#define YT8511_DELAY_GE_TX_EN   (0xf << 4)
#define YT8511_DELAY_GE_TX_DIS  (0x2 << 4)
#define YT8511_DELAY_FE_TX_EN   (0xf << 12)
#define YT8511_DELAY_FE_TX_DIS  (0x2 << 12)

/* Extended register is different from MMD Register and MII Register.
 * We can use ytphy_read_ext/ytphy_write_ext/ytphy_modify_ext function to
 * operate extended register.
 * Extended Register  start
 */

/* Phy gmii clock gating Register */
#define YT8521_CLOCK_GATING_REG                 0xC
#define YT8521_CGR_RX_CLK_EN                    BIT(12)

#define YT8521_EXTREG_SLEEP_CONTROL1_REG        0x27
#define YT8521_ESC1R_SLEEP_SW                   BIT(15)
#define YT8521_ESC1R_PLLON_SLP                  BIT(14)

/* Phy fiber Link timer cfg2 Register */
#define YT8521_LINK_TIMER_CFG2_REG              0xA5
#define YT8521_LTCR_EN_AUTOSEN                  BIT(15)

/* 0xA000, 0xA001, 0xA003, 0xA006 ~ 0xA00A and 0xA012 are common ext registers
 * of yt8521 phy. There is no need to switch reg space when operating these
 * registers.
 */

#define YT8521_REG_SPACE_SELECT_REG             0xA000
#define YT8521_RSSR_SPACE_MASK                  BIT(1)
#define YT8521_RSSR_FIBER_SPACE                 (0x1 << 1)
#define YT8521_RSSR_UTP_SPACE                   (0x0 << 1)
#define YT8521_RSSR_TO_BE_ARBITRATED            (0xFF)

#define YT8521_CHIP_CONFIG_REG                  0xA001
#define YT8521_CCR_SW_RST                       BIT(15)
#define YT8531_RGMII_LDO_VOL_MASK               GENMASK(5, 4)
#define YT8531_LDO_VOL_3V3                      0x0
#define YT8531_LDO_VOL_1V8                      0x2

/* 1b0 disable 1.9ns rxc clock delay  *default*
 * 1b1 enable 1.9ns rxc clock delay
 */
#define YT8521_CCR_RXC_DLY_EN                   BIT(8)
#define YT8521_CCR_RXC_DLY_1_900_NS             1900

#define YT8521_CCR_MODE_SEL_MASK                (BIT(2) | BIT(1) | BIT(0))
#define YT8521_CCR_MODE_UTP_TO_RGMII            0
#define YT8521_CCR_MODE_FIBER_TO_RGMII          1
#define YT8521_CCR_MODE_UTP_FIBER_TO_RGMII      2
#define YT8521_CCR_MODE_UTP_TO_SGMII            3
#define YT8521_CCR_MODE_SGPHY_TO_RGMAC          4
#define YT8521_CCR_MODE_SGMAC_TO_RGPHY          5
#define YT8521_CCR_MODE_UTP_TO_FIBER_AUTO       6
#define YT8521_CCR_MODE_UTP_TO_FIBER_FORCE      7

/* 3 phy polling modes,poll mode combines utp and fiber mode*/
#define YT8521_MODE_FIBER                       0x1
#define YT8521_MODE_UTP                         0x2
#define YT8521_MODE_POLL                        0x3

#define YT8521_RGMII_CONFIG1_REG                0xA003
/* 1b0 use original tx_clk_rgmii  *default*
 * 1b1 use inverted tx_clk_rgmii.
 */
#define YT8521_RC1R_TX_CLK_SEL_INVERTED         BIT(14)
#define YT8521_RC1R_RX_DELAY_MASK               GENMASK(13, 10)
#define YT8521_RC1R_FE_TX_DELAY_MASK            GENMASK(7, 4)
#define YT8521_RC1R_GE_TX_DELAY_MASK            GENMASK(3, 0)
#define YT8521_RC1R_RGMII_0_000_NS              0
#define YT8521_RC1R_RGMII_0_150_NS              1
#define YT8521_RC1R_RGMII_0_300_NS              2
#define YT8521_RC1R_RGMII_0_450_NS              3
#define YT8521_RC1R_RGMII_0_600_NS              4
#define YT8521_RC1R_RGMII_0_750_NS              5
#define YT8521_RC1R_RGMII_0_900_NS              6
#define YT8521_RC1R_RGMII_1_050_NS              7
#define YT8521_RC1R_RGMII_1_200_NS              8
#define YT8521_RC1R_RGMII_1_350_NS              9
#define YT8521_RC1R_RGMII_1_500_NS              10
#define YT8521_RC1R_RGMII_1_650_NS              11
#define YT8521_RC1R_RGMII_1_800_NS              12
#define YT8521_RC1R_RGMII_1_950_NS              13
#define YT8521_RC1R_RGMII_2_100_NS              14
#define YT8521_RC1R_RGMII_2_250_NS              15

#define YTPHY_MISC_CONFIG_REG                   0xA006
#define YTPHY_MCR_FIBER_SPEED_MASK              BIT(0)
#define YTPHY_MCR_FIBER_1000BX                  (0x1 << 0)
#define YTPHY_MCR_FIBER_100FX                   (0x0 << 0)

/* WOL MAC ADDR: MACADDR2(highest), MACADDR1(middle), MACADDR0(lowest) */
#define YTPHY_WOL_MACADDR2_REG                  0xA007
#define YTPHY_WOL_MACADDR1_REG                  0xA008
#define YTPHY_WOL_MACADDR0_REG                  0xA009

#define YTPHY_WOL_CONFIG_REG                    0xA00A
#define YTPHY_WCR_INTR_SEL                      BIT(6)
#define YTPHY_WCR_ENABLE                        BIT(3)

/* 2b00 84ms
 * 2b01 168ms  *default*
 * 2b10 336ms
 * 2b11 672ms
 */
#define YTPHY_WCR_PULSE_WIDTH_MASK              (BIT(2) | BIT(1))
#define YTPHY_WCR_PULSE_WIDTH_672MS             (BIT(2) | BIT(1))

/* 1b0 Interrupt and WOL events is level triggered and active LOW  *default*
 * 1b1 Interrupt and WOL events is pulse triggered and active LOW
 */
#define YTPHY_WCR_TYPE_PULSE                    BIT(0)

#define YTPHY_PAD_DRIVE_STRENGTH_REG            0xA010
#define YT8531_RGMII_RXC_DS_MASK                GENMASK(15, 13)
#define YT8531_RGMII_RXD_DS_HI_MASK             BIT(12)         /* Bit 2 of rxd_ds */
#define YT8531_RGMII_RXD_DS_LOW_MASK            GENMASK(5, 4)   /* Bit 1/0 of rxd_ds */
#define YT8531_RGMII_RX_DS_DEFAULT              0x3

#define YTPHY_SYNCE_CFG_REG                     0xA012
#define YT8521_SCR_SYNCE_ENABLE                 BIT(5)
/* 1b0 output 25m clock
 * 1b1 output 125m clock  *default*
 */
#define YT8521_SCR_CLK_FRE_SEL_125M             BIT(3)
#define YT8521_SCR_CLK_SRC_MASK                 GENMASK(2, 1)
#define YT8521_SCR_CLK_SRC_PLL_125M             0
#define YT8521_SCR_CLK_SRC_UTP_RX               1
#define YT8521_SCR_CLK_SRC_SDS_RX               2
#define YT8521_SCR_CLK_SRC_REF_25M              3
#define YT8531_SCR_SYNCE_ENABLE                 BIT(6)
/* 1b0 output 25m clock   *default*
 * 1b1 output 125m clock
 */
#define YT8531_SCR_CLK_FRE_SEL_125M             BIT(4)
#define YT8531_SCR_CLK_SRC_MASK                 GENMASK(3, 1)
#define YT8531_SCR_CLK_SRC_PLL_125M             0
#define YT8531_SCR_CLK_SRC_UTP_RX               1
#define YT8531_SCR_CLK_SRC_SDS_RX               2
#define YT8531_SCR_CLK_SRC_CLOCK_FROM_DIGITAL   3
#define YT8531_SCR_CLK_SRC_REF_25M              4
#define YT8531_SCR_CLK_SRC_SSC_25M              5

#define YT8821_SDS_EXT_CSR_CTRL_REG                     0x23
#define YT8821_SDS_EXT_CSR_VCO_LDO_EN                   BIT(15)
#define YT8821_SDS_EXT_CSR_VCO_BIAS_LPF_EN              BIT(8)

#define YT8821_UTP_EXT_PI_CTRL_REG                      0x56
#define YT8821_UTP_EXT_PI_RST_N_FIFO                    BIT(5)
#define YT8821_UTP_EXT_PI_TX_CLK_SEL_AFE                BIT(4)
#define YT8821_UTP_EXT_PI_RX_CLK_3_SEL_AFE              BIT(3)
#define YT8821_UTP_EXT_PI_RX_CLK_2_SEL_AFE              BIT(2)
#define YT8821_UTP_EXT_PI_RX_CLK_1_SEL_AFE              BIT(1)
#define YT8821_UTP_EXT_PI_RX_CLK_0_SEL_AFE              BIT(0)

#define YT8821_UTP_EXT_VCT_CFG6_CTRL_REG                0x97
#define YT8821_UTP_EXT_FECHO_AMP_TH_HUGE                GENMASK(15, 8)

#define YT8821_UTP_EXT_ECHO_CTRL_REG                    0x336
#define YT8821_UTP_EXT_TRACE_LNG_GAIN_THR_1000          GENMASK(14, 8)

#define YT8821_UTP_EXT_GAIN_CTRL_REG                    0x340
#define YT8821_UTP_EXT_TRACE_MED_GAIN_THR_1000          GENMASK(6, 0)

#define YT8821_UTP_EXT_RPDN_CTRL_REG                    0x34E
#define YT8821_UTP_EXT_RPDN_BP_FFE_LNG_2500             BIT(15)
#define YT8821_UTP_EXT_RPDN_BP_FFE_SHT_2500             BIT(7)
#define YT8821_UTP_EXT_RPDN_IPR_SHT_2500                GENMASK(6, 0)

#define YT8821_UTP_EXT_TH_20DB_2500_CTRL_REG            0x36A
#define YT8821_UTP_EXT_TH_20DB_2500                     GENMASK(15, 0)

#define YT8821_UTP_EXT_TRACE_CTRL_REG                   0x372
#define YT8821_UTP_EXT_TRACE_LNG_GAIN_THE_2500          GENMASK(14, 8)
#define YT8821_UTP_EXT_TRACE_MED_GAIN_THE_2500          GENMASK(6, 0)

#define YT8821_UTP_EXT_ALPHA_IPR_CTRL_REG               0x374
#define YT8821_UTP_EXT_ALPHA_SHT_2500                   GENMASK(14, 8)
#define YT8821_UTP_EXT_IPR_LNG_2500                     GENMASK(6, 0)

#define YT8821_UTP_EXT_PLL_CTRL_REG                     0x450
#define YT8821_UTP_EXT_PLL_SPARE_CFG                    GENMASK(7, 0)

#define YT8821_UTP_EXT_DAC_IMID_CH_2_3_CTRL_REG         0x466
#define YT8821_UTP_EXT_DAC_IMID_CH_3_10_ORG             GENMASK(14, 8)
#define YT8821_UTP_EXT_DAC_IMID_CH_2_10_ORG             GENMASK(6, 0)

#define YT8821_UTP_EXT_DAC_IMID_CH_0_1_CTRL_REG         0x467
#define YT8821_UTP_EXT_DAC_IMID_CH_1_10_ORG             GENMASK(14, 8)
#define YT8821_UTP_EXT_DAC_IMID_CH_0_10_ORG             GENMASK(6, 0)

#define YT8821_UTP_EXT_DAC_IMSB_CH_2_3_CTRL_REG         0x468
#define YT8821_UTP_EXT_DAC_IMSB_CH_3_10_ORG             GENMASK(14, 8)
#define YT8821_UTP_EXT_DAC_IMSB_CH_2_10_ORG             GENMASK(6, 0)

#define YT8821_UTP_EXT_DAC_IMSB_CH_0_1_CTRL_REG         0x469
#define YT8821_UTP_EXT_DAC_IMSB_CH_1_10_ORG             GENMASK(14, 8)
#define YT8821_UTP_EXT_DAC_IMSB_CH_0_10_ORG             GENMASK(6, 0)

#define YT8821_UTP_EXT_MU_COARSE_FR_CTRL_REG            0x4B3
#define YT8821_UTP_EXT_MU_COARSE_FR_F_FFE               GENMASK(14, 12)
#define YT8821_UTP_EXT_MU_COARSE_FR_F_FBE               GENMASK(10, 8)

#define YT8821_UTP_EXT_MU_FINE_FR_CTRL_REG              0x4B5
#define YT8821_UTP_EXT_MU_FINE_FR_F_FFE                 GENMASK(14, 12)
#define YT8821_UTP_EXT_MU_FINE_FR_F_FBE                 GENMASK(10, 8)

#define YT8821_UTP_EXT_VGA_LPF1_CAP_CTRL_REG            0x4D2
#define YT8821_UTP_EXT_VGA_LPF1_CAP_OTHER               GENMASK(7, 4)
#define YT8821_UTP_EXT_VGA_LPF1_CAP_2500                GENMASK(3, 0)

#define YT8821_UTP_EXT_VGA_LPF2_CAP_CTRL_REG            0x4D3
#define YT8821_UTP_EXT_VGA_LPF2_CAP_OTHER               GENMASK(7, 4)
#define YT8821_UTP_EXT_VGA_LPF2_CAP_2500                GENMASK(3, 0)

#define YT8821_UTP_EXT_TXGE_NFR_FR_THP_CTRL_REG         0x660
#define YT8821_UTP_EXT_NFR_TX_ABILITY                   BIT(3)
/* Extended Register  end */

#define YTPHY_DTS_OUTPUT_CLK_DIS                0
#define YTPHY_DTS_OUTPUT_CLK_25M                25000000
#define YTPHY_DTS_OUTPUT_CLK_125M               125000000

#define YT8821_CHIP_MODE_AUTO_BX2500_SGMII      0
#define YT8821_CHIP_MODE_FORCE_BX2500           1

struct yt8521_priv {
        /* combo_advertising is used for case of YT8521 in combo mode,
         * this means that yt8521 may work in utp or fiber mode which depends
         * on which media is connected (YT8521_RSSR_TO_BE_ARBITRATED).
         */
        __ETHTOOL_DECLARE_LINK_MODE_MASK(combo_advertising);

        /* YT8521_MODE_FIBER / YT8521_MODE_UTP / YT8521_MODE_POLL*/
        u8 polling_mode;
        u8 strap_mode; /* 8 working modes  */
        /* current reg page of yt8521 phy:
         * YT8521_RSSR_UTP_SPACE
         * YT8521_RSSR_FIBER_SPACE
         * YT8521_RSSR_TO_BE_ARBITRATED
         */
        u8 reg_page;
};

/**
 * ytphy_read_ext() - read a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to read
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns the value of regnum reg or negative error code
 */
static int ytphy_read_ext(struct phy_device *phydev, u16 regnum)
{
        int ret;

        ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
        if (ret < 0)
                return ret;

        return __phy_read(phydev, YTPHY_PAGE_DATA);
}

/**
 * ytphy_read_ext_with_lock() - read a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to read
 *
 * returns the value of regnum reg or negative error code
 */
static int ytphy_read_ext_with_lock(struct phy_device *phydev, u16 regnum)
{
        int ret;

        phy_lock_mdio_bus(phydev);
        ret = ytphy_read_ext(phydev, regnum);
        phy_unlock_mdio_bus(phydev);

        return ret;
}

/**
 * ytphy_write_ext() - write a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative error code
 */
static int ytphy_write_ext(struct phy_device *phydev, u16 regnum, u16 val)
{
        int ret;

        ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
        if (ret < 0)
                return ret;

        return __phy_write(phydev, YTPHY_PAGE_DATA, val);
}

/**
 * ytphy_write_ext_with_lock() - write a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * returns 0 or negative error code
 */
static int ytphy_write_ext_with_lock(struct phy_device *phydev, u16 regnum,
                                     u16 val)
{
        int ret;

        phy_lock_mdio_bus(phydev);
        ret = ytphy_write_ext(phydev, regnum, val);
        phy_unlock_mdio_bus(phydev);

        return ret;
}

/**
 * ytphy_modify_ext() - bits modify a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to write
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * NOTE: Convenience function which allows a PHY's extended register to be
 * modified as new register value = (old register value & ~mask) | set.
 * The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative error code
 */
static int ytphy_modify_ext(struct phy_device *phydev, u16 regnum, u16 mask,
                            u16 set)
{
        int ret;

        ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
        if (ret < 0)
                return ret;

        return __phy_modify(phydev, YTPHY_PAGE_DATA, mask, set);
}

/**
 * ytphy_modify_ext_with_lock() - bits modify a PHY's extended register
 * @phydev: a pointer to a &struct phy_device
 * @regnum: register number to write
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * NOTE: Convenience function which allows a PHY's extended register to be
 * modified as new register value = (old register value & ~mask) | set.
 *
 * returns 0 or negative error code
 */
static int ytphy_modify_ext_with_lock(struct phy_device *phydev, u16 regnum,
                                      u16 mask, u16 set)
{
        int ret;

        phy_lock_mdio_bus(phydev);
        ret = ytphy_modify_ext(phydev, regnum, mask, set);
        phy_unlock_mdio_bus(phydev);

        return ret;
}

/**
 * ytphy_get_wol() - report whether wake-on-lan is enabled
 * @phydev: a pointer to a &struct phy_device
 * @wol: a pointer to a &struct ethtool_wolinfo
 *
 * NOTE: YTPHY_WOL_CONFIG_REG is common ext reg.
 */
static void ytphy_get_wol(struct phy_device *phydev,
                          struct ethtool_wolinfo *wol)
{
        int wol_config;

        wol->supported = WAKE_MAGIC;
        wol->wolopts = 0;

        wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
        if (wol_config < 0)
                return;

        if (wol_config & YTPHY_WCR_ENABLE)
                wol->wolopts |= WAKE_MAGIC;
}

/**
 * ytphy_set_wol() - turn wake-on-lan on or off
 * @phydev: a pointer to a &struct phy_device
 * @wol: a pointer to a &struct ethtool_wolinfo
 *
 * NOTE: YTPHY_WOL_CONFIG_REG, YTPHY_WOL_MACADDR2_REG, YTPHY_WOL_MACADDR1_REG
 * and YTPHY_WOL_MACADDR0_REG are common ext reg. The
 * YTPHY_INTERRUPT_ENABLE_REG of UTP is special, fiber also use this register.
 *
 * returns 0 or negative errno code
 */
static int ytphy_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
{
        struct net_device *p_attached_dev;
        const u16 mac_addr_reg[] = {
                YTPHY_WOL_MACADDR2_REG,
                YTPHY_WOL_MACADDR1_REG,
                YTPHY_WOL_MACADDR0_REG,
        };
        const u8 *mac_addr;
        int old_page;
        int ret = 0;
        u16 mask;
        u16 val;
        u8 i;

        if (wol->wolopts & WAKE_MAGIC) {
                p_attached_dev = phydev->attached_dev;
                if (!p_attached_dev)
                        return -ENODEV;

                mac_addr = (const u8 *)p_attached_dev->dev_addr;
                if (!is_valid_ether_addr(mac_addr))
                        return -EINVAL;

                /* lock mdio bus then switch to utp reg space */
                old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
                if (old_page < 0)
                        goto err_restore_page;

                /* Store the device address for the magic packet */
                for (i = 0; i < 3; i++) {
                        ret = ytphy_write_ext(phydev, mac_addr_reg[i],
                                              ((mac_addr[i * 2] << 8)) |
                                                      (mac_addr[i * 2 + 1]));
                        if (ret < 0)
                                goto err_restore_page;
                }

                /* Enable WOL feature */
                mask = YTPHY_WCR_PULSE_WIDTH_MASK | YTPHY_WCR_INTR_SEL;
                val = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
                val |= YTPHY_WCR_TYPE_PULSE | YTPHY_WCR_PULSE_WIDTH_672MS;
                ret = ytphy_modify_ext(phydev, YTPHY_WOL_CONFIG_REG, mask, val);
                if (ret < 0)
                        goto err_restore_page;

                /* Enable WOL interrupt */
                ret = __phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG, 0,
                                   YTPHY_IER_WOL);
                if (ret < 0)
                        goto err_restore_page;

        } else {
                old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
                if (old_page < 0)
                        goto err_restore_page;

                /* Disable WOL feature */
                mask = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
                ret = ytphy_modify_ext(phydev, YTPHY_WOL_CONFIG_REG, mask, 0);

                /* Disable WOL interrupt */
                ret = __phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG,
                                   YTPHY_IER_WOL, 0);
                if (ret < 0)
                        goto err_restore_page;
        }

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

static int yt8531_set_wol(struct phy_device *phydev,
                          struct ethtool_wolinfo *wol)
{
        const u16 mac_addr_reg[] = {
                YTPHY_WOL_MACADDR2_REG,
                YTPHY_WOL_MACADDR1_REG,
                YTPHY_WOL_MACADDR0_REG,
        };
        const u8 *mac_addr;
        u16 mask, val;
        int ret;
        u8 i;

        if (wol->wolopts & WAKE_MAGIC) {
                mac_addr = phydev->attached_dev->dev_addr;

                /* Store the device address for the magic packet */
                for (i = 0; i < 3; i++) {
                        ret = ytphy_write_ext_with_lock(phydev, mac_addr_reg[i],
                                                        ((mac_addr[i * 2] << 8)) |
                                                        (mac_addr[i * 2 + 1]));
                        if (ret < 0)
                                return ret;
                }

                /* Enable WOL feature */
                mask = YTPHY_WCR_PULSE_WIDTH_MASK | YTPHY_WCR_INTR_SEL;
                val = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
                val |= YTPHY_WCR_TYPE_PULSE | YTPHY_WCR_PULSE_WIDTH_672MS;
                ret = ytphy_modify_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG,
                                                 mask, val);
                if (ret < 0)
                        return ret;

                /* Enable WOL interrupt */
                ret = phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG, 0,
                                 YTPHY_IER_WOL);
                if (ret < 0)
                        return ret;
        } else {
                /* Disable WOL feature */
                mask = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
                ret = ytphy_modify_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG,
                                                 mask, 0);

                /* Disable WOL interrupt */
                ret = phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG,
                                 YTPHY_IER_WOL, 0);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

static int yt8511_read_page(struct phy_device *phydev)
{
        return __phy_read(phydev, YT8511_PAGE_SELECT);
};

static int yt8511_write_page(struct phy_device *phydev, int page)
{
        return __phy_write(phydev, YT8511_PAGE_SELECT, page);
};

static int yt8511_config_init(struct phy_device *phydev)
{
        int oldpage, ret = 0;
        unsigned int ge, fe;

        oldpage = phy_select_page(phydev, YT8511_EXT_CLK_GATE);
        if (oldpage < 0)
                goto err_restore_page;

        /* set rgmii delay mode */
        switch (phydev->interface) {
        case PHY_INTERFACE_MODE_RGMII:
                ge = YT8511_DELAY_GE_TX_DIS;
                fe = YT8511_DELAY_FE_TX_DIS;
                break;
        case PHY_INTERFACE_MODE_RGMII_RXID:
                ge = YT8511_DELAY_RX | YT8511_DELAY_GE_TX_DIS;
                fe = YT8511_DELAY_FE_TX_DIS;
                break;
        case PHY_INTERFACE_MODE_RGMII_TXID:
                ge = YT8511_DELAY_GE_TX_EN;
                fe = YT8511_DELAY_FE_TX_EN;
                break;
        case PHY_INTERFACE_MODE_RGMII_ID:
                ge = YT8511_DELAY_RX | YT8511_DELAY_GE_TX_EN;
                fe = YT8511_DELAY_FE_TX_EN;
                break;
        default: /* do not support other modes */
                ret = -EOPNOTSUPP;
                goto err_restore_page;
        }

        ret = __phy_modify(phydev, YT8511_PAGE, (YT8511_DELAY_RX | YT8511_DELAY_GE_TX_EN), ge);
        if (ret < 0)
                goto err_restore_page;

        /* set clock mode to 125mhz */
        ret = __phy_modify(phydev, YT8511_PAGE, 0, YT8511_CLK_125M);
        if (ret < 0)
                goto err_restore_page;

        /* fast ethernet delay is in a separate page */
        ret = __phy_write(phydev, YT8511_PAGE_SELECT, YT8511_EXT_DELAY_DRIVE);
        if (ret < 0)
                goto err_restore_page;

        ret = __phy_modify(phydev, YT8511_PAGE, YT8511_DELAY_FE_TX_EN, fe);
        if (ret < 0)
                goto err_restore_page;

        /* leave pll enabled in sleep */
        ret = __phy_write(phydev, YT8511_PAGE_SELECT, YT8511_EXT_SLEEP_CTRL);
        if (ret < 0)
                goto err_restore_page;

        ret = __phy_modify(phydev, YT8511_PAGE, 0, YT8511_PLLON_SLP);
        if (ret < 0)
                goto err_restore_page;

err_restore_page:
        return phy_restore_page(phydev, oldpage, ret);
}

/**
 * yt8521_read_page() - read reg page
 * @phydev: a pointer to a &struct phy_device
 *
 * returns current reg space of yt8521 (YT8521_RSSR_FIBER_SPACE/
 * YT8521_RSSR_UTP_SPACE) or negative errno code
 */
static int yt8521_read_page(struct phy_device *phydev)
{
        int old_page;

        old_page = ytphy_read_ext(phydev, YT8521_REG_SPACE_SELECT_REG);
        if (old_page < 0)
                return old_page;

        if ((old_page & YT8521_RSSR_SPACE_MASK) == YT8521_RSSR_FIBER_SPACE)
                return YT8521_RSSR_FIBER_SPACE;

        return YT8521_RSSR_UTP_SPACE;
};

/**
 * yt8521_write_page() - write reg page
 * @phydev: a pointer to a &struct phy_device
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to write.
 *
 * returns 0 or negative errno code
 */
static int yt8521_write_page(struct phy_device *phydev, int page)
{
        int mask = YT8521_RSSR_SPACE_MASK;
        int set;

        if ((page & YT8521_RSSR_SPACE_MASK) == YT8521_RSSR_FIBER_SPACE)
                set = YT8521_RSSR_FIBER_SPACE;
        else
                set = YT8521_RSSR_UTP_SPACE;

        return ytphy_modify_ext(phydev, YT8521_REG_SPACE_SELECT_REG, mask, set);
};

/**
 * struct ytphy_cfg_reg_map - map a config value to a register value
 * @cfg: value in device configuration
 * @reg: value in the register
 */
struct ytphy_cfg_reg_map {
        u32 cfg;
        u32 reg;
};

static const struct ytphy_cfg_reg_map ytphy_rgmii_delays[] = {
        /* for tx delay / rx delay with YT8521_CCR_RXC_DLY_EN is not set. */
        { 0,    YT8521_RC1R_RGMII_0_000_NS },
        { 150,  YT8521_RC1R_RGMII_0_150_NS },
        { 300,  YT8521_RC1R_RGMII_0_300_NS },
        { 450,  YT8521_RC1R_RGMII_0_450_NS },
        { 600,  YT8521_RC1R_RGMII_0_600_NS },
        { 750,  YT8521_RC1R_RGMII_0_750_NS },
        { 900,  YT8521_RC1R_RGMII_0_900_NS },
        { 1050, YT8521_RC1R_RGMII_1_050_NS },
        { 1200, YT8521_RC1R_RGMII_1_200_NS },
        { 1350, YT8521_RC1R_RGMII_1_350_NS },
        { 1500, YT8521_RC1R_RGMII_1_500_NS },
        { 1650, YT8521_RC1R_RGMII_1_650_NS },
        { 1800, YT8521_RC1R_RGMII_1_800_NS },
        { 1950, YT8521_RC1R_RGMII_1_950_NS },   /* default tx/rx delay */
        { 2100, YT8521_RC1R_RGMII_2_100_NS },
        { 2250, YT8521_RC1R_RGMII_2_250_NS },

        /* only for rx delay with YT8521_CCR_RXC_DLY_EN is set. */
        { 0    + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_000_NS },
        { 150  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_150_NS },
        { 300  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_300_NS },
        { 450  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_450_NS },
        { 600  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_600_NS },
        { 750  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_750_NS },
        { 900  + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_0_900_NS },
        { 1050 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_050_NS },
        { 1200 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_200_NS },
        { 1350 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_350_NS },
        { 1500 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_500_NS },
        { 1650 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_650_NS },
        { 1800 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_800_NS },
        { 1950 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_1_950_NS },
        { 2100 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_2_100_NS },
        { 2250 + YT8521_CCR_RXC_DLY_1_900_NS,   YT8521_RC1R_RGMII_2_250_NS }
};

static u32 ytphy_get_delay_reg_value(struct phy_device *phydev,
                                     const char *prop_name,
                                     const struct ytphy_cfg_reg_map *tbl,
                                     int tb_size,
                                     u16 *rxc_dly_en,
                                     u32 dflt)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        int tb_size_half = tb_size / 2;
        u32 val;
        int i;

        if (of_property_read_u32(node, prop_name, &val))
                goto err_dts_val;

        /* when rxc_dly_en is NULL, it is get the delay for tx, only half of
         * tb_size is valid.
         */
        if (!rxc_dly_en)
                tb_size = tb_size_half;

        for (i = 0; i < tb_size; i++) {
                if (tbl[i].cfg == val) {
                        if (rxc_dly_en && i < tb_size_half)
                                *rxc_dly_en = 0;
                        return tbl[i].reg;
                }
        }

        phydev_warn(phydev, "Unsupported value %d for %s using default (%u)\n",
                    val, prop_name, dflt);

err_dts_val:
        /* when rxc_dly_en is not NULL, it is get the delay for rx.
         * The rx default in dts and ytphy_rgmii_clk_delay_config is 1950 ps,
         * so YT8521_CCR_RXC_DLY_EN should not be set.
         */
        if (rxc_dly_en)
                *rxc_dly_en = 0;

        return dflt;
}

static int ytphy_rgmii_clk_delay_config(struct phy_device *phydev)
{
        int tb_size = ARRAY_SIZE(ytphy_rgmii_delays);
        u16 rxc_dly_en = YT8521_CCR_RXC_DLY_EN;
        u32 rx_reg, tx_reg;
        u16 mask, val = 0;
        int ret;

        rx_reg = ytphy_get_delay_reg_value(phydev, "rx-internal-delay-ps",
                                           ytphy_rgmii_delays, tb_size,
                                           &rxc_dly_en,
                                           YT8521_RC1R_RGMII_1_950_NS);
        tx_reg = ytphy_get_delay_reg_value(phydev, "tx-internal-delay-ps",
                                           ytphy_rgmii_delays, tb_size, NULL,
                                           YT8521_RC1R_RGMII_1_950_NS);

        switch (phydev->interface) {
        case PHY_INTERFACE_MODE_RGMII:
                rxc_dly_en = 0;
                break;
        case PHY_INTERFACE_MODE_RGMII_RXID:
                val |= FIELD_PREP(YT8521_RC1R_RX_DELAY_MASK, rx_reg);
                break;
        case PHY_INTERFACE_MODE_RGMII_TXID:
                rxc_dly_en = 0;
                val |= FIELD_PREP(YT8521_RC1R_GE_TX_DELAY_MASK, tx_reg);
                break;
        case PHY_INTERFACE_MODE_RGMII_ID:
                val |= FIELD_PREP(YT8521_RC1R_RX_DELAY_MASK, rx_reg) |
                       FIELD_PREP(YT8521_RC1R_GE_TX_DELAY_MASK, tx_reg);
                break;
        default: /* do not support other modes */
                return -EOPNOTSUPP;
        }

        ret = ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
                               YT8521_CCR_RXC_DLY_EN, rxc_dly_en);
        if (ret < 0)
                return ret;

        /* Generally, it is not necessary to adjust YT8521_RC1R_FE_TX_DELAY */
        mask = YT8521_RC1R_RX_DELAY_MASK | YT8521_RC1R_GE_TX_DELAY_MASK;
        return ytphy_modify_ext(phydev, YT8521_RGMII_CONFIG1_REG, mask, val);
}

static int ytphy_rgmii_clk_delay_config_with_lock(struct phy_device *phydev)
{
        int ret;

        phy_lock_mdio_bus(phydev);
        ret = ytphy_rgmii_clk_delay_config(phydev);
        phy_unlock_mdio_bus(phydev);

        return ret;
}

/**
 * struct ytphy_ldo_vol_map - map a current value to a register value
 * @vol: ldo voltage
 * @ds:  value in the register
 * @cur: value in device configuration
 */
struct ytphy_ldo_vol_map {
        u32 vol;
        u32 ds;
        u32 cur;
};

static const struct ytphy_ldo_vol_map yt8531_ldo_vol[] = {
        {.vol = YT8531_LDO_VOL_1V8, .ds = 0, .cur = 1200},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 1, .cur = 2100},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 2, .cur = 2700},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 3, .cur = 2910},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 4, .cur = 3110},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 5, .cur = 3600},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 6, .cur = 3970},
        {.vol = YT8531_LDO_VOL_1V8, .ds = 7, .cur = 4350},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 0, .cur = 3070},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 1, .cur = 4080},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 2, .cur = 4370},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 3, .cur = 4680},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 4, .cur = 5020},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 5, .cur = 5450},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 6, .cur = 5740},
        {.vol = YT8531_LDO_VOL_3V3, .ds = 7, .cur = 6140},
};

static u32 yt8531_get_ldo_vol(struct phy_device *phydev)
{
        u32 val;

        val = ytphy_read_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG);
        val = FIELD_GET(YT8531_RGMII_LDO_VOL_MASK, val);

        return val <= YT8531_LDO_VOL_1V8 ? val : YT8531_LDO_VOL_1V8;
}

static int yt8531_get_ds_map(struct phy_device *phydev, u32 cur)
{
        u32 vol;
        int i;

        vol = yt8531_get_ldo_vol(phydev);
        for (i = 0; i < ARRAY_SIZE(yt8531_ldo_vol); i++) {
                if (yt8531_ldo_vol[i].vol == vol && yt8531_ldo_vol[i].cur == cur)
                        return yt8531_ldo_vol[i].ds;
        }

        return -EINVAL;
}

static int yt8531_set_ds(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        u32 ds_field_low, ds_field_hi, val;
        int ret, ds;

        /* set rgmii rx clk driver strength */
        if (!of_property_read_u32(node, "motorcomm,rx-clk-drv-microamp", &val)) {
                ds = yt8531_get_ds_map(phydev, val);
                if (ds < 0)
                        return dev_err_probe(&phydev->mdio.dev, ds,
                                             "No matching current value was found.\n");
        } else {
                ds = YT8531_RGMII_RX_DS_DEFAULT;
        }

        ret = ytphy_modify_ext_with_lock(phydev,
                                         YTPHY_PAD_DRIVE_STRENGTH_REG,
                                         YT8531_RGMII_RXC_DS_MASK,
                                         FIELD_PREP(YT8531_RGMII_RXC_DS_MASK, ds));
        if (ret < 0)
                return ret;

        /* set rgmii rx data driver strength */
        if (!of_property_read_u32(node, "motorcomm,rx-data-drv-microamp", &val)) {
                ds = yt8531_get_ds_map(phydev, val);
                if (ds < 0)
                        return dev_err_probe(&phydev->mdio.dev, ds,
                                             "No matching current value was found.\n");
        } else {
                ds = YT8531_RGMII_RX_DS_DEFAULT;
        }

        ds_field_hi = FIELD_GET(BIT(2), ds);
        ds_field_hi = FIELD_PREP(YT8531_RGMII_RXD_DS_HI_MASK, ds_field_hi);

        ds_field_low = FIELD_GET(GENMASK(1, 0), ds);
        ds_field_low = FIELD_PREP(YT8531_RGMII_RXD_DS_LOW_MASK, ds_field_low);

        ret = ytphy_modify_ext_with_lock(phydev,
                                         YTPHY_PAD_DRIVE_STRENGTH_REG,
                                         YT8531_RGMII_RXD_DS_LOW_MASK | YT8531_RGMII_RXD_DS_HI_MASK,
                                         ds_field_low | ds_field_hi);
        if (ret < 0)
                return ret;

        return 0;
}

/**
 * yt8521_probe() - read chip config then set suitable polling_mode
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_probe(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        struct device *dev = &phydev->mdio.dev;
        struct yt8521_priv *priv;
        int chip_config;
        u16 mask, val;
        u32 freq;
        int ret;

        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;

        phydev->priv = priv;

        chip_config = ytphy_read_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG);
        if (chip_config < 0)
                return chip_config;

        priv->strap_mode = chip_config & YT8521_CCR_MODE_SEL_MASK;
        switch (priv->strap_mode) {
        case YT8521_CCR_MODE_FIBER_TO_RGMII:
        case YT8521_CCR_MODE_SGPHY_TO_RGMAC:
        case YT8521_CCR_MODE_SGMAC_TO_RGPHY:
                priv->polling_mode = YT8521_MODE_FIBER;
                priv->reg_page = YT8521_RSSR_FIBER_SPACE;
                phydev->port = PORT_FIBRE;
                break;
        case YT8521_CCR_MODE_UTP_FIBER_TO_RGMII:
        case YT8521_CCR_MODE_UTP_TO_FIBER_AUTO:
        case YT8521_CCR_MODE_UTP_TO_FIBER_FORCE:
                priv->polling_mode = YT8521_MODE_POLL;
                priv->reg_page = YT8521_RSSR_TO_BE_ARBITRATED;
                phydev->port = PORT_NONE;
                break;
        case YT8521_CCR_MODE_UTP_TO_SGMII:
        case YT8521_CCR_MODE_UTP_TO_RGMII:
                priv->polling_mode = YT8521_MODE_UTP;
                priv->reg_page = YT8521_RSSR_UTP_SPACE;
                phydev->port = PORT_TP;
                break;
        }
        /* set default reg space */
        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                ret = ytphy_write_ext_with_lock(phydev,
                                                YT8521_REG_SPACE_SELECT_REG,
                                                priv->reg_page);
                if (ret < 0)
                        return ret;
        }

        if (of_property_read_u32(node, "motorcomm,clk-out-frequency-hz", &freq))
                freq = YTPHY_DTS_OUTPUT_CLK_DIS;

        if (phydev->drv->phy_id == PHY_ID_YT8521) {
                switch (freq) {
                case YTPHY_DTS_OUTPUT_CLK_DIS:
                        mask = YT8521_SCR_SYNCE_ENABLE;
                        val = 0;
                        break;
                case YTPHY_DTS_OUTPUT_CLK_25M:
                        mask = YT8521_SCR_SYNCE_ENABLE |
                               YT8521_SCR_CLK_SRC_MASK |
                               YT8521_SCR_CLK_FRE_SEL_125M;
                        val = YT8521_SCR_SYNCE_ENABLE |
                              FIELD_PREP(YT8521_SCR_CLK_SRC_MASK,
                                         YT8521_SCR_CLK_SRC_REF_25M);
                        break;
                case YTPHY_DTS_OUTPUT_CLK_125M:
                        mask = YT8521_SCR_SYNCE_ENABLE |
                               YT8521_SCR_CLK_SRC_MASK |
                               YT8521_SCR_CLK_FRE_SEL_125M;
                        val = YT8521_SCR_SYNCE_ENABLE |
                              YT8521_SCR_CLK_FRE_SEL_125M |
                              FIELD_PREP(YT8521_SCR_CLK_SRC_MASK,
                                         YT8521_SCR_CLK_SRC_PLL_125M);
                        break;
                default:
                        phydev_warn(phydev, "Freq err:%u\n", freq);
                        return -EINVAL;
                }
        } else if (phydev->drv->phy_id == PHY_ID_YT8531S) {
                switch (freq) {
                case YTPHY_DTS_OUTPUT_CLK_DIS:
                        mask = YT8531_SCR_SYNCE_ENABLE;
                        val = 0;
                        break;
                case YTPHY_DTS_OUTPUT_CLK_25M:
                        mask = YT8531_SCR_SYNCE_ENABLE |
                               YT8531_SCR_CLK_SRC_MASK |
                               YT8531_SCR_CLK_FRE_SEL_125M;
                        val = YT8531_SCR_SYNCE_ENABLE |
                              FIELD_PREP(YT8531_SCR_CLK_SRC_MASK,
                                         YT8531_SCR_CLK_SRC_REF_25M);
                        break;
                case YTPHY_DTS_OUTPUT_CLK_125M:
                        mask = YT8531_SCR_SYNCE_ENABLE |
                               YT8531_SCR_CLK_SRC_MASK |
                               YT8531_SCR_CLK_FRE_SEL_125M;
                        val = YT8531_SCR_SYNCE_ENABLE |
                              YT8531_SCR_CLK_FRE_SEL_125M |
                              FIELD_PREP(YT8531_SCR_CLK_SRC_MASK,
                                         YT8531_SCR_CLK_SRC_PLL_125M);
                        break;
                default:
                        phydev_warn(phydev, "Freq err:%u\n", freq);
                        return -EINVAL;
                }
        } else {
                phydev_warn(phydev, "PHY id err\n");
                return -EINVAL;
        }

        return ytphy_modify_ext_with_lock(phydev, YTPHY_SYNCE_CFG_REG, mask,
                                          val);
}

static int yt8531_probe(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        u16 mask, val;
        u32 freq;

        if (of_property_read_u32(node, "motorcomm,clk-out-frequency-hz", &freq))
                freq = YTPHY_DTS_OUTPUT_CLK_DIS;

        switch (freq) {
        case YTPHY_DTS_OUTPUT_CLK_DIS:
                mask = YT8531_SCR_SYNCE_ENABLE;
                val = 0;
                break;
        case YTPHY_DTS_OUTPUT_CLK_25M:
                mask = YT8531_SCR_SYNCE_ENABLE | YT8531_SCR_CLK_SRC_MASK |
                       YT8531_SCR_CLK_FRE_SEL_125M;
                val = YT8531_SCR_SYNCE_ENABLE |
                      FIELD_PREP(YT8531_SCR_CLK_SRC_MASK,
                                 YT8531_SCR_CLK_SRC_REF_25M);
                break;
        case YTPHY_DTS_OUTPUT_CLK_125M:
                mask = YT8531_SCR_SYNCE_ENABLE | YT8531_SCR_CLK_SRC_MASK |
                       YT8531_SCR_CLK_FRE_SEL_125M;
                val = YT8531_SCR_SYNCE_ENABLE | YT8531_SCR_CLK_FRE_SEL_125M |
                      FIELD_PREP(YT8531_SCR_CLK_SRC_MASK,
                                 YT8531_SCR_CLK_SRC_PLL_125M);
                break;
        default:
                phydev_warn(phydev, "Freq err:%u\n", freq);
                return -EINVAL;
        }

        return ytphy_modify_ext_with_lock(phydev, YTPHY_SYNCE_CFG_REG, mask,
                                          val);
}

/**
 * ytphy_utp_read_lpa() - read LPA then setup lp_advertising for utp
 * @phydev: a pointer to a &struct phy_device
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_utp_read_lpa(struct phy_device *phydev)
{
        int lpa, lpagb;

        if (phydev->autoneg == AUTONEG_ENABLE) {
                if (!phydev->autoneg_complete) {
                        mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
                                                        0);
                        mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
                        return 0;
                }

                if (phydev->is_gigabit_capable) {
                        lpagb = __phy_read(phydev, MII_STAT1000);
                        if (lpagb < 0)
                                return lpagb;

                        if (lpagb & LPA_1000MSFAIL) {
                                int adv = __phy_read(phydev, MII_CTRL1000);

                                if (adv < 0)
                                        return adv;

                                if (adv & CTL1000_ENABLE_MASTER)
                                        phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
                                else
                                        phydev_err(phydev, "Master/Slave resolution failed\n");
                                return -ENOLINK;
                        }

                        mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
                                                        lpagb);
                }

                lpa = __phy_read(phydev, MII_LPA);
                if (lpa < 0)
                        return lpa;

                mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
        } else {
                linkmode_zero(phydev->lp_advertising);
        }

        return 0;
}

/**
 * yt8521_adjust_status() - update speed and duplex to phydev. when in fiber
 * mode, adjust speed and duplex.
 * @phydev: a pointer to a &struct phy_device
 * @status: yt8521 status read from YTPHY_SPECIFIC_STATUS_REG
 * @is_utp: false(yt8521 work in fiber mode) or true(yt8521 work in utp mode)
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0
 */
static int yt8521_adjust_status(struct phy_device *phydev, int status,
                                bool is_utp)
{
        int speed_mode, duplex;
        int speed;
        int err;
        int lpa;

        if (is_utp)
                duplex = (status & YTPHY_SSR_DUPLEX) >> YTPHY_SSR_DUPLEX_OFFSET;
        else
                duplex = DUPLEX_FULL;   /* for fiber, it always DUPLEX_FULL */

        speed_mode = status & YTPHY_SSR_SPEED_MASK;

        switch (speed_mode) {
        case YTPHY_SSR_SPEED_10M:
                if (is_utp)
                        speed = SPEED_10;
                else
                        /* for fiber, it will never run here, default to
                         * SPEED_UNKNOWN
                         */
                        speed = SPEED_UNKNOWN;
                break;
        case YTPHY_SSR_SPEED_100M:
                speed = SPEED_100;
                break;
        case YTPHY_SSR_SPEED_1000M:
                speed = SPEED_1000;
                break;
        default:
                speed = SPEED_UNKNOWN;
                break;
        }

        phydev->speed = speed;
        phydev->duplex = duplex;

        if (is_utp) {
                err = ytphy_utp_read_lpa(phydev);
                if (err < 0)
                        return err;

                phy_resolve_aneg_pause(phydev);
        } else {
                lpa = __phy_read(phydev, MII_LPA);
                if (lpa < 0)
                        return lpa;

                /* only support 1000baseX Full */
                linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
                                 phydev->lp_advertising, lpa & LPA_1000XFULL);

                if (!(lpa & YTPHY_FLPA_PAUSE)) {
                        phydev->pause = 0;
                        phydev->asym_pause = 0;
                } else if ((lpa & YTPHY_FLPA_ASYM_PAUSE)) {
                        phydev->pause = 1;
                        phydev->asym_pause = 1;
                } else {
                        phydev->pause = 1;
                        phydev->asym_pause = 0;
                }
        }

        return 0;
}

/**
 * yt8521_read_status_paged() -  determines the speed and duplex of one page
 * @phydev: a pointer to a &struct phy_device
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
 * operate.
 *
 * returns 1 (utp or fiber link),0 (no link) or negative errno code
 */
static int yt8521_read_status_paged(struct phy_device *phydev, int page)
{
        int fiber_latch_val;
        int fiber_curr_val;
        int old_page;
        int ret = 0;
        int status;
        int link;

        linkmode_zero(phydev->lp_advertising);
        phydev->duplex = DUPLEX_UNKNOWN;
        phydev->speed = SPEED_UNKNOWN;
        phydev->asym_pause = 0;
        phydev->pause = 0;

        /* YT8521 has two reg space (utp/fiber) for linkup with utp/fiber
         * respectively. but for utp/fiber combo mode, reg space should be
         * arbitrated based on media priority. by default, utp takes
         * priority. reg space should be properly set before read
         * YTPHY_SPECIFIC_STATUS_REG.
         */

        page &= YT8521_RSSR_SPACE_MASK;
        old_page = phy_select_page(phydev, page);
        if (old_page < 0)
                goto err_restore_page;

        /* Read YTPHY_SPECIFIC_STATUS_REG, which indicates the speed and duplex
         * of the PHY is actually using.
         */
        ret = __phy_read(phydev, YTPHY_SPECIFIC_STATUS_REG);
        if (ret < 0)
                goto err_restore_page;

        status = ret;
        link = !!(status & YTPHY_SSR_LINK);

        /* When PHY is in fiber mode, speed transferred from 1000Mbps to
         * 100Mbps,there is not link down from YTPHY_SPECIFIC_STATUS_REG, so
         * we need check MII_BMSR to identify such case.
         */
        if (page == YT8521_RSSR_FIBER_SPACE) {
                ret = __phy_read(phydev, MII_BMSR);
                if (ret < 0)
                        goto err_restore_page;

                fiber_latch_val = ret;
                ret = __phy_read(phydev, MII_BMSR);
                if (ret < 0)
                        goto err_restore_page;

                fiber_curr_val = ret;
                if (link && fiber_latch_val != fiber_curr_val) {
                        link = 0;
                        phydev_info(phydev,
                                    "%s, fiber link down detect, latch = %04x, curr = %04x\n",
                                    __func__, fiber_latch_val, fiber_curr_val);
                }
        } else {
                /* Read autonegotiation status */
                ret = __phy_read(phydev, MII_BMSR);
                if (ret < 0)
                        goto err_restore_page;

                phydev->autoneg_complete = ret & BMSR_ANEGCOMPLETE ? 1 : 0;
        }

        if (link) {
                if (page == YT8521_RSSR_UTP_SPACE)
                        yt8521_adjust_status(phydev, status, true);
                else
                        yt8521_adjust_status(phydev, status, false);
        }
        return phy_restore_page(phydev, old_page, link);

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8521_read_status() -  determines the negotiated speed and duplex
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_read_status(struct phy_device *phydev)
{
        struct yt8521_priv *priv = phydev->priv;
        int link_fiber = 0;
        int link_utp;
        int link;
        int ret;

        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                link = yt8521_read_status_paged(phydev, priv->reg_page);
                if (link < 0)
                        return link;
        } else {
                /* when page is YT8521_RSSR_TO_BE_ARBITRATED, arbitration is
                 * needed. by default, utp is higher priority.
                 */

                link_utp = yt8521_read_status_paged(phydev,
                                                    YT8521_RSSR_UTP_SPACE);
                if (link_utp < 0)
                        return link_utp;

                if (!link_utp) {
                        link_fiber = yt8521_read_status_paged(phydev,
                                                              YT8521_RSSR_FIBER_SPACE);
                        if (link_fiber < 0)
                                return link_fiber;
                }

                link = link_utp || link_fiber;
        }

        if (link) {
                if (phydev->link == 0) {
                        /* arbitrate reg space based on linkup media type. */
                        if (priv->polling_mode == YT8521_MODE_POLL &&
                            priv->reg_page == YT8521_RSSR_TO_BE_ARBITRATED) {
                                if (link_fiber)
                                        priv->reg_page =
                                                YT8521_RSSR_FIBER_SPACE;
                                else
                                        priv->reg_page = YT8521_RSSR_UTP_SPACE;

                                ret = ytphy_write_ext_with_lock(phydev,
                                                                YT8521_REG_SPACE_SELECT_REG,
                                                                priv->reg_page);
                                if (ret < 0)
                                        return ret;

                                phydev->port = link_fiber ? PORT_FIBRE : PORT_TP;

                                phydev_info(phydev, "%s, link up, media: %s\n",
                                            __func__,
                                            (phydev->port == PORT_TP) ?
                                            "UTP" : "Fiber");
                        }
                }
                phydev->link = 1;
        } else {
                if (phydev->link == 1) {
                        phydev_info(phydev, "%s, link down, media: %s\n",
                                    __func__, (phydev->port == PORT_TP) ?
                                    "UTP" : "Fiber");

                        /* When in YT8521_MODE_POLL mode, need prepare for next
                         * arbitration.
                         */
                        if (priv->polling_mode == YT8521_MODE_POLL) {
                                priv->reg_page = YT8521_RSSR_TO_BE_ARBITRATED;
                                phydev->port = PORT_NONE;
                        }
                }

                phydev->link = 0;
        }

        return 0;
}

/**
 * yt8521_modify_bmcr_paged - bits modify a PHY's BMCR register of one page
 * @phydev: the phy_device struct
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to operate
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * NOTE: Convenience function which allows a PHY's BMCR register to be
 * modified as new register value = (old register value & ~mask) | set.
 * YT8521 has two space (utp/fiber) and three mode (utp/fiber/poll), each space
 * has MII_BMCR. poll mode combines utp and faber,so need do both.
 * If it is reset, it will wait for completion.
 *
 * returns 0 or negative errno code
 */
static int yt8521_modify_bmcr_paged(struct phy_device *phydev, int page,
                                    u16 mask, u16 set)
{
        int max_cnt = 500; /* the max wait time of reset ~ 500 ms */
        int old_page;
        int ret = 0;

        old_page = phy_select_page(phydev, page & YT8521_RSSR_SPACE_MASK);
        if (old_page < 0)
                goto err_restore_page;

        ret = __phy_modify(phydev, MII_BMCR, mask, set);
        if (ret < 0)
                goto err_restore_page;

        /* If it is reset, need to wait for the reset to complete */
        if (set == BMCR_RESET) {
                while (max_cnt--) {
                        usleep_range(1000, 1100);
                        ret = __phy_read(phydev, MII_BMCR);
                        if (ret < 0)
                                goto err_restore_page;

                        if (!(ret & BMCR_RESET))
                                return phy_restore_page(phydev, old_page, 0);
                }
        }

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8521_modify_utp_fiber_bmcr - bits modify a PHY's BMCR register
 * @phydev: the phy_device struct
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * NOTE: Convenience function which allows a PHY's BMCR register to be
 * modified as new register value = (old register value & ~mask) | set.
 * YT8521 has two space (utp/fiber) and three mode (utp/fiber/poll), each space
 * has MII_BMCR. poll mode combines utp and faber,so need do both.
 *
 * returns 0 or negative errno code
 */
static int yt8521_modify_utp_fiber_bmcr(struct phy_device *phydev, u16 mask,
                                        u16 set)
{
        struct yt8521_priv *priv = phydev->priv;
        int ret;

        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                ret = yt8521_modify_bmcr_paged(phydev, priv->reg_page, mask,
                                               set);
                if (ret < 0)
                        return ret;
        } else {
                ret = yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_UTP_SPACE,
                                               mask, set);
                if (ret < 0)
                        return ret;

                ret = yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_FIBER_SPACE,
                                               mask, set);
                if (ret < 0)
                        return ret;
        }
        return 0;
}

/**
 * yt8521_soft_reset() - called to issue a PHY software reset
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_soft_reset(struct phy_device *phydev)
{
        return yt8521_modify_utp_fiber_bmcr(phydev, 0, BMCR_RESET);
}

/**
 * yt8521_suspend() - suspend the hardware
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_suspend(struct phy_device *phydev)
{
        int wol_config;

        /* YTPHY_WOL_CONFIG_REG is common ext reg */
        wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
        if (wol_config < 0)
                return wol_config;

        /* if wol enable, do nothing */
        if (wol_config & YTPHY_WCR_ENABLE)
                return 0;

        return yt8521_modify_utp_fiber_bmcr(phydev, 0, BMCR_PDOWN);
}

/**
 * yt8521_resume() - resume the hardware
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_resume(struct phy_device *phydev)
{
        int ret;
        int wol_config;

        /* disable auto sleep */
        ret = ytphy_modify_ext_with_lock(phydev,
                                         YT8521_EXTREG_SLEEP_CONTROL1_REG,
                                         YT8521_ESC1R_SLEEP_SW, 0);
        if (ret < 0)
                return ret;

        wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
        if (wol_config < 0)
                return wol_config;

        /* if wol enable, do nothing */
        if (wol_config & YTPHY_WCR_ENABLE)
                return 0;

        return yt8521_modify_utp_fiber_bmcr(phydev, BMCR_PDOWN, 0);
}

/**
 * yt8521_config_init() - called to initialize the PHY
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_config_init(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        int old_page;
        int ret = 0;

        old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
        if (old_page < 0)
                goto err_restore_page;

        /* set rgmii delay mode */
        if (phydev->interface != PHY_INTERFACE_MODE_SGMII) {
                ret = ytphy_rgmii_clk_delay_config(phydev);
                if (ret < 0)
                        goto err_restore_page;
        }

        if (of_property_read_bool(node, "motorcomm,auto-sleep-disabled")) {
                /* disable auto sleep */
                ret = ytphy_modify_ext(phydev, YT8521_EXTREG_SLEEP_CONTROL1_REG,
                                       YT8521_ESC1R_SLEEP_SW, 0);
                if (ret < 0)
                        goto err_restore_page;
        }

        if (of_property_read_bool(node, "motorcomm,keep-pll-enabled")) {
                /* enable RXC clock when no wire plug */
                ret = ytphy_modify_ext(phydev, YT8521_CLOCK_GATING_REG,
                                       YT8521_CGR_RX_CLK_EN, 0);
                if (ret < 0)
                        goto err_restore_page;
        }
err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

static int yt8531_config_init(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        int ret;

        ret = ytphy_rgmii_clk_delay_config_with_lock(phydev);
        if (ret < 0)
                return ret;

        if (of_property_read_bool(node, "motorcomm,auto-sleep-disabled")) {
                /* disable auto sleep */
                ret = ytphy_modify_ext_with_lock(phydev,
                                                 YT8521_EXTREG_SLEEP_CONTROL1_REG,
                                                 YT8521_ESC1R_SLEEP_SW, 0);
                if (ret < 0)
                        return ret;
        }

        if (of_property_read_bool(node, "motorcomm,keep-pll-enabled")) {
                /* enable RXC clock when no wire plug */
                ret = ytphy_modify_ext_with_lock(phydev,
                                                 YT8521_CLOCK_GATING_REG,
                                                 YT8521_CGR_RX_CLK_EN, 0);
                if (ret < 0)
                        return ret;
        }

        ret = yt8531_set_ds(phydev);
        if (ret < 0)
                return ret;

        return 0;
}

/**
 * yt8531_link_change_notify() - Adjust the tx clock direction according to
 * the current speed and dts config.
 * @phydev: a pointer to a &struct phy_device
 *
 * NOTE: This function is only used to adapt to VF2 with JH7110 SoC. Please
 * keep "motorcomm,tx-clk-adj-enabled" not exist in dts when the soc is not
 * JH7110.
 */
static void yt8531_link_change_notify(struct phy_device *phydev)
{
        struct device_node *node = phydev->mdio.dev.of_node;
        bool tx_clk_1000_inverted = false;
        bool tx_clk_100_inverted = false;
        bool tx_clk_10_inverted = false;
        bool tx_clk_adj_enabled = false;
        u16 val = 0;
        int ret;

        if (of_property_read_bool(node, "motorcomm,tx-clk-adj-enabled"))
                tx_clk_adj_enabled = true;

        if (!tx_clk_adj_enabled)
                return;

        if (of_property_read_bool(node, "motorcomm,tx-clk-10-inverted"))
                tx_clk_10_inverted = true;
        if (of_property_read_bool(node, "motorcomm,tx-clk-100-inverted"))
                tx_clk_100_inverted = true;
        if (of_property_read_bool(node, "motorcomm,tx-clk-1000-inverted"))
                tx_clk_1000_inverted = true;

        if (phydev->speed < 0)
                return;

        switch (phydev->speed) {
        case SPEED_1000:
                if (tx_clk_1000_inverted)
                        val = YT8521_RC1R_TX_CLK_SEL_INVERTED;
                break;
        case SPEED_100:
                if (tx_clk_100_inverted)
                        val = YT8521_RC1R_TX_CLK_SEL_INVERTED;
                break;
        case SPEED_10:
                if (tx_clk_10_inverted)
                        val = YT8521_RC1R_TX_CLK_SEL_INVERTED;
                break;
        default:
                return;
        }

        ret = ytphy_modify_ext_with_lock(phydev, YT8521_RGMII_CONFIG1_REG,
                                         YT8521_RC1R_TX_CLK_SEL_INVERTED, val);
        if (ret < 0)
                phydev_warn(phydev, "Modify TX_CLK_SEL err:%d\n", ret);
}

/**
 * yt8521_prepare_fiber_features() -  A small helper function that setup
 * fiber's features.
 * @phydev: a pointer to a &struct phy_device
 * @dst: a pointer to store fiber's features
 */
static void yt8521_prepare_fiber_features(struct phy_device *phydev,
                                          unsigned long *dst)
{
        linkmode_set_bit(ETHTOOL_LINK_MODE_100baseFX_Full_BIT, dst);
        linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, dst);
        linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, dst);
        linkmode_set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, dst);
}

/**
 * yt8521_fiber_setup_forced - configures/forces speed from @phydev
 * @phydev: target phy_device struct
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int yt8521_fiber_setup_forced(struct phy_device *phydev)
{
        u16 val;
        int ret;

        if (phydev->speed == SPEED_1000)
                val = YTPHY_MCR_FIBER_1000BX;
        else if (phydev->speed == SPEED_100)
                val = YTPHY_MCR_FIBER_100FX;
        else
                return -EINVAL;

        ret =  __phy_modify(phydev, MII_BMCR, BMCR_ANENABLE, 0);
        if (ret < 0)
                return ret;

        /* disable Fiber auto sensing */
        ret =  ytphy_modify_ext(phydev, YT8521_LINK_TIMER_CFG2_REG,
                                YT8521_LTCR_EN_AUTOSEN, 0);
        if (ret < 0)
                return ret;

        ret =  ytphy_modify_ext(phydev, YTPHY_MISC_CONFIG_REG,
                                YTPHY_MCR_FIBER_SPEED_MASK, val);
        if (ret < 0)
                return ret;

        return ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
                                YT8521_CCR_SW_RST, 0);
}

/**
 * ytphy_check_and_restart_aneg - Enable and restart auto-negotiation
 * @phydev: target phy_device struct
 * @restart: whether aneg restart is requested
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
{
        int ret;

        if (!restart) {
                /* Advertisement hasn't changed, but maybe aneg was never on to
                 * begin with?  Or maybe phy was isolated?
                 */
                ret = __phy_read(phydev, MII_BMCR);
                if (ret < 0)
                        return ret;

                if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
                        restart = true;
        }
        /* Enable and Restart Autonegotiation
         * Don't isolate the PHY if we're negotiating
         */
        if (restart)
                return __phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
                                    BMCR_ANENABLE | BMCR_ANRESTART);

        return 0;
}

/**
 * yt8521_fiber_config_aneg - restart auto-negotiation or write
 * YTPHY_MISC_CONFIG_REG.
 * @phydev: target phy_device struct
 *
 * NOTE:The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int yt8521_fiber_config_aneg(struct phy_device *phydev)
{
        int err, changed = 0;
        int bmcr;
        u16 adv;

        if (phydev->autoneg != AUTONEG_ENABLE)
                return yt8521_fiber_setup_forced(phydev);

        /* enable Fiber auto sensing */
        err =  ytphy_modify_ext(phydev, YT8521_LINK_TIMER_CFG2_REG,
                                0, YT8521_LTCR_EN_AUTOSEN);
        if (err < 0)
                return err;

        err =  ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
                                YT8521_CCR_SW_RST, 0);
        if (err < 0)
                return err;

        bmcr = __phy_read(phydev, MII_BMCR);
        if (bmcr < 0)
                return bmcr;

        /* When it is coming from fiber forced mode, add bmcr power down
         * and power up to let aneg work fine.
         */
        if (!(bmcr & BMCR_ANENABLE)) {
                __phy_modify(phydev, MII_BMCR, 0, BMCR_PDOWN);
                usleep_range(1000, 1100);
                __phy_modify(phydev, MII_BMCR, BMCR_PDOWN, 0);
        }

        adv = linkmode_adv_to_mii_adv_x(phydev->advertising,
                                        ETHTOOL_LINK_MODE_1000baseX_Full_BIT);

        /* Setup fiber advertisement */
        err = __phy_modify_changed(phydev, MII_ADVERTISE,
                                   ADVERTISE_1000XHALF | ADVERTISE_1000XFULL |
                                   ADVERTISE_1000XPAUSE |
                                   ADVERTISE_1000XPSE_ASYM,
                                   adv);
        if (err < 0)
                return err;

        if (err > 0)
                changed = 1;

        return ytphy_check_and_restart_aneg(phydev, changed);
}

/**
 * ytphy_setup_master_slave
 * @phydev: target phy_device struct
 *
 * NOTE: The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_setup_master_slave(struct phy_device *phydev)
{
        u16 ctl = 0;

        if (!phydev->is_gigabit_capable)
                return 0;

        switch (phydev->master_slave_set) {
        case MASTER_SLAVE_CFG_MASTER_PREFERRED:
                ctl |= CTL1000_PREFER_MASTER;
                break;
        case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
                break;
        case MASTER_SLAVE_CFG_MASTER_FORCE:
                ctl |= CTL1000_AS_MASTER;
                fallthrough;
        case MASTER_SLAVE_CFG_SLAVE_FORCE:
                ctl |= CTL1000_ENABLE_MASTER;
                break;
        case MASTER_SLAVE_CFG_UNKNOWN:
        case MASTER_SLAVE_CFG_UNSUPPORTED:
                return 0;
        default:
                phydev_warn(phydev, "Unsupported Master/Slave mode\n");
                return -EOPNOTSUPP;
        }

        return __phy_modify_changed(phydev, MII_CTRL1000,
                                    (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
                                    CTL1000_PREFER_MASTER), ctl);
}

/**
 * ytphy_utp_config_advert - sanitize and advertise auto-negotiation parameters
 * @phydev: target phy_device struct
 *
 * NOTE: Writes MII_ADVERTISE with the appropriate values,
 * after sanitizing the values to make sure we only advertise
 * what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
 * hasn't changed, and > 0 if it has changed.
 * The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_utp_config_advert(struct phy_device *phydev)
{
        int err, bmsr, changed = 0;
        u32 adv;

        /* Only allow advertising what this PHY supports */
        linkmode_and(phydev->advertising, phydev->advertising,
                     phydev->supported);

        adv = linkmode_adv_to_mii_adv_t(phydev->advertising);

        /* Setup standard advertisement */
        err = __phy_modify_changed(phydev, MII_ADVERTISE,
                                   ADVERTISE_ALL | ADVERTISE_100BASE4 |
                                   ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
                                   adv);
        if (err < 0)
                return err;
        if (err > 0)
                changed = 1;

        bmsr = __phy_read(phydev, MII_BMSR);
        if (bmsr < 0)
                return bmsr;

        /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
         * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
         * logical 1.
         */
        if (!(bmsr & BMSR_ESTATEN))
                return changed;

        adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);

        err = __phy_modify_changed(phydev, MII_CTRL1000,
                                   ADVERTISE_1000FULL | ADVERTISE_1000HALF,
                                   adv);
        if (err < 0)
                return err;
        if (err > 0)
                changed = 1;

        return changed;
}

/**
 * ytphy_utp_config_aneg - restart auto-negotiation or write BMCR
 * @phydev: target phy_device struct
 * @changed: whether autoneg is requested
 *
 * NOTE: If auto-negotiation is enabled, we configure the
 * advertising, and then restart auto-negotiation.  If it is not
 * enabled, then we write the BMCR.
 * The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_utp_config_aneg(struct phy_device *phydev, bool changed)
{
        int err;
        u16 ctl;

        err = ytphy_setup_master_slave(phydev);
        if (err < 0)
                return err;
        else if (err)
                changed = true;

        if (phydev->autoneg != AUTONEG_ENABLE) {
                /* configures/forces speed/duplex from @phydev */

                ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);

                return __phy_modify(phydev, MII_BMCR, ~(BMCR_LOOPBACK |
                                    BMCR_ISOLATE | BMCR_PDOWN), ctl);
        }

        err = ytphy_utp_config_advert(phydev);
        if (err < 0) /* error */
                return err;
        else if (err)
                changed = true;

        return ytphy_check_and_restart_aneg(phydev, changed);
}

/**
 * yt8521_config_aneg_paged() - switch reg space then call genphy_config_aneg
 * of one page
 * @phydev: a pointer to a &struct phy_device
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
 * operate.
 *
 * returns 0 or negative errno code
 */
static int yt8521_config_aneg_paged(struct phy_device *phydev, int page)
{
        __ETHTOOL_DECLARE_LINK_MODE_MASK(fiber_supported);
        struct yt8521_priv *priv = phydev->priv;
        int old_page;
        int ret = 0;

        page &= YT8521_RSSR_SPACE_MASK;

        old_page = phy_select_page(phydev, page);
        if (old_page < 0)
                goto err_restore_page;

        /* If reg_page is YT8521_RSSR_TO_BE_ARBITRATED,
         * phydev->advertising should be updated.
         */
        if (priv->reg_page == YT8521_RSSR_TO_BE_ARBITRATED) {
                linkmode_zero(fiber_supported);
                yt8521_prepare_fiber_features(phydev, fiber_supported);

                /* prepare fiber_supported, then setup advertising. */
                if (page == YT8521_RSSR_FIBER_SPACE) {
                        linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
                                         fiber_supported);
                        linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
                                         fiber_supported);
                        linkmode_and(phydev->advertising,
                                     priv->combo_advertising, fiber_supported);
                } else {
                        /* ETHTOOL_LINK_MODE_Autoneg_BIT is also used in utp */
                        linkmode_clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
                                           fiber_supported);
                        linkmode_andnot(phydev->advertising,
                                        priv->combo_advertising,
                                        fiber_supported);
                }
        }

        if (page == YT8521_RSSR_FIBER_SPACE)
                ret = yt8521_fiber_config_aneg(phydev);
        else
                ret = ytphy_utp_config_aneg(phydev, false);

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8521_config_aneg() - change reg space then call yt8521_config_aneg_paged
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0 or negative errno code
 */
static int yt8521_config_aneg(struct phy_device *phydev)
{
        struct yt8521_priv *priv = phydev->priv;
        int ret;

        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                ret = yt8521_config_aneg_paged(phydev, priv->reg_page);
                if (ret < 0)
                        return ret;
        } else {
                /* If reg_page is YT8521_RSSR_TO_BE_ARBITRATED,
                 * phydev->advertising need to be saved at first run.
                 * Because it contains the advertising which supported by both
                 * mac and yt8521(utp and fiber).
                 */
                if (linkmode_empty(priv->combo_advertising)) {
                        linkmode_copy(priv->combo_advertising,
                                      phydev->advertising);
                }

                ret = yt8521_config_aneg_paged(phydev, YT8521_RSSR_UTP_SPACE);
                if (ret < 0)
                        return ret;

                ret = yt8521_config_aneg_paged(phydev, YT8521_RSSR_FIBER_SPACE);
                if (ret < 0)
                        return ret;

                /* we don't known which will be link, so restore
                 * phydev->advertising as default value.
                 */
                linkmode_copy(phydev->advertising, priv->combo_advertising);
        }
        return 0;
}

/**
 * yt8521_aneg_done_paged() - determines the auto negotiation result of one
 * page.
 * @phydev: a pointer to a &struct phy_device
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
 * operate.
 *
 * returns 0(no link)or 1(fiber or utp link) or negative errno code
 */
static int yt8521_aneg_done_paged(struct phy_device *phydev, int page)
{
        int old_page;
        int ret = 0;
        int link;

        old_page = phy_select_page(phydev, page & YT8521_RSSR_SPACE_MASK);
        if (old_page < 0)
                goto err_restore_page;

        ret = __phy_read(phydev, YTPHY_SPECIFIC_STATUS_REG);
        if (ret < 0)
                goto err_restore_page;

        link = !!(ret & YTPHY_SSR_LINK);
        ret = link;

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8521_aneg_done() - determines the auto negotiation result
 * @phydev: a pointer to a &struct phy_device
 *
 * returns 0(no link)or 1(fiber or utp link) or negative errno code
 */
static int yt8521_aneg_done(struct phy_device *phydev)
{
        struct yt8521_priv *priv = phydev->priv;
        int link_fiber = 0;
        int link_utp;
        int link;

        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                link = yt8521_aneg_done_paged(phydev, priv->reg_page);
        } else {
                link_utp = yt8521_aneg_done_paged(phydev,
                                                  YT8521_RSSR_UTP_SPACE);
                if (link_utp < 0)
                        return link_utp;

                if (!link_utp) {
                        link_fiber = yt8521_aneg_done_paged(phydev,
                                                            YT8521_RSSR_FIBER_SPACE);
                        if (link_fiber < 0)
                                return link_fiber;
                }
                link = link_fiber || link_utp;
                phydev_info(phydev, "%s, link_fiber: %d, link_utp: %d\n",
                            __func__, link_fiber, link_utp);
        }

        return link;
}

/**
 * ytphy_utp_read_abilities - read PHY abilities from Clause 22 registers
 * @phydev: target phy_device struct
 *
 * NOTE: Reads the PHY's abilities and populates
 * phydev->supported accordingly.
 * The caller must have taken the MDIO bus lock.
 *
 * returns 0 or negative errno code
 */
static int ytphy_utp_read_abilities(struct phy_device *phydev)
{
        int val;

        linkmode_set_bit_array(phy_basic_ports_array,
                               ARRAY_SIZE(phy_basic_ports_array),
                               phydev->supported);

        val = __phy_read(phydev, MII_BMSR);
        if (val < 0)
                return val;

        linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
                         val & BMSR_ANEGCAPABLE);

        linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
                         val & BMSR_100FULL);
        linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
                         val & BMSR_100HALF);
        linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
                         val & BMSR_10FULL);
        linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
                         val & BMSR_10HALF);

        if (val & BMSR_ESTATEN) {
                val = __phy_read(phydev, MII_ESTATUS);
                if (val < 0)
                        return val;

                linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
                                 phydev->supported, val & ESTATUS_1000_TFULL);
                linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
                                 phydev->supported, val & ESTATUS_1000_THALF);
                linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
                                 phydev->supported, val & ESTATUS_1000_XFULL);
        }

        return 0;
}

/**
 * yt8521_get_features_paged() -  read supported link modes for one page
 * @phydev: a pointer to a &struct phy_device
 * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
 * operate.
 *
 * returns 0 or negative errno code
 */
static int yt8521_get_features_paged(struct phy_device *phydev, int page)
{
        int old_page;
        int ret = 0;

        page &= YT8521_RSSR_SPACE_MASK;
        old_page = phy_select_page(phydev, page);
        if (old_page < 0)
                goto err_restore_page;

        if (page == YT8521_RSSR_FIBER_SPACE) {
                linkmode_zero(phydev->supported);
                yt8521_prepare_fiber_features(phydev, phydev->supported);
        } else {
                ret = ytphy_utp_read_abilities(phydev);
                if (ret < 0)
                        goto err_restore_page;
        }

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8521_get_features - switch reg space then call yt8521_get_features_paged
 * @phydev: target phy_device struct
 *
 * returns 0 or negative errno code
 */
static int yt8521_get_features(struct phy_device *phydev)
{
        struct yt8521_priv *priv = phydev->priv;
        int ret;

        if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
                ret = yt8521_get_features_paged(phydev, priv->reg_page);
        } else {
                ret = yt8521_get_features_paged(phydev,
                                                YT8521_RSSR_UTP_SPACE);
                if (ret < 0)
                        return ret;

                /* add fiber's features to phydev->supported */
                yt8521_prepare_fiber_features(phydev, phydev->supported);
        }
        return ret;
}

/**
 * yt8821_get_features - read mmd register to get 2.5G capability
 * @phydev: target phy_device struct
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_get_features(struct phy_device *phydev)
{
        int ret;

        ret = genphy_c45_pma_read_ext_abilities(phydev);
        if (ret < 0)
                return ret;

        return genphy_read_abilities(phydev);
}

/**
 * yt8821_get_rate_matching - read register to get phy chip mode
 * @phydev: target phy_device struct
 * @iface: PHY data interface type
 *
 * Returns: rate matching type or negative errno code
 */
static int yt8821_get_rate_matching(struct phy_device *phydev,
                                    phy_interface_t iface)
{
        int val;

        val = ytphy_read_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG);
        if (val < 0)
                return val;

        if (FIELD_GET(YT8521_CCR_MODE_SEL_MASK, val) ==
            YT8821_CHIP_MODE_FORCE_BX2500)
                return RATE_MATCH_PAUSE;

        return RATE_MATCH_NONE;
}

/**
 * yt8821_aneg_done() - determines the auto negotiation result
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0(no link)or 1(utp link) or negative errno code
 */
static int yt8821_aneg_done(struct phy_device *phydev)
{
        return yt8521_aneg_done_paged(phydev, YT8521_RSSR_UTP_SPACE);
}

/**
 * yt8821_serdes_init() - serdes init
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_serdes_init(struct phy_device *phydev)
{
        int old_page;
        int ret = 0;
        u16 mask;
        u16 set;

        old_page = phy_select_page(phydev, YT8521_RSSR_FIBER_SPACE);
        if (old_page < 0) {
                phydev_err(phydev, "Failed to select page: %d\n",
                           old_page);
                goto err_restore_page;
        }

        ret = __phy_modify(phydev, MII_BMCR, BMCR_ANENABLE, 0);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_SDS_EXT_CSR_VCO_LDO_EN |
                YT8821_SDS_EXT_CSR_VCO_BIAS_LPF_EN;
        set = YT8821_SDS_EXT_CSR_VCO_LDO_EN;
        ret = ytphy_modify_ext(phydev, YT8821_SDS_EXT_CSR_CTRL_REG, mask,
                               set);

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8821_utp_init() - utp init
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_utp_init(struct phy_device *phydev)
{
        int old_page;
        int ret = 0;
        u16 mask;
        u16 save;
        u16 set;

        old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
        if (old_page < 0) {
                phydev_err(phydev, "Failed to select page: %d\n",
                           old_page);
                goto err_restore_page;
        }

        mask = YT8821_UTP_EXT_RPDN_BP_FFE_LNG_2500 |
                YT8821_UTP_EXT_RPDN_BP_FFE_SHT_2500 |
                YT8821_UTP_EXT_RPDN_IPR_SHT_2500;
        set = YT8821_UTP_EXT_RPDN_BP_FFE_LNG_2500 |
                YT8821_UTP_EXT_RPDN_BP_FFE_SHT_2500;
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_RPDN_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_VGA_LPF1_CAP_OTHER |
                YT8821_UTP_EXT_VGA_LPF1_CAP_2500;
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_VGA_LPF1_CAP_CTRL_REG,
                               mask, 0);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_VGA_LPF2_CAP_OTHER |
                YT8821_UTP_EXT_VGA_LPF2_CAP_2500;
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_VGA_LPF2_CAP_CTRL_REG,
                               mask, 0);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_TRACE_LNG_GAIN_THE_2500 |
                YT8821_UTP_EXT_TRACE_MED_GAIN_THE_2500;
        set = FIELD_PREP(YT8821_UTP_EXT_TRACE_LNG_GAIN_THE_2500, 0x5a) |
                FIELD_PREP(YT8821_UTP_EXT_TRACE_MED_GAIN_THE_2500, 0x3c);
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_TRACE_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_IPR_LNG_2500;
        set = FIELD_PREP(YT8821_UTP_EXT_IPR_LNG_2500, 0x6c);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_ALPHA_IPR_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_TRACE_LNG_GAIN_THR_1000;
        set = FIELD_PREP(YT8821_UTP_EXT_TRACE_LNG_GAIN_THR_1000, 0x2a);
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_ECHO_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_TRACE_MED_GAIN_THR_1000;
        set = FIELD_PREP(YT8821_UTP_EXT_TRACE_MED_GAIN_THR_1000, 0x22);
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_GAIN_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_TH_20DB_2500;
        set = FIELD_PREP(YT8821_UTP_EXT_TH_20DB_2500, 0x8000);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_TH_20DB_2500_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_MU_COARSE_FR_F_FFE |
                YT8821_UTP_EXT_MU_COARSE_FR_F_FBE;
        set = FIELD_PREP(YT8821_UTP_EXT_MU_COARSE_FR_F_FFE, 0x7) |
                FIELD_PREP(YT8821_UTP_EXT_MU_COARSE_FR_F_FBE, 0x7);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_MU_COARSE_FR_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_MU_FINE_FR_F_FFE |
                YT8821_UTP_EXT_MU_FINE_FR_F_FBE;
        set = FIELD_PREP(YT8821_UTP_EXT_MU_FINE_FR_F_FFE, 0x2) |
                FIELD_PREP(YT8821_UTP_EXT_MU_FINE_FR_F_FBE, 0x2);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_MU_FINE_FR_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        /* save YT8821_UTP_EXT_PI_CTRL_REG's val for use later */
        ret = ytphy_read_ext(phydev, YT8821_UTP_EXT_PI_CTRL_REG);
        if (ret < 0)
                goto err_restore_page;

        save = ret;

        mask = YT8821_UTP_EXT_PI_TX_CLK_SEL_AFE |
                YT8821_UTP_EXT_PI_RX_CLK_3_SEL_AFE |
                YT8821_UTP_EXT_PI_RX_CLK_2_SEL_AFE |
                YT8821_UTP_EXT_PI_RX_CLK_1_SEL_AFE |
                YT8821_UTP_EXT_PI_RX_CLK_0_SEL_AFE;
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_PI_CTRL_REG,
                               mask, 0);
        if (ret < 0)
                goto err_restore_page;

        /* restore YT8821_UTP_EXT_PI_CTRL_REG's val */
        ret = ytphy_write_ext(phydev, YT8821_UTP_EXT_PI_CTRL_REG, save);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_FECHO_AMP_TH_HUGE;
        set = FIELD_PREP(YT8821_UTP_EXT_FECHO_AMP_TH_HUGE, 0x38);
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_VCT_CFG6_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_NFR_TX_ABILITY;
        set = YT8821_UTP_EXT_NFR_TX_ABILITY;
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_TXGE_NFR_FR_THP_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_PLL_SPARE_CFG;
        set = FIELD_PREP(YT8821_UTP_EXT_PLL_SPARE_CFG, 0xe9);
        ret = ytphy_modify_ext(phydev, YT8821_UTP_EXT_PLL_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_DAC_IMID_CH_3_10_ORG |
                YT8821_UTP_EXT_DAC_IMID_CH_2_10_ORG;
        set = FIELD_PREP(YT8821_UTP_EXT_DAC_IMID_CH_3_10_ORG, 0x64) |
                FIELD_PREP(YT8821_UTP_EXT_DAC_IMID_CH_2_10_ORG, 0x64);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_DAC_IMID_CH_2_3_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_DAC_IMID_CH_1_10_ORG |
                YT8821_UTP_EXT_DAC_IMID_CH_0_10_ORG;
        set = FIELD_PREP(YT8821_UTP_EXT_DAC_IMID_CH_1_10_ORG, 0x64) |
                FIELD_PREP(YT8821_UTP_EXT_DAC_IMID_CH_0_10_ORG, 0x64);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_DAC_IMID_CH_0_1_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_DAC_IMSB_CH_3_10_ORG |
                YT8821_UTP_EXT_DAC_IMSB_CH_2_10_ORG;
        set = FIELD_PREP(YT8821_UTP_EXT_DAC_IMSB_CH_3_10_ORG, 0x64) |
                FIELD_PREP(YT8821_UTP_EXT_DAC_IMSB_CH_2_10_ORG, 0x64);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_DAC_IMSB_CH_2_3_CTRL_REG,
                               mask, set);
        if (ret < 0)
                goto err_restore_page;

        mask = YT8821_UTP_EXT_DAC_IMSB_CH_1_10_ORG |
                YT8821_UTP_EXT_DAC_IMSB_CH_0_10_ORG;
        set = FIELD_PREP(YT8821_UTP_EXT_DAC_IMSB_CH_1_10_ORG, 0x64) |
                FIELD_PREP(YT8821_UTP_EXT_DAC_IMSB_CH_0_10_ORG, 0x64);
        ret = ytphy_modify_ext(phydev,
                               YT8821_UTP_EXT_DAC_IMSB_CH_0_1_CTRL_REG,
                               mask, set);

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8821_auto_sleep_config() - phy auto sleep config
 * @phydev: a pointer to a &struct phy_device
 * @enable: true enable auto sleep, false disable auto sleep
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_auto_sleep_config(struct phy_device *phydev,
                                    bool enable)
{
        int old_page;
        int ret = 0;

        old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
        if (old_page < 0) {
                phydev_err(phydev, "Failed to select page: %d\n",
                           old_page);
                goto err_restore_page;
        }

        ret = ytphy_modify_ext(phydev,
                               YT8521_EXTREG_SLEEP_CONTROL1_REG,
                               YT8521_ESC1R_SLEEP_SW,
                               enable ? 1 : 0);

err_restore_page:
        return phy_restore_page(phydev, old_page, ret);
}

/**
 * yt8821_soft_reset() - soft reset utp and serdes
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_soft_reset(struct phy_device *phydev)
{
        return ytphy_modify_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG,
                                          YT8521_CCR_SW_RST, 0);
}

/**
 * yt8821_config_init() - phy initializatioin
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_config_init(struct phy_device *phydev)
{
        u8 mode = YT8821_CHIP_MODE_AUTO_BX2500_SGMII;
        int ret;
        u16 set;

        if (phydev->interface == PHY_INTERFACE_MODE_2500BASEX)
                mode = YT8821_CHIP_MODE_FORCE_BX2500;

        set = FIELD_PREP(YT8521_CCR_MODE_SEL_MASK, mode);
        ret = ytphy_modify_ext_with_lock(phydev,
                                         YT8521_CHIP_CONFIG_REG,
                                         YT8521_CCR_MODE_SEL_MASK,
                                         set);
        if (ret < 0)
                return ret;

        __set_bit(PHY_INTERFACE_MODE_2500BASEX,
                  phydev->possible_interfaces);

        if (mode == YT8821_CHIP_MODE_AUTO_BX2500_SGMII) {
                __set_bit(PHY_INTERFACE_MODE_SGMII,
                          phydev->possible_interfaces);

                phydev->rate_matching = RATE_MATCH_NONE;
        } else if (mode == YT8821_CHIP_MODE_FORCE_BX2500) {
                phydev->rate_matching = RATE_MATCH_PAUSE;
        }

        ret = yt8821_serdes_init(phydev);
        if (ret < 0)
                return ret;

        ret = yt8821_utp_init(phydev);
        if (ret < 0)
                return ret;

        /* disable auto sleep */
        ret = yt8821_auto_sleep_config(phydev, false);
        if (ret < 0)
                return ret;

        /* soft reset */
        return yt8821_soft_reset(phydev);
}

/**
 * yt8821_adjust_status() - update speed and duplex to phydev
 * @phydev: a pointer to a &struct phy_device
 * @val: read from YTPHY_SPECIFIC_STATUS_REG
 */
static void yt8821_adjust_status(struct phy_device *phydev, int val)
{
        int speed, duplex;
        int speed_mode;

        duplex = FIELD_GET(YTPHY_SSR_DUPLEX, val);
        speed_mode = val & YTPHY_SSR_SPEED_MASK;
        switch (speed_mode) {
        case YTPHY_SSR_SPEED_10M:
                speed = SPEED_10;
                break;
        case YTPHY_SSR_SPEED_100M:
                speed = SPEED_100;
                break;
        case YTPHY_SSR_SPEED_1000M:
                speed = SPEED_1000;
                break;
        case YTPHY_SSR_SPEED_2500M:
                speed = SPEED_2500;
                break;
        default:
                speed = SPEED_UNKNOWN;
                break;
        }

        phydev->speed = speed;
        phydev->duplex = duplex;
}

/**
 * yt8821_update_interface() - update interface per current speed
 * @phydev: a pointer to a &struct phy_device
 */
static void yt8821_update_interface(struct phy_device *phydev)
{
        if (!phydev->link)
                return;

        switch (phydev->speed) {
        case SPEED_2500:
                phydev->interface = PHY_INTERFACE_MODE_2500BASEX;
                break;
        case SPEED_1000:
        case SPEED_100:
        case SPEED_10:
                phydev->interface = PHY_INTERFACE_MODE_SGMII;
                break;
        default:
                phydev_warn(phydev, "phy speed err :%d\n", phydev->speed);
                break;
        }
}

/**
 * yt8821_read_status() -  determines the negotiated speed and duplex
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_read_status(struct phy_device *phydev)
{
        int link;
        int ret;
        int val;

        ret = ytphy_write_ext_with_lock(phydev,
                                        YT8521_REG_SPACE_SELECT_REG,
                                        YT8521_RSSR_UTP_SPACE);
        if (ret < 0)
                return ret;

        ret = genphy_read_status(phydev);
        if (ret < 0)
                return ret;

        if (phydev->autoneg_complete) {
                ret = genphy_c45_read_lpa(phydev);
                if (ret < 0)
                        return ret;
        }

        ret = phy_read(phydev, YTPHY_SPECIFIC_STATUS_REG);
        if (ret < 0)
                return ret;

        val = ret;

        link = val & YTPHY_SSR_LINK;
        if (link)
                yt8821_adjust_status(phydev, val);

        if (link) {
                if (phydev->link == 0)
                        phydev_dbg(phydev,
                                   "%s, phy addr: %d, link up\n",
                                   __func__, phydev->mdio.addr);
                phydev->link = 1;
        } else {
                if (phydev->link == 1)
                        phydev_dbg(phydev,
                                   "%s, phy addr: %d, link down\n",
                                   __func__, phydev->mdio.addr);
                phydev->link = 0;
        }

        val = ytphy_read_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG);
        if (val < 0)
                return val;

        if (FIELD_GET(YT8521_CCR_MODE_SEL_MASK, val) ==
            YT8821_CHIP_MODE_AUTO_BX2500_SGMII)
                yt8821_update_interface(phydev);

        return 0;
}

/**
 * yt8821_modify_utp_fiber_bmcr - bits modify a PHY's BMCR register
 * @phydev: the phy_device struct
 * @mask: bit mask of bits to clear
 * @set: bit mask of bits to set
 *
 * NOTE: Convenience function which allows a PHY's BMCR register to be
 * modified as new register value = (old register value & ~mask) | set.
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_modify_utp_fiber_bmcr(struct phy_device *phydev,
                                        u16 mask, u16 set)
{
        int ret;

        ret = yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_UTP_SPACE,
                                       mask, set);
        if (ret < 0)
                return ret;

        return yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_FIBER_SPACE,
                                        mask, set);
}

/**
 * yt8821_suspend() - suspend the hardware
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_suspend(struct phy_device *phydev)
{
        int wol_config;

        wol_config = ytphy_read_ext_with_lock(phydev,
                                              YTPHY_WOL_CONFIG_REG);
        if (wol_config < 0)
                return wol_config;

        /* if wol enable, do nothing */
        if (wol_config & YTPHY_WCR_ENABLE)
                return 0;

        return yt8821_modify_utp_fiber_bmcr(phydev, 0, BMCR_PDOWN);
}

/**
 * yt8821_resume() - resume the hardware
 * @phydev: a pointer to a &struct phy_device
 *
 * Returns: 0 or negative errno code
 */
static int yt8821_resume(struct phy_device *phydev)
{
        int wol_config;
        int ret;

        /* disable auto sleep */
        ret = yt8821_auto_sleep_config(phydev, false);
        if (ret < 0)
                return ret;

        wol_config = ytphy_read_ext_with_lock(phydev,
                                              YTPHY_WOL_CONFIG_REG);
        if (wol_config < 0)
                return wol_config;

        /* if wol enable, do nothing */
        if (wol_config & YTPHY_WCR_ENABLE)
                return 0;

        return yt8821_modify_utp_fiber_bmcr(phydev, BMCR_PDOWN, 0);
}

static struct phy_driver motorcomm_phy_drvs[] = {
        {
                PHY_ID_MATCH_EXACT(PHY_ID_YT8511),
                .name           = "YT8511 Gigabit Ethernet",
                .config_init    = yt8511_config_init,
                .suspend        = genphy_suspend,
                .resume         = genphy_resume,
                .read_page      = yt8511_read_page,
                .write_page     = yt8511_write_page,
        },
        {
                PHY_ID_MATCH_EXACT(PHY_ID_YT8521),
                .name           = "YT8521 Gigabit Ethernet",
                .get_features   = yt8521_get_features,
                .probe          = yt8521_probe,
                .read_page      = yt8521_read_page,
                .write_page     = yt8521_write_page,
                .get_wol        = ytphy_get_wol,
                .set_wol        = ytphy_set_wol,
                .config_aneg    = yt8521_config_aneg,
                .aneg_done      = yt8521_aneg_done,
                .config_init    = yt8521_config_init,
                .read_status    = yt8521_read_status,
                .soft_reset     = yt8521_soft_reset,
                .suspend        = yt8521_suspend,
                .resume         = yt8521_resume,
        },
        {
                PHY_ID_MATCH_EXACT(PHY_ID_YT8531),
                .name           = "YT8531 Gigabit Ethernet",
                .probe          = yt8531_probe,
                .config_init    = yt8531_config_init,
                .suspend        = genphy_suspend,
                .resume         = genphy_resume,
                .get_wol        = ytphy_get_wol,
                .set_wol        = yt8531_set_wol,
                .link_change_notify = yt8531_link_change_notify,
        },
        {
                PHY_ID_MATCH_EXACT(PHY_ID_YT8531S),
                .name           = "YT8531S Gigabit Ethernet",
                .get_features   = yt8521_get_features,
                .probe          = yt8521_probe,
                .read_page      = yt8521_read_page,
                .write_page     = yt8521_write_page,
                .get_wol        = ytphy_get_wol,
                .set_wol        = ytphy_set_wol,
                .config_aneg    = yt8521_config_aneg,
                .aneg_done      = yt8521_aneg_done,
                .config_init    = yt8521_config_init,
                .read_status    = yt8521_read_status,
                .soft_reset     = yt8521_soft_reset,
                .suspend        = yt8521_suspend,
                .resume         = yt8521_resume,
        },
        {
                PHY_ID_MATCH_EXACT(PHY_ID_YT8821),
                .name                   = "YT8821 2.5Gbps PHY",
                .get_features           = yt8821_get_features,
                .read_page              = yt8521_read_page,
                .write_page             = yt8521_write_page,
                .get_wol                = ytphy_get_wol,
                .set_wol                = ytphy_set_wol,
                .config_aneg            = genphy_config_aneg,
                .aneg_done              = yt8821_aneg_done,
                .config_init            = yt8821_config_init,
                .get_rate_matching      = yt8821_get_rate_matching,
                .read_status            = yt8821_read_status,
                .soft_reset             = yt8821_soft_reset,
                .suspend                = yt8821_suspend,
                .resume                 = yt8821_resume,
        },
};

module_phy_driver(motorcomm_phy_drvs);

MODULE_DESCRIPTION("Motorcomm 8511/8521/8531/8531S/8821 PHY driver");
MODULE_AUTHOR("Peter Geis");
MODULE_AUTHOR("Frank");
MODULE_LICENSE("GPL");

static const struct mdio_device_id __maybe_unused motorcomm_tbl[] = {
        { PHY_ID_MATCH_EXACT(PHY_ID_YT8511) },
        { PHY_ID_MATCH_EXACT(PHY_ID_YT8521) },
        { PHY_ID_MATCH_EXACT(PHY_ID_YT8531) },
        { PHY_ID_MATCH_EXACT(PHY_ID_YT8531S) },
        { PHY_ID_MATCH_EXACT(PHY_ID_YT8821) },
        { /* sentinel */ }
};

MODULE_DEVICE_TABLE(mdio, motorcomm_tbl);